// clang-format off
/*
 * Copyright (c) 2020, 2025, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0,
 * as published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms,
 * as designated in a particular file or component or in included license
 * documentation.  The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
 * the GNU General Public License, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */




// Generated from /home/paandrus/dev/ngshell/mysqlshdk/libs/parser/grammars/MySQLParser.g4 by ANTLR 4.10.1


#include "MySQLParserListener.h"
#include "MySQLParserVisitor.h"

#include "MySQLParser.h"

#include "mysqlshdk/libs/parser/MySQLBaseRecognizer.h"

using namespace antlrcpp;
using namespace parsers;

using namespace antlr4;

namespace {

struct MySQLParserStaticData final {
  MySQLParserStaticData(std::vector<std::string> ruleNames,
                        std::vector<std::string> literalNames,
                        std::vector<std::string> symbolicNames)
      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
        symbolicNames(std::move(symbolicNames)),
        vocabulary(this->literalNames, this->symbolicNames) {}

  MySQLParserStaticData(const MySQLParserStaticData&) = delete;
  MySQLParserStaticData(MySQLParserStaticData&&) = delete;
  MySQLParserStaticData& operator=(const MySQLParserStaticData&) = delete;
  MySQLParserStaticData& operator=(MySQLParserStaticData&&) = delete;

  std::vector<antlr4::dfa::DFA> decisionToDFA;
  antlr4::atn::PredictionContextCache sharedContextCache;
  const std::vector<std::string> ruleNames;
  const std::vector<std::string> literalNames;
  const std::vector<std::string> symbolicNames;
  const antlr4::dfa::Vocabulary vocabulary;
  antlr4::atn::SerializedATNView serializedATN;
  std::unique_ptr<antlr4::atn::ATN> atn;
};

std::once_flag mysqlparserParserOnceFlag;
MySQLParserStaticData *mysqlparserParserStaticData = nullptr;

void mysqlparserParserInitialize() {
  assert(mysqlparserParserStaticData == nullptr);
  auto staticData = std::make_unique<MySQLParserStaticData>(
    std::vector<std::string>{
      "query", "simpleStatement", "alterStatement", "alterDatabase", "alterDatabaseOption", 
      "alterEvent", "alterLogfileGroup", "alterLogfileGroupOptions", "alterLogfileGroupOption", 
      "alterServer", "alterTable", "alterTableActions", "alterCommandList", 
      "alterCommandsModifierList", "standaloneAlterCommands", "alterPartition", 
      "alterList", "alterCommandsModifier", "alterListItem", "place", "restrict", 
      "alterOrderList", "alterAlgorithmOption", "alterLockOption", "indexLockAndAlgorithm", 
      "withValidation", "removePartitioning", "allOrPartitionNameList", 
      "alterTablespace", "alterUndoTablespace", "undoTableSpaceOptions", 
      "undoTableSpaceOption", "alterTablespaceOptions", "alterTablespaceOption", 
      "changeTablespaceOption", "alterView", "viewTail", "viewQueryBlock", 
      "viewCheckOption", "alterInstanceStatement", "createStatement", "createDatabase", 
      "createDatabaseOption", "createTable", "tableElementList", "tableElement", 
      "duplicateAsQe", "asCreateQueryExpression", "queryExpressionOrParens", 
      "queryExpressionWithOptLockingClauses", "createRoutine", "createProcedure", 
      "routineString", "storedRoutineBody", "createFunction", "createUdf", 
      "routineCreateOption", "libraryList", "libraryNameWithAlias", "routineAlterOptions", 
      "routineOption", "createIndex", "indexNameAndType", "createIndexTarget", 
      "createLogfileGroup", "logfileGroupOptions", "logfileGroupOption", 
      "createServer", "serverOptions", "serverOption", "createTablespace", 
      "createUndoTablespace", "createLibrary", "tsDataFileName", "tsDataFile", 
      "tablespaceOptions", "tablespaceOption", "tsOptionInitialSize", "tsOptionUndoRedoBufferSize", 
      "tsOptionAutoextendSize", "tsOptionMaxSize", "tsOptionExtentSize", 
      "tsOptionNodegroup", "tsOptionEngine", "tsOptionWait", "tsOptionComment", 
      "tsOptionFileblockSize", "tsOptionEncryption", "tsOptionEngineAttribute", 
      "createView", "viewReplaceOrAlgorithm", "viewAlgorithm", "viewSuid", 
      "createTrigger", "triggerFollowsPrecedesClause", "createEvent", "createRole", 
      "createSpatialReference", "srsAttribute", "dropStatement", "dropDatabase", 
      "dropEvent", "dropFunction", "dropProcedure", "dropIndex", "dropLogfileGroup", 
      "dropLogfileGroupOption", "dropServer", "dropTable", "dropTableSpace", 
      "dropTrigger", "dropView", "dropRole", "dropSpatialReference", "dropUndoTablespace", 
      "dropLibrary", "renameTableStatement", "renamePair", "truncateTableStatement", 
      "importStatement", "callStatement", "deleteStatement", "partitionDelete", 
      "deleteStatementOption", "doStatement", "handlerStatement", "handlerReadOrScan", 
      "insertStatement", "insertLockOption", "insertFromConstructor", "fields", 
      "insertValues", "insertQueryExpression", "valueList", "values", "valuesReference", 
      "insertUpdateList", "loadStatement", "dataOrXml", "loadDataLock", 
      "loadFrom", "loadSourceType", "sourceCount", "sourceOrder", "xmlRowsIdentifiedBy", 
      "loadDataFileTail", "loadDataFileTargetList", "fieldOrVariableList", 
      "loadAlgorithm", "compressionAlgorithm", "loadParallel", "loadMemory", 
      "replaceStatement", "selectStatement", "selectStatementWithInto", 
      "queryExpression", "queryExpressionBody", "queryExpressionParens", 
      "queryPrimary", "querySpecification", "subquery", "querySpecOption", 
      "limitClause", "simpleLimitClause", "limitOptions", "limitOption", 
      "outfileURI", "outfileFileInfo", "outfileFileInfoList", "outfileFileInfoElem", 
      "intoClause", "procedureAnalyseClause", "havingClause", "qualifyClause", 
      "windowClause", "windowDefinition", "windowSpec", "windowSpecDetails", 
      "windowFrameClause", "windowFrameUnits", "windowFrameExtent", "windowFrameStart", 
      "windowFrameBetween", "windowFrameBound", "windowFrameExclusion", 
      "withClause", "commonTableExpression", "groupByClause", "olapOption", 
      "orderClause", "direction", "fromClause", "tableReferenceList", "tableValueConstructor", 
      "explicitTable", "rowValueExplicit", "selectOption", "lockingClauseList", 
      "lockingClause", "lockStrengh", "lockedRowAction", "selectItemList", 
      "selectItem", "selectAlias", "whereClause", "tableReference", "escapedTableReference", 
      "joinedTable", "naturalJoinType", "innerJoinType", "outerJoinType", 
      "tableFactor", "singleTable", "singleTableParens", "derivedTable", 
      "tableReferenceListParens", "tableFunction", "columnsClause", "jtColumn", 
      "onEmptyOrError", "onEmptyOrErrorJsonTable", "onEmpty", "onError", 
      "jsonOnResponse", "unionOption", "tableAlias", "indexHintList", "indexHint", 
      "indexHintType", "keyOrIndex", "constraintKeyType", "indexHintClause", 
      "indexList", "indexListElement", "updateStatement", "transactionOrLockingStatement", 
      "transactionStatement", "beginWork", "startTransactionOptionList", 
      "savepointStatement", "lockStatement", "lockItem", "lockOption", "xaStatement", 
      "xaConvert", "xid", "replicationStatement", "purgeOptions", "resetOption", 
      "masterOrBinaryLogsAndGtids", "sourceResetOptions", "replicationSource", 
      "changeReplicationSource", "sourceDefinitions", "sourceDefinition", 
      "changeReplicationSourceAutoPosition", "changeReplicationSourceHost", 
      "changeReplicationSourceBind", "changeReplicationSourceUser", "changeReplicationSourcePassword", 
      "changeReplicationSourcePort", "changeReplicationSourceConnectRetry", 
      "changeReplicationSourceRetryCount", "changeReplicationSourceDelay", 
      "changeReplicationSourceSSL", "changeReplicationSourceSSLCA", "changeReplicationSourceSSLCApath", 
      "changeReplicationSourceSSLCipher", "changeReplicationSourceSSLCLR", 
      "changeReplicationSourceSSLCLRpath", "changeReplicationSourceSSLKey", 
      "changeReplicationSourceSSLVerifyServerCert", "changeReplicationSourceTLSVersion", 
      "changeReplicationSourceTLSCiphersuites", "changeReplicationSourceSSLCert", 
      "changeReplicationSourcePublicKey", "changeReplicationSourceGetSourcePublicKey", 
      "changeReplicationSourceHeartbeatPeriod", "changeReplicationSourceCompressionAlgorithm", 
      "changeReplicationSourceZstdCompressionLevel", "privilegeCheckDef", 
      "tablePrimaryKeyCheckDef", "assignGtidsToAnonymousTransactionsDefinition", 
      "sourceTlsCiphersuitesDef", "sourceFileDef", "sourceLogFile", "sourceLogPos", 
      "serverIdList", "changeReplicationFilter", "filterDefinition", "filterDbList", 
      "filterTableList", "filterStringList", "filterWildDbTableString", 
      "filterDbPairList", "startReplicaStatement", "stopReplicaStatement", 
      "replicaUntil", "userOption", "passwordOption", "defaultAuthOption", 
      "pluginDirOption", "replicaThreadOptions", "replicaThreadOption", 
      "groupReplication", "groupReplicationStartOptions", "groupReplicationStartOption", 
      "groupReplicationUser", "groupReplicationPassword", "groupReplicationPluginAuth", 
      "replica", "preparedStatement", "executeStatement", "executeVarList", 
      "cloneStatement", "dataDirSSL", "ssl", "accountManagementStatement", 
      "alterUserStatement", "alterUserList", "alterUser", "oldAlterUser", 
      "userFunction", "createUserStatement", "createUserTail", "userAttributes", 
      "defaultRoleClause", "requireClause", "connectOptions", "accountLockPasswordExpireOptions", 
      "dropUserStatement", "grantStatement", "grantTargetList", "grantOptions", 
      "exceptRoleList", "withRoles", "grantAs", "versionedRequireClause", 
      "renameUserStatement", "revokeStatement", "aclType", "roleOrPrivilegesList", 
      "roleOrPrivilege", "grantIdentifier", "requireList", "requireListElement", 
      "grantOption", "setRoleStatement", "roleList", "role", "tableAdministrationStatement", 
      "histogramAutoUpdate", "histogramUpdateParam", "histogramNumBuckets", 
      "histogram", "checkOption", "repairType", "uninstallStatement", "installStatement", 
      "installOptionType", "installSetRvalue", "installSetValue", "installSetValueList", 
      "setStatement", "startOptionValueList", "transactionCharacteristics", 
      "transactionAccessMode", "isolationLevel", "optionValueListContinued", 
      "optionValueNoOptionType", "optionValue", "startOptionValueListFollowingOptionType", 
      "optionValueFollowingOptionType", "setExprOrDefault", "showDatabasesStatement", 
      "showTablesStatement", "showTriggersStatement", "showEventsStatement", 
      "showTableStatusStatement", "showOpenTablesStatement", "showParseTreeStatement", 
      "showPluginsStatement", "showEngineLogsStatement", "showEngineMutexStatement", 
      "showEngineStatusStatement", "showColumnsStatement", "showBinaryLogsStatement", 
      "showBinaryLogStatusStatement", "showReplicasStatement", "showBinlogEventsStatement", 
      "showRelaylogEventsStatement", "showKeysStatement", "showEnginesStatement", 
      "showCountWarningsStatement", "showCountErrorsStatement", "showWarningsStatement", 
      "showErrorsStatement", "showProfilesStatement", "showProfileStatement", 
      "showStatusStatement", "showProcessListStatement", "showVariablesStatement", 
      "showCharacterSetStatement", "showCollationStatement", "showPrivilegesStatement", 
      "showGrantsStatement", "showCreateDatabaseStatement", "showCreateTableStatement", 
      "showCreateViewStatement", "showMasterStatusStatement", "showReplicaStatusStatement", 
      "showCreateProcedureStatement", "showCreateFunctionStatement", "showCreateLibraryStatement", 
      "showCreateTriggerStatement", "showProcedureStatusStatement", "showFunctionStatusStatement", 
      "showProcedureCodeStatement", "showFunctionCodeStatement", "showCreateEventStatement", 
      "showCreateUserStatement", "showCommandType", "engineOrAll", "fromOrIn", 
      "inDb", "profileDefinitions", "profileDefinition", "otherAdministrativeStatement", 
      "keyCacheListOrParts", "keyCacheList", "assignToKeycache", "assignToKeycachePartition", 
      "cacheKeyList", "keyUsageElement", "keyUsageList", "flushOption", 
      "logType", "flushTables", "flushTablesOptions", "preloadTail", "preloadList", 
      "preloadKeys", "adminPartition", "resourceGroupManagement", "createResourceGroup", 
      "resourceGroupVcpuList", "vcpuNumOrRange", "resourceGroupPriority", 
      "resourceGroupEnableDisable", "alterResourceGroup", "setResourceGroup", 
      "threadIdList", "dropResourceGroup", "utilityStatement", "describeStatement", 
      "explainStatement", "explainOptions", "explainableStatement", "explainInto", 
      "helpCommand", "useCommand", "restartServer", "expr", "boolPri", "compOp", 
      "predicate", "predicateOperations", "bitExpr", "simpleExpr", "arrayCast", 
      "jsonOperator", "sumExpr", "groupingOperation", "windowFunctionCall", 
      "samplingMethod", "samplingPercentage", "tablesampleClause", "windowingClause", 
      "leadLagInfo", "stableInteger", "paramOrVar", "nullTreatment", "jsonFunction", 
      "inSumExpr", "identListArg", "identList", "fulltextOptions", "runtimeFunctionCall", 
      "returningType", "geometryFunction", "timeFunctionParameters", "fractionalPrecision", 
      "weightStringLevels", "weightStringLevelListItem", "dateTimeTtype", 
      "trimFunction", "substringFunction", "functionCall", "udfExprList", 
      "udfExpr", "userVariable", "userVariableIdentifier", "inExpressionUserVariableAssignment", 
      "rvalueSystemOrUserVariable", "lvalueVariable", "rvalueSystemVariable", 
      "whenExpression", "thenExpression", "elseExpression", "castType", 
      "exprList", "charset", "notRule", "not2Rule", "interval", "intervalTimeStamp", 
      "exprListWithParentheses", "exprWithParentheses", "simpleExprWithParentheses", 
      "orderList", "orderExpression", "groupList", "groupingExpression", 
      "channel", "compoundStatement", "returnStatement", "ifStatement", 
      "ifBody", "thenStatement", "compoundStatementList", "caseStatement", 
      "elseStatement", "labeledBlock", "unlabeledBlock", "label", "beginEndBlock", 
      "labeledControl", "unlabeledControl", "loopBlock", "whileDoBlock", 
      "repeatUntilBlock", "spDeclarations", "spDeclaration", "variableDeclaration", 
      "conditionDeclaration", "spCondition", "sqlstate", "handlerDeclaration", 
      "handlerCondition", "cursorDeclaration", "iterateStatement", "leaveStatement", 
      "getDiagnosticsStatement", "signalAllowedExpr", "statementInformationItem", 
      "conditionInformationItem", "signalInformationItemName", "signalStatement", 
      "resignalStatement", "signalInformationItem", "cursorOpen", "cursorClose", 
      "cursorFetch", "schedule", "columnDefinition", "checkOrReferences", 
      "checkConstraint", "constraintEnforcement", "tableConstraintDef", 
      "constraintName", "fieldDefinition", "columnAttribute", "columnFormat", 
      "storageMedia", "now", "nowOrSignedLiteral", "gcolAttribute", "references", 
      "deleteOption", "keyList", "keyPart", "keyListWithExpression", "keyPartOrExpression", 
      "indexType", "indexOption", "commonIndexOption", "visibility", "indexTypeClause", 
      "fulltextIndexOption", "spatialIndexOption", "dataTypeDefinition", 
      "dataType", "nchar", "realType", "fieldLength", "fieldOptions", "charsetWithOptBinary", 
      "ascii", "unicode", "wsNumCodepoints", "typeDatetimePrecision", "functionDatetimePrecision", 
      "charsetName", "collationName", "createTableOptions", "createTableOptionsEtc", 
      "createPartitioningEtc", "createTableOptionsSpaceSeparated", "createTableOption", 
      "ternaryOption", "defaultCollation", "defaultEncryption", "defaultCharset", 
      "partitionClause", "partitionTypeDef", "subPartitions", "partitionKeyAlgorithm", 
      "partitionDefinitions", "partitionDefinition", "partitionValuesIn", 
      "partitionOption", "subpartitionDefinition", "partitionValueItemListParen", 
      "partitionValueItem", "definerClause", "ifExists", "ifExistsIdentifier", 
      "persistedVariableIdentifier", "ifNotExists", "ignoreUnknownUser", 
      "procedureParameter", "functionParameter", "collate", "typeWithOptCollate", 
      "schemaIdentifierPair", "viewRefList", "updateList", "updateElement", 
      "charsetClause", "fieldsClause", "fieldTerm", "linesClause", "lineTerm", 
      "userList", "createUserList", "createUser", "createUserWithMfa", "identification", 
      "identifiedByPassword", "identifiedByRandomPassword", "identifiedWithPlugin", 
      "identifiedWithPluginAsAuth", "identifiedWithPluginByPassword", "identifiedWithPluginByRandomPassword", 
      "initialAuth", "retainCurrentPassword", "discardOldPassword", "userRegistration", 
      "factor", "replacePassword", "userIdentifierOrText", "user", "likeClause", 
      "likeOrWhere", "onlineOption", "noWriteToBinLog", "usePartition", 
      "fieldIdentifier", "columnName", "columnInternalRef", "columnInternalRefList", 
      "columnRef", "insertIdentifier", "indexName", "indexRef", "tableWild", 
      "schemaName", "schemaRef", "procedureName", "procedureRef", "functionName", 
      "functionRef", "triggerName", "triggerRef", "viewName", "viewRef", 
      "tablespaceName", "tablespaceRef", "logfileGroupName", "logfileGroupRef", 
      "eventName", "eventRef", "udfName", "serverName", "serverRef", "engineRef", 
      "tableName", "filterTableRef", "tableRefWithWildcard", "tableRef", 
      "tableRefList", "tableAliasRefList", "parameterName", "labelIdentifier", 
      "labelRef", "roleIdentifier", "pluginRef", "componentRef", "resourceGroupRef", 
      "windowName", "libraryName", "libraryRef", "pureIdentifier", "identifier", 
      "identifierList", "identifierListWithParentheses", "qualifiedIdentifier", 
      "simpleIdentifier", "dotIdentifier", "ulong_number", "real_ulong_number", 
      "ulonglongNumber", "real_ulonglong_number", "signedLiteral", "signedLiteralOrNull", 
      "literal", "literalOrNull", "nullAsLiteral", "stringList", "textStringLiteral", 
      "textString", "textStringHash", "textLiteral", "textStringNoLinebreak", 
      "textStringLiteralList", "numLiteral", "boolLiteral", "nullLiteral", 
      "int64Literal", "temporalLiteral", "floatOptions", "standardFloatOptions", 
      "precision", "textOrIdentifier", "lValueIdentifier", "roleIdentifierOrText", 
      "sizeNumber", "parentheses", "equal", "optionType", "rvalueSystemVariableType", 
      "setVarIdentType", "jsonAttribute", "identifierKeyword", "identifierKeywordsAmbiguous1RolesAndLabels", 
      "identifierKeywordsAmbiguous2Labels", "labelKeyword", "identifierKeywordsAmbiguous3Roles", 
      "identifierKeywordsUnambiguous", "roleKeyword", "lValueKeyword", "identifierKeywordsAmbiguous4SystemVariables", 
      "roleOrIdentifierKeyword", "roleOrLabelKeyword"
    },
    std::vector<std::string>{
      "", "", "", "", "", "", "'='", "':='", "'<=>'", "'>='", "'>'", "'<='", 
      "'<'", "'!='", "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'~'", "'<<'", 
      "'>>'", "'&&'", "'&'", "'^'", "'||'", "'|'", "'.'", "','", "';'", 
      "':'", "'('", "')'", "'{'", "'}'", "'_'", "'->'", "'->>'", "'@'", 
      "", "'\\N'", "'\\u003F'", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "'<>'"
    },
    std::vector<std::string>{
      "", "NOT2_SYMBOL", "CONCAT_PIPES_SYMBOL", "INT_NUMBER", "LONG_NUMBER", 
      "ULONGLONG_NUMBER", "EQUAL_OPERATOR", "ASSIGN_OPERATOR", "NULL_SAFE_EQUAL_OPERATOR", 
      "GREATER_OR_EQUAL_OPERATOR", "GREATER_THAN_OPERATOR", "LESS_OR_EQUAL_OPERATOR", 
      "LESS_THAN_OPERATOR", "NOT_EQUAL_OPERATOR", "PLUS_OPERATOR", "MINUS_OPERATOR", 
      "MULT_OPERATOR", "DIV_OPERATOR", "MOD_OPERATOR", "LOGICAL_NOT_OPERATOR", 
      "BITWISE_NOT_OPERATOR", "SHIFT_LEFT_OPERATOR", "SHIFT_RIGHT_OPERATOR", 
      "LOGICAL_AND_OPERATOR", "BITWISE_AND_OPERATOR", "BITWISE_XOR_OPERATOR", 
      "LOGICAL_OR_OPERATOR", "BITWISE_OR_OPERATOR", "DOT_SYMBOL", "COMMA_SYMBOL", 
      "SEMICOLON_SYMBOL", "COLON_SYMBOL", "OPEN_PAR_SYMBOL", "CLOSE_PAR_SYMBOL", 
      "OPEN_CURLY_SYMBOL", "CLOSE_CURLY_SYMBOL", "UNDERLINE_SYMBOL", "JSON_SEPARATOR_SYMBOL", 
      "JSON_UNQUOTED_SEPARATOR_SYMBOL", "AT_SIGN_SYMBOL", "AT_AT_SIGN_SYMBOL", 
      "NULL2_SYMBOL", "PARAM_MARKER", "HEX_NUMBER", "BIN_NUMBER", "DECIMAL_NUMBER", 
      "FLOAT_NUMBER", "ACCESSIBLE_SYMBOL", "ACCOUNT_SYMBOL", "ACTION_SYMBOL", 
      "ADD_SYMBOL", "ADDDATE_SYMBOL", "AFTER_SYMBOL", "AGAINST_SYMBOL", 
      "AGGREGATE_SYMBOL", "ALGORITHM_SYMBOL", "ALL_SYMBOL", "ALTER_SYMBOL", 
      "ALWAYS_SYMBOL", "ANALYSE_SYMBOL", "ANALYZE_SYMBOL", "AND_SYMBOL", 
      "ANY_SYMBOL", "AS_SYMBOL", "ASC_SYMBOL", "ASCII_SYMBOL", "ASENSITIVE_SYMBOL", 
      "AT_SYMBOL", "AUTOEXTEND_SIZE_SYMBOL", "AUTO_INCREMENT_SYMBOL", "AVG_ROW_LENGTH_SYMBOL", 
      "AVG_SYMBOL", "BACKUP_SYMBOL", "BEFORE_SYMBOL", "BEGIN_SYMBOL", "BETWEEN_SYMBOL", 
      "BIGINT_SYMBOL", "BINARY_SYMBOL", "BINLOG_SYMBOL", "BIN_NUM_SYMBOL", 
      "BIT_AND_SYMBOL", "BIT_OR_SYMBOL", "BIT_SYMBOL", "BIT_XOR_SYMBOL", 
      "BLOB_SYMBOL", "BLOCK_SYMBOL", "BOOLEAN_SYMBOL", "BOOL_SYMBOL", "BOTH_SYMBOL", 
      "BTREE_SYMBOL", "BY_SYMBOL", "BYTE_SYMBOL", "CACHE_SYMBOL", "CALL_SYMBOL", 
      "CASCADE_SYMBOL", "CASCADED_SYMBOL", "CASE_SYMBOL", "CAST_SYMBOL", 
      "CATALOG_NAME_SYMBOL", "CHAIN_SYMBOL", "CHANGE_SYMBOL", "CHANGED_SYMBOL", 
      "CHANNEL_SYMBOL", "CHARSET_SYMBOL", "CHAR_SYMBOL", "CHECKSUM_SYMBOL", 
      "CHECK_SYMBOL", "CIPHER_SYMBOL", "CLASS_ORIGIN_SYMBOL", "CLIENT_SYMBOL", 
      "CLOSE_SYMBOL", "COALESCE_SYMBOL", "CODE_SYMBOL", "COLLATE_SYMBOL", 
      "COLLATION_SYMBOL", "COLUMNS_SYMBOL", "COLUMN_SYMBOL", "COLUMN_NAME_SYMBOL", 
      "COLUMN_FORMAT_SYMBOL", "COMMENT_SYMBOL", "COMMITTED_SYMBOL", "COMMIT_SYMBOL", 
      "COMPACT_SYMBOL", "COMPLETION_SYMBOL", "COMPRESSED_SYMBOL", "COMPRESSION_SYMBOL", 
      "CONCURRENT_SYMBOL", "CONDITION_SYMBOL", "CONNECTION_SYMBOL", "CONSISTENT_SYMBOL", 
      "CONSTRAINT_SYMBOL", "CONSTRAINT_CATALOG_SYMBOL", "CONSTRAINT_NAME_SYMBOL", 
      "CONSTRAINT_SCHEMA_SYMBOL", "CONTAINS_SYMBOL", "CONTEXT_SYMBOL", "CONTINUE_SYMBOL", 
      "CONVERT_SYMBOL", "COUNT_SYMBOL", "CPU_SYMBOL", "CREATE_SYMBOL", "CROSS_SYMBOL", 
      "CUBE_SYMBOL", "CURDATE_SYMBOL", "CURRENT_SYMBOL", "CURRENT_DATE_SYMBOL", 
      "CURRENT_TIME_SYMBOL", "CURRENT_USER_SYMBOL", "CURSOR_SYMBOL", "CURSOR_NAME_SYMBOL", 
      "CURTIME_SYMBOL", "DATABASE_SYMBOL", "DATABASES_SYMBOL", "DATAFILE_SYMBOL", 
      "DATA_SYMBOL", "DATETIME_SYMBOL", "DATE_ADD_SYMBOL", "DATE_SUB_SYMBOL", 
      "DATE_SYMBOL", "DAY_HOUR_SYMBOL", "DAY_MICROSECOND_SYMBOL", "DAY_MINUTE_SYMBOL", 
      "DAY_SECOND_SYMBOL", "DAY_SYMBOL", "DEALLOCATE_SYMBOL", "DECIMAL_NUM_SYMBOL", 
      "DECIMAL_SYMBOL", "DECLARE_SYMBOL", "DEFAULT_SYMBOL", "DEFAULT_AUTH_SYMBOL", 
      "DEFINER_SYMBOL", "DELAYED_SYMBOL", "DELAY_KEY_WRITE_SYMBOL", "DELETE_SYMBOL", 
      "DESC_SYMBOL", "DESCRIBE_SYMBOL", "DES_KEY_FILE_SYMBOL", "DETERMINISTIC_SYMBOL", 
      "DIAGNOSTICS_SYMBOL", "DIRECTORY_SYMBOL", "DISABLE_SYMBOL", "DISCARD_SYMBOL", 
      "DISK_SYMBOL", "DISTINCT_SYMBOL", "DIV_SYMBOL", "DOUBLE_SYMBOL", "DO_SYMBOL", 
      "DROP_SYMBOL", "DUAL_SYMBOL", "DUMPFILE_SYMBOL", "DUPLICATE_SYMBOL", 
      "DYNAMIC_SYMBOL", "EACH_SYMBOL", "ELSE_SYMBOL", "ELSEIF_SYMBOL", "ENABLE_SYMBOL", 
      "ENCLOSED_SYMBOL", "ENCRYPTION_SYMBOL", "END_SYMBOL", "ENDS_SYMBOL", 
      "END_OF_INPUT_SYMBOL", "ENGINES_SYMBOL", "ENGINE_SYMBOL", "ENUM_SYMBOL", 
      "ERROR_SYMBOL", "ERRORS_SYMBOL", "ESCAPED_SYMBOL", "ESCAPE_SYMBOL", 
      "EVENTS_SYMBOL", "EVENT_SYMBOL", "EVERY_SYMBOL", "EXCHANGE_SYMBOL", 
      "EXECUTE_SYMBOL", "EXISTS_SYMBOL", "EXIT_SYMBOL", "EXPANSION_SYMBOL", 
      "EXPIRE_SYMBOL", "EXPLAIN_SYMBOL", "EXPORT_SYMBOL", "EXTENDED_SYMBOL", 
      "EXTENT_SIZE_SYMBOL", "EXTRACT_SYMBOL", "FALSE_SYMBOL", "FAST_SYMBOL", 
      "FAULTS_SYMBOL", "FETCH_SYMBOL", "FILE_SYMBOL", "FILE_BLOCK_SIZE_SYMBOL", 
      "FILTER_SYMBOL", "FIRST_SYMBOL", "FIXED_SYMBOL", "FLOAT_SYMBOL", "FLUSH_SYMBOL", 
      "FOLLOWS_SYMBOL", "FORCE_SYMBOL", "FOREIGN_SYMBOL", "FOR_SYMBOL", 
      "FORMAT_SYMBOL", "FOUND_SYMBOL", "FROM_SYMBOL", "FULL_SYMBOL", "FULLTEXT_SYMBOL", 
      "FUNCTION_SYMBOL", "GET_SYMBOL", "GENERAL_SYMBOL", "GENERATED_SYMBOL", 
      "GROUP_REPLICATION_SYMBOL", "GEOMETRYCOLLECTION_SYMBOL", "GEOMETRY_SYMBOL", 
      "GET_FORMAT_SYMBOL", "GLOBAL_SYMBOL", "GRANT_SYMBOL", "GRANTS_SYMBOL", 
      "GROUP_SYMBOL", "GROUP_CONCAT_SYMBOL", "HANDLER_SYMBOL", "HASH_SYMBOL", 
      "HAVING_SYMBOL", "HELP_SYMBOL", "HIGH_PRIORITY_SYMBOL", "HOST_SYMBOL", 
      "HOSTS_SYMBOL", "HOUR_MICROSECOND_SYMBOL", "HOUR_MINUTE_SYMBOL", "HOUR_SECOND_SYMBOL", 
      "HOUR_SYMBOL", "IDENTIFIED_SYMBOL", "IF_SYMBOL", "IGNORE_SYMBOL", 
      "IGNORE_SERVER_IDS_SYMBOL", "IMPORT_SYMBOL", "INDEXES_SYMBOL", "INDEX_SYMBOL", 
      "INFILE_SYMBOL", "INITIAL_SIZE_SYMBOL", "INNER_SYMBOL", "INOUT_SYMBOL", 
      "INSENSITIVE_SYMBOL", "INSERT_SYMBOL", "INSERT_METHOD_SYMBOL", "INSTANCE_SYMBOL", 
      "INSTALL_SYMBOL", "INTERVAL_SYMBOL", "INTO_SYMBOL", "INT_SYMBOL", 
      "INVOKER_SYMBOL", "IN_SYMBOL", "IO_AFTER_GTIDS_SYMBOL", "IO_BEFORE_GTIDS_SYMBOL", 
      "IO_SYMBOL", "IPC_SYMBOL", "IS_SYMBOL", "ISOLATION_SYMBOL", "ISSUER_SYMBOL", 
      "ITERATE_SYMBOL", "JOIN_SYMBOL", "JSON_SYMBOL", "KEYS_SYMBOL", "KEY_BLOCK_SIZE_SYMBOL", 
      "KEY_SYMBOL", "KILL_SYMBOL", "LANGUAGE_SYMBOL", "LAST_SYMBOL", "LEADING_SYMBOL", 
      "LEAVES_SYMBOL", "LEAVE_SYMBOL", "LEFT_SYMBOL", "LESS_SYMBOL", "LEVEL_SYMBOL", 
      "LIKE_SYMBOL", "LIMIT_SYMBOL", "LINEAR_SYMBOL", "LINES_SYMBOL", "LINESTRING_SYMBOL", 
      "LIST_SYMBOL", "LOAD_SYMBOL", "LOCAL_SYMBOL", "LOCATOR_SYMBOL", "LOCKS_SYMBOL", 
      "LOCK_SYMBOL", "LOGFILE_SYMBOL", "LOGS_SYMBOL", "LONGBLOB_SYMBOL", 
      "LONGTEXT_SYMBOL", "LONG_NUM_SYMBOL", "LONG_SYMBOL", "LOOP_SYMBOL", 
      "LOW_PRIORITY_SYMBOL", "MASTER_AUTO_POSITION_SYMBOL", "MASTER_BIND_SYMBOL", 
      "MASTER_CONNECT_RETRY_SYMBOL", "MASTER_DELAY_SYMBOL", "MASTER_HOST_SYMBOL", 
      "MASTER_LOG_FILE_SYMBOL", "MASTER_LOG_POS_SYMBOL", "MASTER_PASSWORD_SYMBOL", 
      "MASTER_PORT_SYMBOL", "MASTER_RETRY_COUNT_SYMBOL", "MASTER_SERVER_ID_SYMBOL", 
      "MASTER_SSL_CAPATH_SYMBOL", "MASTER_SSL_CA_SYMBOL", "MASTER_SSL_CERT_SYMBOL", 
      "MASTER_SSL_CIPHER_SYMBOL", "MASTER_SSL_CRL_SYMBOL", "MASTER_SSL_CRLPATH_SYMBOL", 
      "MASTER_SSL_KEY_SYMBOL", "MASTER_SSL_SYMBOL", "MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL", 
      "MASTER_SYMBOL", "MASTER_TLS_VERSION_SYMBOL", "MASTER_USER_SYMBOL", 
      "MASTER_HEARTBEAT_PERIOD_SYMBOL", "MATCH_SYMBOL", "MAX_CONNECTIONS_PER_HOUR_SYMBOL", 
      "MAX_QUERIES_PER_HOUR_SYMBOL", "MAX_ROWS_SYMBOL", "MAX_SIZE_SYMBOL", 
      "MAX_STATEMENT_TIME_SYMBOL", "MAX_SYMBOL", "MAX_UPDATES_PER_HOUR_SYMBOL", 
      "MAX_USER_CONNECTIONS_SYMBOL", "MAXVALUE_SYMBOL", "MEDIUMBLOB_SYMBOL", 
      "MEDIUMINT_SYMBOL", "MEDIUMTEXT_SYMBOL", "MEDIUM_SYMBOL", "MEMORY_SYMBOL", 
      "MERGE_SYMBOL", "MESSAGE_TEXT_SYMBOL", "MICROSECOND_SYMBOL", "MID_SYMBOL", 
      "MIGRATE_SYMBOL", "MINUTE_MICROSECOND_SYMBOL", "MINUTE_SECOND_SYMBOL", 
      "MINUTE_SYMBOL", "MIN_ROWS_SYMBOL", "MIN_SYMBOL", "MODE_SYMBOL", "MODIFIES_SYMBOL", 
      "MODIFY_SYMBOL", "MOD_SYMBOL", "MONTH_SYMBOL", "MULTILINESTRING_SYMBOL", 
      "MULTIPOINT_SYMBOL", "MULTIPOLYGON_SYMBOL", "MUTEX_SYMBOL", "MYSQL_ERRNO_SYMBOL", 
      "NAMES_SYMBOL", "NAME_SYMBOL", "NATIONAL_SYMBOL", "NATURAL_SYMBOL", 
      "NCHAR_STRING_SYMBOL", "NCHAR_SYMBOL", "NDBCLUSTER_SYMBOL", "NEG_SYMBOL", 
      "NEVER_SYMBOL", "NEW_SYMBOL", "NEXT_SYMBOL", "NODEGROUP_SYMBOL", "NONE_SYMBOL", 
      "NONBLOCKING_SYMBOL", "NOT_SYMBOL", "NOW_SYMBOL", "NO_SYMBOL", "NO_WAIT_SYMBOL", 
      "NO_WRITE_TO_BINLOG_SYMBOL", "NULL_SYMBOL", "NUMBER_SYMBOL", "NUMERIC_SYMBOL", 
      "NVARCHAR_SYMBOL", "OFFLINE_SYMBOL", "OFFSET_SYMBOL", "OLD_PASSWORD_SYMBOL", 
      "ON_SYMBOL", "ONE_SYMBOL", "ONLINE_SYMBOL", "ONLY_SYMBOL", "OPEN_SYMBOL", 
      "OPTIMIZE_SYMBOL", "OPTIMIZER_COSTS_SYMBOL", "OPTIONS_SYMBOL", "OPTION_SYMBOL", 
      "OPTIONALLY_SYMBOL", "ORDER_SYMBOL", "OR_SYMBOL", "OUTER_SYMBOL", 
      "OUTFILE_SYMBOL", "OUT_SYMBOL", "OWNER_SYMBOL", "PACK_KEYS_SYMBOL", 
      "PAGE_SYMBOL", "PARSER_SYMBOL", "PARTIAL_SYMBOL", "PARTITIONING_SYMBOL", 
      "PARTITIONS_SYMBOL", "PARTITION_SYMBOL", "PASSWORD_SYMBOL", "PHASE_SYMBOL", 
      "PLUGINS_SYMBOL", "PLUGIN_DIR_SYMBOL", "PLUGIN_SYMBOL", "POINT_SYMBOL", 
      "POLYGON_SYMBOL", "PORT_SYMBOL", "POSITION_SYMBOL", "PRECEDES_SYMBOL", 
      "PRECISION_SYMBOL", "PREPARE_SYMBOL", "PRESERVE_SYMBOL", "PREV_SYMBOL", 
      "PRIMARY_SYMBOL", "PRIVILEGES_SYMBOL", "PROCEDURE_SYMBOL", "PROCESS_SYMBOL", 
      "PROCESSLIST_SYMBOL", "PROFILE_SYMBOL", "PROFILES_SYMBOL", "PROXY_SYMBOL", 
      "PURGE_SYMBOL", "QUARTER_SYMBOL", "QUERY_SYMBOL", "QUICK_SYMBOL", 
      "RANGE_SYMBOL", "READS_SYMBOL", "READ_ONLY_SYMBOL", "READ_SYMBOL", 
      "READ_WRITE_SYMBOL", "REAL_SYMBOL", "REBUILD_SYMBOL", "RECOVER_SYMBOL", 
      "REDOFILE_SYMBOL", "REDO_BUFFER_SIZE_SYMBOL", "REDUNDANT_SYMBOL", 
      "REFERENCES_SYMBOL", "REGEXP_SYMBOL", "RELAY_SYMBOL", "RELAYLOG_SYMBOL", 
      "RELAY_LOG_FILE_SYMBOL", "RELAY_LOG_POS_SYMBOL", "RELAY_THREAD_SYMBOL", 
      "RELEASE_SYMBOL", "RELOAD_SYMBOL", "REMOVE_SYMBOL", "RENAME_SYMBOL", 
      "REORGANIZE_SYMBOL", "REPAIR_SYMBOL", "REPEATABLE_SYMBOL", "REPEAT_SYMBOL", 
      "REPLACE_SYMBOL", "REPLICATION_SYMBOL", "REPLICATE_DO_DB_SYMBOL", 
      "REPLICATE_IGNORE_DB_SYMBOL", "REPLICATE_DO_TABLE_SYMBOL", "REPLICATE_IGNORE_TABLE_SYMBOL", 
      "REPLICATE_WILD_DO_TABLE_SYMBOL", "REPLICATE_WILD_IGNORE_TABLE_SYMBOL", 
      "REPLICATE_REWRITE_DB_SYMBOL", "REQUIRE_SYMBOL", "RESET_SYMBOL", "RESIGNAL_SYMBOL", 
      "RESTORE_SYMBOL", "RESTRICT_SYMBOL", "RESUME_SYMBOL", "RETURNED_SQLSTATE_SYMBOL", 
      "RETURNS_SYMBOL", "RETURN_SYMBOL", "REVERSE_SYMBOL", "REVOKE_SYMBOL", 
      "RIGHT_SYMBOL", "ROLLBACK_SYMBOL", "ROLLUP_SYMBOL", "ROTATE_SYMBOL", 
      "ROUTINE_SYMBOL", "ROWS_SYMBOL", "ROW_COUNT_SYMBOL", "ROW_FORMAT_SYMBOL", 
      "ROW_SYMBOL", "RTREE_SYMBOL", "SAVEPOINT_SYMBOL", "SCHEDULE_SYMBOL", 
      "SCHEMA_NAME_SYMBOL", "SECOND_MICROSECOND_SYMBOL", "SECOND_SYMBOL", 
      "SECURITY_SYMBOL", "SELECT_SYMBOL", "SENSITIVE_SYMBOL", "SEPARATOR_SYMBOL", 
      "SERIALIZABLE_SYMBOL", "SERIAL_SYMBOL", "SESSION_SYMBOL", "SERVER_SYMBOL", 
      "SERVER_OPTIONS_SYMBOL", "SESSION_USER_SYMBOL", "SET_SYMBOL", "SET_VAR_SYMBOL", 
      "SHARE_SYMBOL", "SHOW_SYMBOL", "SHUTDOWN_SYMBOL", "SIGNAL_SYMBOL", 
      "SIGNED_SYMBOL", "SIMPLE_SYMBOL", "SLAVE_SYMBOL", "SLOW_SYMBOL", "SMALLINT_SYMBOL", 
      "SNAPSHOT_SYMBOL", "SOCKET_SYMBOL", "SONAME_SYMBOL", "SOUNDS_SYMBOL", 
      "SOURCE_SYMBOL", "SPATIAL_SYMBOL", "SPECIFIC_SYMBOL", "SQLEXCEPTION_SYMBOL", 
      "SQLSTATE_SYMBOL", "SQLWARNING_SYMBOL", "SQL_AFTER_GTIDS_SYMBOL", 
      "SQL_AFTER_MTS_GAPS_SYMBOL", "SQL_BEFORE_GTIDS_SYMBOL", "SQL_BIG_RESULT_SYMBOL", 
      "SQL_BUFFER_RESULT_SYMBOL", "SQL_CACHE_SYMBOL", "SQL_CALC_FOUND_ROWS_SYMBOL", 
      "SQL_NO_CACHE_SYMBOL", "SQL_SMALL_RESULT_SYMBOL", "SQL_SYMBOL", "SQL_THREAD_SYMBOL", 
      "SSL_SYMBOL", "STACKED_SYMBOL", "STARTING_SYMBOL", "STARTS_SYMBOL", 
      "START_SYMBOL", "STATS_AUTO_RECALC_SYMBOL", "STATS_PERSISTENT_SYMBOL", 
      "STATS_SAMPLE_PAGES_SYMBOL", "STATUS_SYMBOL", "STDDEV_SAMP_SYMBOL", 
      "STDDEV_SYMBOL", "STDDEV_POP_SYMBOL", "STD_SYMBOL", "STOP_SYMBOL", 
      "STORAGE_SYMBOL", "STORED_SYMBOL", "STRAIGHT_JOIN_SYMBOL", "STRING_SYMBOL", 
      "SUBCLASS_ORIGIN_SYMBOL", "SUBDATE_SYMBOL", "SUBJECT_SYMBOL", "SUBPARTITIONS_SYMBOL", 
      "SUBPARTITION_SYMBOL", "SUBSTR_SYMBOL", "SUBSTRING_SYMBOL", "SUM_SYMBOL", 
      "SUPER_SYMBOL", "SUSPEND_SYMBOL", "SWAPS_SYMBOL", "SWITCHES_SYMBOL", 
      "SYSDATE_SYMBOL", "SYSTEM_USER_SYMBOL", "TABLES_SYMBOL", "TABLESPACE_SYMBOL", 
      "TABLE_REF_PRIORITY_SYMBOL", "TABLE_SYMBOL", "TABLE_CHECKSUM_SYMBOL", 
      "TABLE_NAME_SYMBOL", "TEMPORARY_SYMBOL", "TEMPTABLE_SYMBOL", "TERMINATED_SYMBOL", 
      "TEXT_SYMBOL", "THAN_SYMBOL", "THEN_SYMBOL", "TIMESTAMP_SYMBOL", "TIMESTAMPADD_SYMBOL", 
      "TIMESTAMPDIFF_SYMBOL", "TIME_SYMBOL", "TINYBLOB_SYMBOL", "TINYINT_SYMBOL", 
      "TINYTEXT_SYMBOL", "TO_SYMBOL", "TRAILING_SYMBOL", "TRANSACTION_SYMBOL", 
      "TRIGGERS_SYMBOL", "TRIGGER_SYMBOL", "TRIM_SYMBOL", "TRUE_SYMBOL", 
      "TRUNCATE_SYMBOL", "TYPES_SYMBOL", "TYPE_SYMBOL", "UDF_RETURNS_SYMBOL", 
      "UNCOMMITTED_SYMBOL", "UNDEFINED_SYMBOL", "UNDOFILE_SYMBOL", "UNDO_BUFFER_SIZE_SYMBOL", 
      "UNDO_SYMBOL", "UNICODE_SYMBOL", "UNINSTALL_SYMBOL", "UNION_SYMBOL", 
      "UNIQUE_SYMBOL", "UNKNOWN_SYMBOL", "UNLOCK_SYMBOL", "UNSIGNED_SYMBOL", 
      "UNTIL_SYMBOL", "UPDATE_SYMBOL", "UPGRADE_SYMBOL", "USAGE_SYMBOL", 
      "USER_RESOURCES_SYMBOL", "USER_SYMBOL", "USE_FRM_SYMBOL", "USE_SYMBOL", 
      "USING_SYMBOL", "UTC_DATE_SYMBOL", "UTC_TIMESTAMP_SYMBOL", "UTC_TIME_SYMBOL", 
      "VALIDATION_SYMBOL", "VALUES_SYMBOL", "VALUE_SYMBOL", "VARBINARY_SYMBOL", 
      "VARCHAR_SYMBOL", "VARIABLES_SYMBOL", "VARIANCE_SYMBOL", "VARYING_SYMBOL", 
      "VAR_POP_SYMBOL", "VAR_SAMP_SYMBOL", "VIEW_SYMBOL", "VIRTUAL_SYMBOL", 
      "WAIT_SYMBOL", "WARNINGS_SYMBOL", "WEEK_SYMBOL", "WEIGHT_STRING_SYMBOL", 
      "WHEN_SYMBOL", "WHERE_SYMBOL", "WHILE_SYMBOL", "WITH_SYMBOL", "WITHOUT_SYMBOL", 
      "WORK_SYMBOL", "WRAPPER_SYMBOL", "WRITE_SYMBOL", "X509_SYMBOL", "XA_SYMBOL", 
      "XID_SYMBOL", "XML_SYMBOL", "XOR_SYMBOL", "YEAR_MONTH_SYMBOL", "YEAR_SYMBOL", 
      "ZEROFILL_SYMBOL", "PERSIST_SYMBOL", "ROLE_SYMBOL", "ADMIN_SYMBOL", 
      "INVISIBLE_SYMBOL", "VISIBLE_SYMBOL", "EXCEPT_SYMBOL", "COMPONENT_SYMBOL", 
      "RECURSIVE_SYMBOL", "JSON_OBJECTAGG_SYMBOL", "JSON_ARRAYAGG_SYMBOL", 
      "OF_SYMBOL", "SKIP_SYMBOL", "LOCKED_SYMBOL", "NOWAIT_SYMBOL", "GROUPING_SYMBOL", 
      "PERSIST_ONLY_SYMBOL", "HISTOGRAM_SYMBOL", "BUCKETS_SYMBOL", "REMOTE_SYMBOL", 
      "CLONE_SYMBOL", "CUME_DIST_SYMBOL", "DENSE_RANK_SYMBOL", "EXCLUDE_SYMBOL", 
      "FIRST_VALUE_SYMBOL", "FOLLOWING_SYMBOL", "GROUPS_SYMBOL", "LAG_SYMBOL", 
      "LAST_VALUE_SYMBOL", "LEAD_SYMBOL", "NTH_VALUE_SYMBOL", "NTILE_SYMBOL", 
      "NULLS_SYMBOL", "OTHERS_SYMBOL", "OVER_SYMBOL", "PERCENT_RANK_SYMBOL", 
      "PRECEDING_SYMBOL", "RANK_SYMBOL", "RESPECT_SYMBOL", "ROW_NUMBER_SYMBOL", 
      "TIES_SYMBOL", "UNBOUNDED_SYMBOL", "WINDOW_SYMBOL", "EMPTY_SYMBOL", 
      "JSON_TABLE_SYMBOL", "NESTED_SYMBOL", "ORDINALITY_SYMBOL", "PATH_SYMBOL", 
      "HISTORY_SYMBOL", "REUSE_SYMBOL", "SRID_SYMBOL", "THREAD_PRIORITY_SYMBOL", 
      "RESOURCE_SYMBOL", "SYSTEM_SYMBOL", "VCPU_SYMBOL", "MASTER_PUBLIC_KEY_PATH_SYMBOL", 
      "GET_MASTER_PUBLIC_KEY_SYMBOL", "RESTART_SYMBOL", "DEFINITION_SYMBOL", 
      "DESCRIPTION_SYMBOL", "ORGANIZATION_SYMBOL", "REFERENCE_SYMBOL", "OPTIONAL_SYMBOL", 
      "SECONDARY_SYMBOL", "SECONDARY_ENGINE_SYMBOL", "SECONDARY_LOAD_SYMBOL", 
      "SECONDARY_UNLOAD_SYMBOL", "ACTIVE_SYMBOL", "INACTIVE_SYMBOL", "LATERAL_SYMBOL", 
      "RETAIN_SYMBOL", "OLD_SYMBOL", "NETWORK_NAMESPACE_SYMBOL", "ENFORCED_SYMBOL", 
      "ARRAY_SYMBOL", "OJ_SYMBOL", "MEMBER_SYMBOL", "RANDOM_SYMBOL", "MASTER_COMPRESSION_ALGORITHM_SYMBOL", 
      "MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL", "PRIVILEGE_CHECKS_USER_SYMBOL", 
      "MASTER_TLS_CIPHERSUITES_SYMBOL", "REQUIRE_ROW_FORMAT_SYMBOL", "PASSWORD_LOCK_TIME_SYMBOL", 
      "FAILED_LOGIN_ATTEMPTS_SYMBOL", "REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL", 
      "STREAM_SYMBOL", "OFF_SYMBOL", "RETURNING_SYMBOL", "JSON_VALUE_SYMBOL", 
      "TLS_SYMBOL", "ATTRIBUTE_SYMBOL", "ENGINE_ATTRIBUTE_SYMBOL", "SECONDARY_ENGINE_ATTRIBUTE_SYMBOL", 
      "SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL", "ZONE_SYMBOL", "GRAMMAR_SELECTOR_DERIVED_EXPR", 
      "REPLICA_SYMBOL", "REPLICAS_SYMBOL", "ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL", 
      "GET_SOURCE_PUBLIC_KEY_SYMBOL", "SOURCE_AUTO_POSITION_SYMBOL", "SOURCE_BIND_SYMBOL", 
      "SOURCE_COMPRESSION_ALGORITHM_SYMBOL", "SOURCE_CONNECT_RETRY_SYMBOL", 
      "SOURCE_DELAY_SYMBOL", "SOURCE_HEARTBEAT_PERIOD_SYMBOL", "SOURCE_HOST_SYMBOL", 
      "SOURCE_LOG_FILE_SYMBOL", "SOURCE_LOG_POS_SYMBOL", "SOURCE_PASSWORD_SYMBOL", 
      "SOURCE_PORT_SYMBOL", "SOURCE_PUBLIC_KEY_PATH_SYMBOL", "SOURCE_RETRY_COUNT_SYMBOL", 
      "SOURCE_SSL_SYMBOL", "SOURCE_SSL_CA_SYMBOL", "SOURCE_SSL_CAPATH_SYMBOL", 
      "SOURCE_SSL_CERT_SYMBOL", "SOURCE_SSL_CIPHER_SYMBOL", "SOURCE_SSL_CRL_SYMBOL", 
      "SOURCE_SSL_CRLPATH_SYMBOL", "SOURCE_SSL_KEY_SYMBOL", "SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL", 
      "SOURCE_TLS_CIPHERSUITES_SYMBOL", "SOURCE_TLS_VERSION_SYMBOL", "SOURCE_USER_SYMBOL", 
      "SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL", "ST_COLLECT_SYMBOL", "KEYRING_SYMBOL", 
      "AUTHENTICATION_SYMBOL", "FACTOR_SYMBOL", "FINISH_SYMBOL", "INITIATE_SYMBOL", 
      "REGISTRATION_SYMBOL", "UNREGISTER_SYMBOL", "INITIAL_SYMBOL", "CHALLENGE_RESPONSE_SYMBOL", 
      "GTID_ONLY_SYMBOL", "INTERSECT_SYMBOL", "BULK_SYMBOL", "URL_SYMBOL", 
      "GENERATE_SYMBOL", "PARSE_TREE_SYMBOL", "LOG_SYMBOL", "GTIDS_SYMBOL", 
      "PARALLEL_SYMBOL", "S3_SYMBOL", "QUALIFY_SYMBOL", "AUTO_SYMBOL", "MANUAL_SYMBOL", 
      "BERNOULLI_SYMBOL", "TABLESAMPLE_SYMBOL", "VECTOR_SYMBOL", "PARAMETERS_SYMBOL", 
      "HEADER_SYMBOL", "LIBRARY_SYMBOL", "WHITESPACE", "INVALID_INPUT", 
      "UNDERSCORE_CHARSET", "DOLLAR_QUOTED_STRING_TEXT", "IDENTIFIER", "NCHAR_TEXT", 
      "BACK_TICK_QUOTED_ID", "DOUBLE_QUOTED_TEXT", "SINGLE_QUOTED_TEXT", 
      "VERSION_COMMENT_START", "MYSQL_COMMENT_START", "VERSION_COMMENT_END", 
      "BLOCK_COMMENT", "INVALID_BLOCK_COMMENT", "POUND_COMMENT", "DASHDASH_COMMENT", 
      "SIMPLE_IDENTIFIER", "NOT_EQUAL2_OPERATOR"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,855,9689,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,
  	2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,13,2,14,
  	7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,20,7,20,2,21,
  	7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,26,2,27,7,27,2,28,
  	7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,33,7,33,2,34,7,34,2,35,
  	7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,39,2,40,7,40,2,41,7,41,2,42,
  	7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,46,7,46,2,47,7,47,2,48,7,48,2,49,
  	7,49,2,50,7,50,2,51,7,51,2,52,7,52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,
  	7,56,2,57,7,57,2,58,7,58,2,59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,
  	7,63,2,64,7,64,2,65,7,65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,
  	7,70,2,71,7,71,2,72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,
  	7,77,2,78,7,78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,
  	7,84,2,85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,
  	7,91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,98,
  	7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,2,104,
  	7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,7,109,2,110,
  	7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,2,115,7,115,2,116,
  	7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,7,120,2,121,7,121,2,122,
  	7,122,2,123,7,123,2,124,7,124,2,125,7,125,2,126,7,126,2,127,7,127,2,128,
  	7,128,2,129,7,129,2,130,7,130,2,131,7,131,2,132,7,132,2,133,7,133,2,134,
  	7,134,2,135,7,135,2,136,7,136,2,137,7,137,2,138,7,138,2,139,7,139,2,140,
  	7,140,2,141,7,141,2,142,7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,
  	7,146,2,147,7,147,2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,
  	7,152,2,153,7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,
  	7,158,2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,
  	7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,2,170,
  	7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,7,175,2,176,
  	7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,2,181,7,181,2,182,
  	7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,7,186,2,187,7,187,2,188,
  	7,188,2,189,7,189,2,190,7,190,2,191,7,191,2,192,7,192,2,193,7,193,2,194,
  	7,194,2,195,7,195,2,196,7,196,2,197,7,197,2,198,7,198,2,199,7,199,2,200,
  	7,200,2,201,7,201,2,202,7,202,2,203,7,203,2,204,7,204,2,205,7,205,2,206,
  	7,206,2,207,7,207,2,208,7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,
  	7,212,2,213,7,213,2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,2,218,
  	7,218,2,219,7,219,2,220,7,220,2,221,7,221,2,222,7,222,2,223,7,223,2,224,
  	7,224,2,225,7,225,2,226,7,226,2,227,7,227,2,228,7,228,2,229,7,229,2,230,
  	7,230,2,231,7,231,2,232,7,232,2,233,7,233,2,234,7,234,2,235,7,235,2,236,
  	7,236,2,237,7,237,2,238,7,238,2,239,7,239,2,240,7,240,2,241,7,241,2,242,
  	7,242,2,243,7,243,2,244,7,244,2,245,7,245,2,246,7,246,2,247,7,247,2,248,
  	7,248,2,249,7,249,2,250,7,250,2,251,7,251,2,252,7,252,2,253,7,253,2,254,
  	7,254,2,255,7,255,2,256,7,256,2,257,7,257,2,258,7,258,2,259,7,259,2,260,
  	7,260,2,261,7,261,2,262,7,262,2,263,7,263,2,264,7,264,2,265,7,265,2,266,
  	7,266,2,267,7,267,2,268,7,268,2,269,7,269,2,270,7,270,2,271,7,271,2,272,
  	7,272,2,273,7,273,2,274,7,274,2,275,7,275,2,276,7,276,2,277,7,277,2,278,
  	7,278,2,279,7,279,2,280,7,280,2,281,7,281,2,282,7,282,2,283,7,283,2,284,
  	7,284,2,285,7,285,2,286,7,286,2,287,7,287,2,288,7,288,2,289,7,289,2,290,
  	7,290,2,291,7,291,2,292,7,292,2,293,7,293,2,294,7,294,2,295,7,295,2,296,
  	7,296,2,297,7,297,2,298,7,298,2,299,7,299,2,300,7,300,2,301,7,301,2,302,
  	7,302,2,303,7,303,2,304,7,304,2,305,7,305,2,306,7,306,2,307,7,307,2,308,
  	7,308,2,309,7,309,2,310,7,310,2,311,7,311,2,312,7,312,2,313,7,313,2,314,
  	7,314,2,315,7,315,2,316,7,316,2,317,7,317,2,318,7,318,2,319,7,319,2,320,
  	7,320,2,321,7,321,2,322,7,322,2,323,7,323,2,324,7,324,2,325,7,325,2,326,
  	7,326,2,327,7,327,2,328,7,328,2,329,7,329,2,330,7,330,2,331,7,331,2,332,
  	7,332,2,333,7,333,2,334,7,334,2,335,7,335,2,336,7,336,2,337,7,337,2,338,
  	7,338,2,339,7,339,2,340,7,340,2,341,7,341,2,342,7,342,2,343,7,343,2,344,
  	7,344,2,345,7,345,2,346,7,346,2,347,7,347,2,348,7,348,2,349,7,349,2,350,
  	7,350,2,351,7,351,2,352,7,352,2,353,7,353,2,354,7,354,2,355,7,355,2,356,
  	7,356,2,357,7,357,2,358,7,358,2,359,7,359,2,360,7,360,2,361,7,361,2,362,
  	7,362,2,363,7,363,2,364,7,364,2,365,7,365,2,366,7,366,2,367,7,367,2,368,
  	7,368,2,369,7,369,2,370,7,370,2,371,7,371,2,372,7,372,2,373,7,373,2,374,
  	7,374,2,375,7,375,2,376,7,376,2,377,7,377,2,378,7,378,2,379,7,379,2,380,
  	7,380,2,381,7,381,2,382,7,382,2,383,7,383,2,384,7,384,2,385,7,385,2,386,
  	7,386,2,387,7,387,2,388,7,388,2,389,7,389,2,390,7,390,2,391,7,391,2,392,
  	7,392,2,393,7,393,2,394,7,394,2,395,7,395,2,396,7,396,2,397,7,397,2,398,
  	7,398,2,399,7,399,2,400,7,400,2,401,7,401,2,402,7,402,2,403,7,403,2,404,
  	7,404,2,405,7,405,2,406,7,406,2,407,7,407,2,408,7,408,2,409,7,409,2,410,
  	7,410,2,411,7,411,2,412,7,412,2,413,7,413,2,414,7,414,2,415,7,415,2,416,
  	7,416,2,417,7,417,2,418,7,418,2,419,7,419,2,420,7,420,2,421,7,421,2,422,
  	7,422,2,423,7,423,2,424,7,424,2,425,7,425,2,426,7,426,2,427,7,427,2,428,
  	7,428,2,429,7,429,2,430,7,430,2,431,7,431,2,432,7,432,2,433,7,433,2,434,
  	7,434,2,435,7,435,2,436,7,436,2,437,7,437,2,438,7,438,2,439,7,439,2,440,
  	7,440,2,441,7,441,2,442,7,442,2,443,7,443,2,444,7,444,2,445,7,445,2,446,
  	7,446,2,447,7,447,2,448,7,448,2,449,7,449,2,450,7,450,2,451,7,451,2,452,
  	7,452,2,453,7,453,2,454,7,454,2,455,7,455,2,456,7,456,2,457,7,457,2,458,
  	7,458,2,459,7,459,2,460,7,460,2,461,7,461,2,462,7,462,2,463,7,463,2,464,
  	7,464,2,465,7,465,2,466,7,466,2,467,7,467,2,468,7,468,2,469,7,469,2,470,
  	7,470,2,471,7,471,2,472,7,472,2,473,7,473,2,474,7,474,2,475,7,475,2,476,
  	7,476,2,477,7,477,2,478,7,478,2,479,7,479,2,480,7,480,2,481,7,481,2,482,
  	7,482,2,483,7,483,2,484,7,484,2,485,7,485,2,486,7,486,2,487,7,487,2,488,
  	7,488,2,489,7,489,2,490,7,490,2,491,7,491,2,492,7,492,2,493,7,493,2,494,
  	7,494,2,495,7,495,2,496,7,496,2,497,7,497,2,498,7,498,2,499,7,499,2,500,
  	7,500,2,501,7,501,2,502,7,502,2,503,7,503,2,504,7,504,2,505,7,505,2,506,
  	7,506,2,507,7,507,2,508,7,508,2,509,7,509,2,510,7,510,2,511,7,511,2,512,
  	7,512,2,513,7,513,2,514,7,514,2,515,7,515,2,516,7,516,2,517,7,517,2,518,
  	7,518,2,519,7,519,2,520,7,520,2,521,7,521,2,522,7,522,2,523,7,523,2,524,
  	7,524,2,525,7,525,2,526,7,526,2,527,7,527,2,528,7,528,2,529,7,529,2,530,
  	7,530,2,531,7,531,2,532,7,532,2,533,7,533,2,534,7,534,2,535,7,535,2,536,
  	7,536,2,537,7,537,2,538,7,538,2,539,7,539,2,540,7,540,2,541,7,541,2,542,
  	7,542,2,543,7,543,2,544,7,544,2,545,7,545,2,546,7,546,2,547,7,547,2,548,
  	7,548,2,549,7,549,2,550,7,550,2,551,7,551,2,552,7,552,2,553,7,553,2,554,
  	7,554,2,555,7,555,2,556,7,556,2,557,7,557,2,558,7,558,2,559,7,559,2,560,
  	7,560,2,561,7,561,2,562,7,562,2,563,7,563,2,564,7,564,2,565,7,565,2,566,
  	7,566,2,567,7,567,2,568,7,568,2,569,7,569,2,570,7,570,2,571,7,571,2,572,
  	7,572,2,573,7,573,2,574,7,574,2,575,7,575,2,576,7,576,2,577,7,577,2,578,
  	7,578,2,579,7,579,2,580,7,580,2,581,7,581,2,582,7,582,2,583,7,583,2,584,
  	7,584,2,585,7,585,2,586,7,586,2,587,7,587,2,588,7,588,2,589,7,589,2,590,
  	7,590,2,591,7,591,2,592,7,592,2,593,7,593,2,594,7,594,2,595,7,595,2,596,
  	7,596,2,597,7,597,2,598,7,598,2,599,7,599,2,600,7,600,2,601,7,601,2,602,
  	7,602,2,603,7,603,2,604,7,604,2,605,7,605,2,606,7,606,2,607,7,607,2,608,
  	7,608,2,609,7,609,2,610,7,610,2,611,7,611,2,612,7,612,2,613,7,613,2,614,
  	7,614,2,615,7,615,2,616,7,616,2,617,7,617,2,618,7,618,2,619,7,619,2,620,
  	7,620,2,621,7,621,2,622,7,622,2,623,7,623,2,624,7,624,2,625,7,625,2,626,
  	7,626,2,627,7,627,2,628,7,628,2,629,7,629,2,630,7,630,2,631,7,631,2,632,
  	7,632,2,633,7,633,2,634,7,634,2,635,7,635,2,636,7,636,2,637,7,637,2,638,
  	7,638,2,639,7,639,2,640,7,640,2,641,7,641,2,642,7,642,2,643,7,643,2,644,
  	7,644,2,645,7,645,2,646,7,646,2,647,7,647,2,648,7,648,2,649,7,649,2,650,
  	7,650,2,651,7,651,2,652,7,652,2,653,7,653,2,654,7,654,2,655,7,655,2,656,
  	7,656,2,657,7,657,2,658,7,658,2,659,7,659,2,660,7,660,2,661,7,661,2,662,
  	7,662,2,663,7,663,2,664,7,664,2,665,7,665,2,666,7,666,2,667,7,667,2,668,
  	7,668,2,669,7,669,2,670,7,670,2,671,7,671,2,672,7,672,2,673,7,673,2,674,
  	7,674,2,675,7,675,2,676,7,676,2,677,7,677,2,678,7,678,2,679,7,679,2,680,
  	7,680,2,681,7,681,2,682,7,682,2,683,7,683,2,684,7,684,2,685,7,685,2,686,
  	7,686,2,687,7,687,2,688,7,688,2,689,7,689,2,690,7,690,2,691,7,691,2,692,
  	7,692,2,693,7,693,2,694,7,694,2,695,7,695,2,696,7,696,2,697,7,697,2,698,
  	7,698,2,699,7,699,2,700,7,700,2,701,7,701,2,702,7,702,2,703,7,703,2,704,
  	7,704,2,705,7,705,2,706,7,706,2,707,7,707,2,708,7,708,2,709,7,709,2,710,
  	7,710,2,711,7,711,2,712,7,712,2,713,7,713,2,714,7,714,2,715,7,715,2,716,
  	7,716,2,717,7,717,2,718,7,718,2,719,7,719,2,720,7,720,2,721,7,721,2,722,
  	7,722,2,723,7,723,2,724,7,724,2,725,7,725,2,726,7,726,2,727,7,727,2,728,
  	7,728,2,729,7,729,2,730,7,730,2,731,7,731,2,732,7,732,2,733,7,733,2,734,
  	7,734,2,735,7,735,2,736,7,736,2,737,7,737,2,738,7,738,2,739,7,739,2,740,
  	7,740,2,741,7,741,2,742,7,742,2,743,7,743,2,744,7,744,2,745,7,745,2,746,
  	7,746,2,747,7,747,2,748,7,748,2,749,7,749,2,750,7,750,2,751,7,751,2,752,
  	7,752,2,753,7,753,2,754,7,754,2,755,7,755,2,756,7,756,2,757,7,757,2,758,
  	7,758,2,759,7,759,2,760,7,760,2,761,7,761,2,762,7,762,2,763,7,763,1,0,
  	1,0,3,0,1531,8,0,1,0,3,0,1534,8,0,3,0,1536,8,0,1,0,1,0,1,1,1,1,1,1,1,
  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
  	1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,3,1,1624,8,1,1,2,1,2,1,2,1,
  	2,1,2,1,2,3,2,1632,8,2,1,2,1,2,1,2,3,2,1637,8,2,1,2,1,2,1,2,1,2,1,2,1,
  	2,1,2,1,2,3,2,1647,8,2,1,3,1,3,1,3,4,3,1652,8,3,11,3,12,3,1653,1,3,1,
  	3,1,3,1,3,1,3,3,3,1661,8,3,1,4,1,4,1,4,1,4,3,4,1667,8,4,1,4,3,4,1670,
  	8,4,1,5,3,5,1673,8,5,1,5,1,5,1,5,1,5,1,5,3,5,1680,8,5,1,5,1,5,1,5,3,5,
  	1685,8,5,1,5,3,5,1688,8,5,1,5,1,5,1,5,3,5,1693,8,5,1,5,1,5,1,5,1,5,3,
  	5,1699,8,5,3,5,1701,8,5,1,5,1,5,3,5,1705,8,5,1,5,1,5,3,5,1709,8,5,1,6,
  	1,6,1,6,1,6,1,6,1,6,1,6,3,6,1718,8,6,1,7,1,7,3,7,1722,8,7,1,7,5,7,1725,
  	8,7,10,7,12,7,1728,9,7,1,8,1,8,1,8,3,8,1733,8,8,1,9,1,9,1,9,1,9,1,10,
  	3,10,1740,8,10,1,10,1,10,1,10,3,10,1745,8,10,1,11,1,11,1,11,3,11,1750,
  	8,11,1,11,1,11,1,11,1,11,1,11,3,11,1757,8,11,1,11,3,11,1760,8,11,1,12,
  	1,12,1,12,1,12,3,12,1766,8,12,1,12,3,12,1769,8,12,1,13,1,13,1,13,5,13,
  	1774,8,13,10,13,12,13,1777,9,13,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,
  	14,1,14,3,14,1788,8,14,1,14,1,14,1,14,3,14,1793,8,14,3,14,1795,8,14,3,
  	14,1797,8,14,1,15,1,15,1,15,3,15,1802,8,15,1,15,1,15,1,15,3,15,1807,8,
  	15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,1815,8,15,1,15,1,15,1,15,1,15,3,
  	15,1821,8,15,1,15,1,15,3,15,1825,8,15,1,15,1,15,1,15,3,15,1830,8,15,1,
  	15,1,15,1,15,1,15,1,15,5,15,1837,8,15,10,15,12,15,1840,9,15,1,15,1,15,
  	1,15,3,15,1845,8,15,1,15,1,15,5,15,1849,8,15,10,15,12,15,1852,9,15,1,
  	15,1,15,1,15,3,15,1857,8,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,3,15,1866,
  	8,15,1,15,1,15,1,15,1,15,3,15,1872,8,15,1,15,1,15,1,15,1,15,1,15,1,15,
  	1,15,3,15,1881,8,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,1,15,
  	1,15,1,15,3,15,1895,8,15,1,16,1,16,3,16,1899,8,16,1,16,1,16,1,16,1,16,
  	3,16,1905,8,16,5,16,1907,8,16,10,16,12,16,1910,9,16,1,17,1,17,1,17,3,
  	17,1915,8,17,1,18,1,18,3,18,1919,8,18,1,18,1,18,1,18,3,18,1924,8,18,1,
  	18,3,18,1927,8,18,1,18,1,18,1,18,1,18,3,18,1933,8,18,1,18,1,18,1,18,1,
  	18,3,18,1939,8,18,1,18,1,18,1,18,1,18,3,18,1945,8,18,1,18,1,18,3,18,1949,
  	8,18,1,18,1,18,1,18,3,18,1954,8,18,1,18,1,18,3,18,1958,8,18,1,18,1,18,
  	3,18,1962,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,
  	1,18,1,18,1,18,3,18,1978,8,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,1986,
  	8,18,1,18,1,18,1,18,1,18,1,18,1,18,3,18,1994,8,18,1,18,1,18,1,18,1,18,
  	1,18,3,18,2001,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,
  	1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,
  	1,18,1,18,1,18,3,18,2030,8,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,1,18,
  	1,18,1,18,1,18,1,18,1,18,3,18,2045,8,18,1,18,3,18,2048,8,18,1,18,1,18,
  	1,18,1,18,1,18,1,18,1,18,3,18,2057,8,18,1,19,1,19,1,19,3,19,2062,8,19,
  	1,20,1,20,1,21,1,21,3,21,2068,8,21,1,21,1,21,1,21,3,21,2073,8,21,5,21,
  	2075,8,21,10,21,12,21,2078,9,21,1,22,1,22,3,22,2082,8,22,1,22,1,22,3,
  	22,2086,8,22,1,23,1,23,3,23,2090,8,23,1,23,1,23,3,23,2094,8,23,1,24,1,
  	24,3,24,2098,8,24,1,24,1,24,3,24,2102,8,24,3,24,2104,8,24,1,25,1,25,1,
  	25,1,25,1,26,1,26,1,26,1,27,1,27,3,27,2115,8,27,1,28,1,28,1,28,1,28,1,
  	28,1,28,3,28,2123,8,28,1,28,1,28,1,28,1,28,1,28,3,28,2130,8,28,1,29,1,
  	29,1,29,1,29,1,29,1,29,3,29,2138,8,29,1,30,1,30,3,30,2142,8,30,1,30,5,
  	30,2145,8,30,10,30,12,30,2148,9,30,1,31,1,31,1,32,1,32,3,32,2154,8,32,
  	1,32,5,32,2157,8,32,10,32,12,32,2160,9,32,1,33,1,33,3,33,2164,8,33,1,
  	33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,3,33,2174,8,33,1,34,1,34,3,34,2178,
  	8,34,1,34,1,34,1,34,3,34,2183,8,34,1,35,3,35,2186,8,35,1,35,3,35,2189,
  	8,35,1,35,3,35,2192,8,35,1,35,1,35,1,35,1,35,1,36,3,36,2199,8,36,1,36,
  	1,36,1,36,1,37,1,37,3,37,2206,8,37,1,38,1,38,3,38,2210,8,38,1,38,1,38,
  	1,38,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,1,39,
  	1,39,3,39,2229,8,39,1,39,1,39,1,39,1,39,3,39,2235,8,39,1,39,1,39,1,39,
  	1,39,1,39,1,39,1,39,1,39,3,39,2245,8,39,1,39,3,39,2248,8,39,1,40,1,40,
  	1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,1,40,
  	1,40,1,40,1,40,1,40,1,40,3,40,2271,8,40,1,41,1,41,3,41,2275,8,41,1,41,
  	1,41,5,41,2279,8,41,10,41,12,41,2282,9,41,1,42,1,42,1,42,1,42,3,42,2288,
  	8,42,1,43,3,43,2291,8,43,1,43,1,43,3,43,2295,8,43,1,43,1,43,1,43,1,43,
  	1,43,3,43,2302,8,43,1,43,3,43,2305,8,43,1,43,1,43,1,43,1,43,1,43,1,43,
  	1,43,3,43,2314,8,43,1,44,1,44,1,44,5,44,2319,8,44,10,44,12,44,2322,9,
  	44,1,45,1,45,3,45,2326,8,45,1,46,3,46,2329,8,46,1,46,1,46,1,47,3,47,2334,
  	8,47,1,47,1,47,1,48,1,48,3,48,2340,8,48,1,48,3,48,2343,8,48,1,49,1,49,
  	3,49,2347,8,49,1,50,1,50,1,50,1,50,3,50,2353,8,50,1,50,3,50,2356,8,50,
  	1,50,1,50,1,51,3,51,2361,8,51,1,51,1,51,1,51,3,51,2366,8,51,1,51,1,51,
  	1,51,1,51,1,51,5,51,2373,8,51,10,51,12,51,2376,9,51,3,51,2378,8,51,1,
  	51,1,51,5,51,2382,8,51,10,51,12,51,2385,9,51,1,51,1,51,1,52,1,52,3,52,
  	2391,8,52,1,53,1,53,1,53,1,53,3,53,2397,8,53,1,54,3,54,2400,8,54,1,54,
  	1,54,1,54,3,54,2405,8,54,1,54,1,54,1,54,1,54,1,54,5,54,2412,8,54,10,54,
  	12,54,2415,9,54,3,54,2417,8,54,1,54,1,54,1,54,1,54,5,54,2423,8,54,10,
  	54,12,54,2426,9,54,1,54,1,54,1,55,3,55,2431,8,55,1,55,1,55,1,55,3,55,
  	2436,8,55,1,55,1,55,1,55,1,55,1,55,1,55,1,56,1,56,3,56,2446,8,56,1,56,
  	1,56,1,56,1,56,1,56,1,56,1,56,3,56,2455,8,56,1,57,1,57,1,57,5,57,2460,
  	8,57,10,57,12,57,2463,9,57,1,58,1,58,3,58,2467,8,58,1,58,3,58,2470,8,
  	58,1,59,4,59,2473,8,59,11,59,12,59,2474,1,60,1,60,1,60,1,60,1,60,1,60,
  	3,60,2483,8,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,1,60,
  	1,60,1,60,3,60,2498,8,60,1,61,3,61,2501,8,61,1,61,3,61,2504,8,61,1,61,
  	1,61,1,61,3,61,2509,8,61,1,61,1,61,5,61,2513,8,61,10,61,12,61,2516,9,
  	61,1,61,1,61,1,61,1,61,1,61,5,61,2523,8,61,10,61,12,61,2526,9,61,1,61,
  	1,61,1,61,1,61,1,61,5,61,2533,8,61,10,61,12,61,2536,9,61,3,61,2538,8,
  	61,1,61,3,61,2541,8,61,1,62,1,62,3,62,2545,8,62,1,62,1,62,1,62,1,62,1,
  	62,1,62,3,62,2553,8,62,1,63,1,63,1,63,1,63,1,64,1,64,1,64,1,64,1,64,1,
  	64,1,64,3,64,2566,8,64,1,65,1,65,3,65,2570,8,65,1,65,5,65,2573,8,65,10,
  	65,12,65,2576,9,65,1,66,1,66,1,66,1,66,1,66,1,66,3,66,2584,8,66,1,67,
  	1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,68,1,68,1,68,1,68,1,68,5,68,2599,
  	8,68,10,68,12,68,2602,9,68,1,68,1,68,1,69,1,69,1,69,1,69,1,69,1,69,1,
  	69,1,69,1,69,1,69,1,69,1,69,1,69,1,69,3,69,2620,8,69,1,70,1,70,1,70,1,
  	70,1,70,1,70,1,70,3,70,2629,8,70,1,70,3,70,2632,8,70,1,71,1,71,1,71,1,
  	71,1,71,1,71,3,71,2640,8,71,1,72,1,72,3,72,2644,8,72,1,72,1,72,1,72,1,
  	72,1,72,1,72,1,73,1,73,1,73,1,73,1,73,3,73,2657,8,73,3,73,2659,8,73,1,
  	74,1,74,1,74,1,75,1,75,3,75,2666,8,75,1,75,5,75,2669,8,75,10,75,12,75,
  	2672,9,75,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,1,76,
  	3,76,2686,8,76,1,77,1,77,3,77,2690,8,77,1,77,1,77,1,78,1,78,3,78,2696,
  	8,78,1,78,1,78,1,79,1,79,3,79,2702,8,79,1,79,1,79,1,80,1,80,3,80,2708,
  	8,80,1,80,1,80,1,81,1,81,3,81,2714,8,81,1,81,1,81,1,82,1,82,3,82,2720,
  	8,82,1,82,1,82,1,83,3,83,2725,8,83,1,83,1,83,3,83,2729,8,83,1,83,1,83,
  	1,84,1,84,1,85,1,85,3,85,2737,8,85,1,85,1,85,1,86,1,86,3,86,2743,8,86,
  	1,86,1,86,1,87,1,87,3,87,2749,8,87,1,87,1,87,1,88,1,88,3,88,2755,8,88,
  	1,88,1,88,1,89,3,89,2760,8,89,1,89,3,89,2763,8,89,1,89,3,89,2766,8,89,
  	1,89,1,89,1,89,3,89,2771,8,89,1,89,1,89,1,89,1,90,1,90,1,90,3,90,2779,
  	8,90,1,90,3,90,2782,8,90,1,91,1,91,1,91,1,91,1,92,1,92,1,92,1,92,1,93,
  	3,93,2793,8,93,1,93,1,93,1,93,3,93,2798,8,93,1,93,1,93,1,93,1,93,1,93,
  	1,93,1,93,1,93,1,93,3,93,2809,8,93,1,93,1,93,1,94,1,94,1,94,1,95,3,95,
  	2817,8,95,1,95,1,95,3,95,2821,8,95,1,95,1,95,1,95,1,95,1,95,1,95,1,95,
  	3,95,2830,8,95,1,95,3,95,2833,8,95,1,95,1,95,1,95,1,95,3,95,2839,8,95,
  	3,95,2841,8,95,1,95,1,95,3,95,2845,8,95,1,95,1,95,1,95,1,96,1,96,3,96,
  	2852,8,96,1,96,1,96,1,97,1,97,1,97,1,97,1,97,1,97,1,97,5,97,2863,8,97,
  	10,97,12,97,2866,9,97,1,97,1,97,1,97,1,97,3,97,2872,8,97,1,97,1,97,5,
  	97,2876,8,97,10,97,12,97,2879,9,97,3,97,2881,8,97,1,98,1,98,1,98,1,98,
  	1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,1,98,3,98,2898,8,98,
  	1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,1,99,
  	1,99,1,99,1,99,1,99,1,99,1,99,3,99,2920,8,99,1,100,1,100,3,100,2924,8,
  	100,1,100,1,100,1,101,1,101,3,101,2930,8,101,1,101,1,101,1,102,1,102,
  	3,102,2936,8,102,1,102,1,102,1,103,1,103,3,103,2942,8,103,1,103,1,103,
  	1,104,3,104,2947,8,104,1,104,1,104,1,104,1,104,1,104,3,104,2954,8,104,
  	1,105,1,105,1,105,1,105,1,105,3,105,2961,8,105,1,105,5,105,2964,8,105,
  	10,105,12,105,2967,9,105,3,105,2969,8,105,1,106,1,106,3,106,2973,8,106,
  	1,107,1,107,3,107,2977,8,107,1,107,1,107,1,108,3,108,2982,8,108,1,108,
  	1,108,3,108,2986,8,108,1,108,1,108,3,108,2990,8,108,1,109,1,109,1,109,
  	1,109,3,109,2996,8,109,1,109,5,109,2999,8,109,10,109,12,109,3002,9,109,
  	3,109,3004,8,109,1,110,1,110,3,110,3008,8,110,1,110,1,110,1,111,1,111,
  	3,111,3014,8,111,1,111,1,111,3,111,3018,8,111,1,112,1,112,3,112,3022,
  	8,112,1,112,1,112,1,113,1,113,1,113,1,113,3,113,3030,8,113,1,113,1,113,
  	1,114,1,114,1,114,1,114,3,114,3038,8,114,1,115,1,115,1,115,3,115,3043,
  	8,115,1,115,1,115,1,116,1,116,1,116,1,116,1,116,5,116,3052,8,116,10,116,
  	12,116,3055,9,116,1,117,1,117,1,117,1,117,1,118,1,118,3,118,3063,8,118,
  	1,118,1,118,1,119,1,119,1,119,1,119,1,119,1,120,1,120,1,120,1,120,3,120,
  	3076,8,120,1,120,3,120,3079,8,120,1,121,1,121,3,121,3083,8,121,1,121,
  	1,121,5,121,3087,8,121,10,121,12,121,3090,9,121,1,121,1,121,1,121,1,121,
  	1,121,3,121,3097,8,121,1,121,1,121,1,121,3,121,3102,8,121,1,121,3,121,
  	3105,8,121,1,121,3,121,3108,8,121,1,121,3,121,3111,8,121,1,121,3,121,
  	3114,8,121,3,121,3116,8,121,1,121,1,121,1,121,1,121,3,121,3122,8,121,
  	3,121,3124,8,121,1,122,1,122,1,122,1,122,1,122,1,123,1,123,1,124,1,124,
  	1,124,1,124,1,124,3,124,3138,8,124,1,125,1,125,1,125,1,125,3,125,3144,
  	8,125,1,125,1,125,1,125,1,125,1,125,3,125,3151,8,125,1,125,3,125,3154,
  	8,125,3,125,3156,8,125,3,125,3158,8,125,1,126,1,126,1,126,1,126,1,126,
  	1,126,1,126,1,126,3,126,3168,8,126,3,126,3170,8,126,1,127,1,127,3,127,
  	3174,8,127,1,127,3,127,3177,8,127,1,127,3,127,3180,8,127,1,127,1,127,
  	3,127,3184,8,127,1,127,1,127,3,127,3188,8,127,1,127,1,127,1,127,3,127,
  	3193,8,127,1,127,3,127,3196,8,127,1,127,3,127,3199,8,127,1,128,1,128,
  	1,129,1,129,3,129,3205,8,129,1,129,3,129,3208,8,129,1,129,1,129,1,130,
  	1,130,1,130,5,130,3215,8,130,10,130,12,130,3218,9,130,1,131,1,131,1,131,
  	1,132,1,132,1,132,1,132,3,132,3227,8,132,1,132,3,132,3230,8,132,1,132,
  	3,132,3233,8,132,1,133,1,133,3,133,3237,8,133,1,133,1,133,1,133,1,133,
  	3,133,3243,8,133,1,133,5,133,3246,8,133,10,133,12,133,3249,9,133,1,134,
  	1,134,3,134,3253,8,134,1,134,1,134,1,134,3,134,3258,8,134,5,134,3260,
  	8,134,10,134,12,134,3263,9,134,1,135,1,135,1,135,1,135,3,135,3269,8,135,
  	1,136,1,136,1,136,1,136,1,136,1,136,1,137,1,137,1,137,3,137,3280,8,137,
  	1,137,3,137,3283,8,137,1,137,3,137,3286,8,137,1,137,3,137,3289,8,137,
  	1,137,1,137,3,137,3293,8,137,1,137,3,137,3296,8,137,1,137,3,137,3299,
  	8,137,1,137,1,137,1,137,1,137,3,137,3305,8,137,1,137,1,137,3,137,3309,
  	8,137,1,137,3,137,3312,8,137,1,137,3,137,3315,8,137,1,137,3,137,3318,
  	8,137,1,137,3,137,3321,8,137,1,137,1,137,3,137,3325,8,137,1,137,3,137,
  	3328,8,137,1,137,3,137,3331,8,137,1,138,1,138,1,139,1,139,1,140,1,140,
  	1,140,1,141,1,141,1,141,3,141,3343,8,141,1,142,1,142,1,142,1,142,1,142,
  	1,142,1,142,3,142,3352,8,142,1,143,1,143,1,143,1,143,1,143,1,143,1,144,
  	1,144,1,144,1,144,1,144,1,145,1,145,1,145,3,145,3368,8,145,1,145,3,145,
  	3371,8,145,1,145,1,145,3,145,3375,8,145,1,146,1,146,3,146,3379,8,146,
  	1,146,1,146,1,147,1,147,3,147,3385,8,147,1,147,1,147,1,147,3,147,3390,
  	8,147,5,147,3392,8,147,10,147,12,147,3395,9,147,1,148,1,148,1,148,1,148,
  	1,148,1,149,1,149,1,149,1,149,1,149,1,150,1,150,1,150,1,150,1,150,1,151,
  	1,151,1,151,1,151,1,151,1,152,1,152,3,152,3419,8,152,1,152,3,152,3422,
  	8,152,1,152,1,152,3,152,3426,8,152,1,152,1,152,1,152,1,152,3,152,3432,
  	8,152,1,153,1,153,3,153,3436,8,153,1,153,3,153,3439,8,153,1,154,1,154,
  	1,154,1,154,1,154,1,154,1,154,3,154,3448,8,154,1,154,1,154,1,154,1,154,
  	1,154,1,154,1,154,1,154,3,154,3458,8,154,1,155,1,155,3,155,3462,8,155,
  	1,155,1,155,3,155,3466,8,155,1,155,3,155,3469,8,155,1,155,1,155,3,155,
  	3473,8,155,1,156,1,156,3,156,3477,8,156,1,156,1,156,1,156,3,156,3482,
  	8,156,1,156,3,156,3485,8,156,1,156,5,156,3488,8,156,10,156,12,156,3491,
  	9,156,1,157,1,157,1,157,3,157,3496,8,157,1,157,1,157,1,158,1,158,1,158,
  	1,158,1,158,3,158,3505,8,158,1,159,1,159,5,159,3509,8,159,10,159,12,159,
  	3512,9,159,1,159,1,159,3,159,3516,8,159,1,159,3,159,3519,8,159,1,159,
  	3,159,3522,8,159,1,159,3,159,3525,8,159,1,159,3,159,3528,8,159,1,159,
  	1,159,3,159,3532,8,159,1,159,3,159,3535,8,159,1,160,1,160,1,161,1,161,
  	1,162,1,162,1,162,1,163,1,163,1,163,1,164,1,164,1,164,3,164,3550,8,164,
  	1,165,1,165,3,165,3554,8,165,1,166,1,166,1,166,1,167,1,167,1,168,4,168,
  	3562,8,168,11,168,12,168,3563,1,169,1,169,1,169,1,169,1,169,1,169,1,169,
  	1,169,1,169,3,169,3575,8,169,1,170,1,170,1,170,1,170,1,170,3,170,3582,
  	8,170,1,170,1,170,1,170,3,170,3587,8,170,1,170,3,170,3590,8,170,1,170,
  	1,170,1,170,1,170,3,170,3596,8,170,1,170,3,170,3599,8,170,1,170,3,170,
  	3602,8,170,1,170,1,170,1,170,1,170,3,170,3608,8,170,1,170,1,170,1,170,
  	3,170,3613,8,170,5,170,3615,8,170,10,170,12,170,3618,9,170,3,170,3620,
  	8,170,1,171,1,171,1,171,1,171,1,171,1,171,3,171,3628,8,171,3,171,3630,
  	8,171,1,171,1,171,1,172,1,172,1,172,1,173,1,173,1,173,1,173,1,174,1,174,
  	1,174,1,174,5,174,3645,8,174,10,174,12,174,3648,9,174,1,175,1,175,1,175,
  	1,175,1,176,1,176,1,176,1,176,1,177,3,177,3659,8,177,1,177,1,177,1,177,
  	3,177,3664,8,177,1,177,3,177,3667,8,177,1,177,3,177,3670,8,177,1,178,
  	1,178,1,178,3,178,3675,8,178,1,179,1,179,1,180,1,180,3,180,3681,8,180,
  	1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,1,181,
  	1,181,1,181,3,181,3697,8,181,1,182,1,182,1,182,1,182,1,182,1,183,1,183,
  	1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,1,183,3,183,
  	3717,8,183,1,184,1,184,1,184,1,184,1,184,1,184,1,184,3,184,3726,8,184,
  	1,185,1,185,3,185,3730,8,185,1,185,1,185,1,185,5,185,3735,8,185,10,185,
  	12,185,3738,9,185,1,186,1,186,3,186,3742,8,186,1,186,1,186,1,186,1,187,
  	1,187,1,187,1,187,3,187,3751,8,187,1,187,1,187,1,187,1,187,1,187,1,187,
  	1,187,1,187,3,187,3761,8,187,1,188,1,188,1,188,1,188,1,188,3,188,3768,
  	8,188,1,189,1,189,1,189,1,189,1,190,1,190,1,191,1,191,1,191,3,191,3779,
  	8,191,1,192,1,192,1,192,5,192,3784,8,192,10,192,12,192,3787,9,192,1,193,
  	1,193,1,193,1,193,5,193,3793,8,193,10,193,12,193,3796,9,193,1,194,1,194,
  	1,194,1,195,1,195,1,195,3,195,3804,8,195,1,195,1,195,1,196,1,196,1,196,
  	1,196,1,196,1,196,1,196,1,196,3,196,3816,8,196,1,197,1,197,4,197,3820,
  	8,197,11,197,12,197,3821,1,198,1,198,1,198,1,198,1,198,3,198,3829,8,198,
  	1,198,1,198,3,198,3833,8,198,1,198,1,198,1,198,1,198,3,198,3839,8,198,
  	1,199,1,199,1,199,3,199,3844,8,199,1,200,1,200,1,200,3,200,3849,8,200,
  	1,201,1,201,3,201,3853,8,201,1,201,1,201,5,201,3857,8,201,10,201,12,201,
  	3860,9,201,1,202,1,202,1,202,3,202,3865,8,202,3,202,3867,8,202,1,203,
  	3,203,3870,8,203,1,203,1,203,3,203,3874,8,203,1,204,1,204,1,204,1,205,
  	1,205,1,205,1,205,1,205,3,205,3884,8,205,1,205,1,205,1,205,3,205,3889,
  	8,205,1,205,5,205,3892,8,205,10,205,12,205,3895,9,205,1,206,1,206,5,206,
  	3899,8,206,10,206,12,206,3902,9,206,1,207,1,207,1,207,1,207,1,207,1,207,
  	3,207,3910,8,207,1,207,1,207,1,207,1,207,1,207,1,207,3,207,3918,8,207,
  	1,207,1,207,1,207,3,207,3923,8,207,1,208,1,208,3,208,3927,8,208,1,208,
  	1,208,1,208,1,208,3,208,3933,8,208,1,208,3,208,3936,8,208,1,209,3,209,
  	3939,8,209,1,209,1,209,3,209,3943,8,209,1,210,1,210,3,210,3947,8,210,
  	1,210,1,210,1,211,1,211,1,211,1,211,1,211,1,211,3,211,3957,8,211,1,212,
  	1,212,3,212,3961,8,212,1,212,3,212,3964,8,212,1,212,3,212,3967,8,212,
  	1,212,3,212,3970,8,212,1,213,1,213,1,213,3,213,3975,8,213,1,213,1,213,
  	1,214,1,214,3,214,3981,8,214,1,214,1,214,3,214,3985,8,214,1,214,1,214,
  	1,214,1,214,3,214,3991,8,214,1,214,3,214,3994,8,214,3,214,3996,8,214,
  	1,215,1,215,1,215,3,215,4001,8,215,1,215,1,215,1,216,1,216,1,216,1,216,
  	1,216,1,216,1,216,1,216,3,216,4013,8,216,1,217,1,217,1,217,1,217,1,217,
  	5,217,4020,8,217,10,217,12,217,4023,9,217,1,217,1,217,1,218,1,218,1,218,
  	1,218,1,218,1,218,1,218,1,218,3,218,4035,8,218,1,218,3,218,4038,8,218,
  	1,218,1,218,1,218,3,218,4043,8,218,1,218,1,218,1,218,1,218,1,218,3,218,
  	4050,8,218,1,219,1,219,3,219,4054,8,219,1,219,3,219,4057,8,219,1,220,
  	1,220,1,220,1,220,3,220,4063,8,220,1,221,1,221,1,221,1,221,1,222,1,222,
  	1,222,1,222,1,223,1,223,1,223,1,223,3,223,4077,8,223,1,224,1,224,1,225,
  	1,225,1,225,3,225,4084,8,225,1,225,1,225,1,226,1,226,5,226,4090,8,226,
  	10,226,12,226,4093,9,226,1,227,1,227,1,227,3,227,4098,8,227,1,227,1,227,
  	1,227,1,227,1,227,1,227,1,227,3,227,4107,8,227,1,227,1,227,3,227,4111,
  	8,227,1,227,1,227,3,227,4115,8,227,1,228,1,228,1,229,1,229,1,230,1,230,
  	1,230,1,230,3,230,4125,8,230,3,230,4127,8,230,1,231,1,231,1,231,1,231,
  	1,231,1,231,3,231,4135,8,231,1,232,1,232,1,232,5,232,4140,8,232,10,232,
  	12,232,4143,9,232,1,233,1,233,3,233,4147,8,233,1,234,1,234,3,234,4151,
  	8,234,1,234,1,234,3,234,4155,8,234,1,234,3,234,4158,8,234,1,234,1,234,
  	1,234,1,234,3,234,4164,8,234,1,234,3,234,4167,8,234,1,234,3,234,4170,
  	8,234,1,235,1,235,1,235,1,235,3,235,4176,8,235,1,236,1,236,1,236,5,236,
  	4181,8,236,10,236,12,236,4184,9,236,1,236,1,236,3,236,4188,8,236,1,236,
  	1,236,3,236,4192,8,236,1,236,3,236,4195,8,236,1,236,3,236,4198,8,236,
  	1,236,3,236,4201,8,236,3,236,4203,8,236,1,237,1,237,3,237,4207,8,237,
  	1,238,1,238,1,238,1,238,1,238,3,238,4214,8,238,1,239,1,239,1,239,1,239,
  	3,239,4220,8,239,1,239,1,239,3,239,4224,8,239,1,239,1,239,1,239,3,239,
  	4229,8,239,1,239,3,239,4232,8,239,1,239,3,239,4235,8,239,1,239,3,239,
  	4238,8,239,3,239,4240,8,239,1,239,1,239,1,239,3,239,4245,8,239,1,240,
  	1,240,1,240,1,240,1,240,5,240,4252,8,240,10,240,12,240,4255,9,240,1,240,
  	1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,1,240,3,240,4267,8,240,
  	3,240,4269,8,240,1,241,1,241,3,241,4273,8,241,1,241,1,241,1,242,1,242,
  	3,242,4279,8,242,1,242,1,242,3,242,4283,8,242,1,242,3,242,4286,8,242,
  	1,243,1,243,1,243,1,243,3,243,4292,8,243,1,243,1,243,1,243,1,243,1,243,
  	3,243,4299,8,243,3,243,4301,8,243,1,243,1,243,1,243,1,243,1,243,1,243,
  	3,243,4309,8,243,1,243,1,243,1,243,1,243,3,243,4315,8,243,1,244,1,244,
  	1,244,3,244,4320,8,244,1,244,3,244,4323,8,244,1,245,1,245,1,245,1,245,
  	1,245,3,245,4330,8,245,3,245,4332,8,245,1,246,1,246,1,246,1,246,1,246,
  	1,246,1,246,1,246,5,246,4342,8,246,10,246,12,246,4345,9,246,1,246,1,246,
  	1,246,1,246,3,246,4351,8,246,1,246,1,246,1,246,1,246,3,246,4357,8,246,
  	1,247,1,247,1,247,3,247,4362,8,247,1,247,1,247,1,247,1,247,1,247,3,247,
  	4369,8,247,1,248,1,248,3,248,4373,8,248,1,248,1,248,1,248,1,248,1,248,
  	3,248,4380,8,248,1,248,3,248,4383,8,248,3,248,4385,8,248,1,249,1,249,
  	1,249,1,249,1,249,1,249,1,249,3,249,4394,8,249,1,250,1,250,1,250,1,250,
  	1,251,1,251,1,251,1,251,1,251,3,251,4405,8,251,1,252,1,252,1,252,1,252,
  	1,252,3,252,4412,8,252,1,253,1,253,1,253,5,253,4417,8,253,10,253,12,253,
  	4420,9,253,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,
  	1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,1,254,3,254,4550,
  	8,254,1,255,1,255,1,256,1,256,1,257,1,257,1,258,1,258,1,259,1,259,1,260,
  	1,260,1,261,1,261,1,262,1,262,1,263,1,263,1,264,1,264,1,265,1,265,1,266,
  	1,266,1,267,1,267,1,268,1,268,1,269,1,269,1,270,1,270,1,271,1,271,1,272,
  	1,272,1,273,1,273,1,274,1,274,1,275,1,275,1,276,1,276,1,277,1,277,1,278,
  	1,278,1,279,1,279,1,280,1,280,3,280,4604,8,280,1,281,1,281,1,282,1,282,
  	1,282,3,282,4611,8,282,1,283,1,283,3,283,4615,8,283,1,284,1,284,1,284,
  	1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,1,284,3,284,
  	4631,8,284,1,285,1,285,1,286,1,286,1,287,1,287,1,287,1,287,5,287,4641,
  	8,287,10,287,12,287,4644,9,287,3,287,4646,8,287,1,287,1,287,1,288,1,288,
  	1,288,1,288,1,288,1,288,5,288,4656,8,288,10,288,12,288,4659,9,288,1,288,
  	1,288,3,288,4663,8,288,1,289,1,289,1,289,1,289,3,289,4669,8,289,1,289,
  	1,289,1,289,1,289,1,289,3,289,4676,8,289,1,289,1,289,1,289,1,289,1,289,
  	3,289,4683,8,289,1,289,1,289,1,289,1,289,1,289,3,289,4690,8,289,1,289,
  	1,289,1,289,1,289,1,289,3,289,4697,8,289,1,289,1,289,1,289,1,289,1,289,
  	3,289,4704,8,289,1,289,1,289,1,289,1,289,1,289,3,289,4711,8,289,1,289,
  	3,289,4714,8,289,1,290,1,290,1,290,5,290,4719,8,290,10,290,12,290,4722,
  	9,290,1,291,1,291,1,291,5,291,4727,8,291,10,291,12,291,4730,9,291,1,292,
  	1,292,1,292,5,292,4735,8,292,10,292,12,292,4738,9,292,1,293,1,293,1,294,
  	1,294,1,294,5,294,4745,8,294,10,294,12,294,4748,9,294,1,295,1,295,1,295,
  	3,295,4753,8,295,1,295,1,295,3,295,4757,8,295,1,295,3,295,4760,8,295,
  	1,295,3,295,4763,8,295,1,295,3,295,4766,8,295,1,295,3,295,4769,8,295,
  	1,295,3,295,4772,8,295,1,296,1,296,1,296,3,296,4777,8,296,1,296,3,296,
  	4780,8,296,1,297,1,297,1,297,1,297,1,297,3,297,4787,8,297,1,297,1,297,
  	5,297,4791,8,297,10,297,12,297,4794,9,297,1,298,1,298,1,298,1,298,1,299,
  	1,299,1,299,1,299,1,300,1,300,1,300,1,300,1,301,1,301,1,301,1,301,1,302,
  	1,302,1,302,5,302,4815,8,302,10,302,12,302,4818,9,302,1,303,1,303,1,304,
  	1,304,1,304,1,304,3,304,4826,8,304,1,304,1,304,3,304,4830,8,304,1,305,
  	1,305,1,305,5,305,4835,8,305,10,305,12,305,4838,9,305,1,306,1,306,1,306,
  	3,306,4843,8,306,1,307,1,307,1,307,1,307,1,308,1,308,1,308,1,308,1,309,
  	1,309,1,309,1,309,1,310,1,310,1,310,3,310,4860,8,310,1,311,1,311,1,311,
  	1,311,1,311,3,311,4867,8,311,1,311,1,311,1,311,1,311,3,311,4873,8,311,
  	1,312,1,312,1,312,1,312,3,312,4879,8,312,1,313,1,313,1,313,5,313,4884,
  	8,313,10,313,12,313,4887,9,313,1,314,1,314,1,314,1,314,1,314,3,314,4894,
  	8,314,1,314,1,314,1,314,1,314,3,314,4900,8,314,1,314,1,314,1,314,1,314,
  	1,314,1,314,1,314,1,314,1,314,1,314,3,314,4912,8,314,3,314,4914,8,314,
  	1,315,1,315,1,315,1,315,3,315,4920,8,315,1,315,1,315,3,315,4924,8,315,
  	3,315,4926,8,315,1,316,1,316,3,316,4930,8,316,1,316,1,316,1,317,1,317,
  	1,317,1,317,1,317,1,317,1,317,1,317,3,317,4942,8,317,1,318,1,318,1,318,
  	1,318,3,318,4948,8,318,1,318,1,318,1,318,1,318,3,318,4954,8,318,1,318,
  	1,318,1,318,1,318,1,318,1,318,3,318,4962,8,318,1,318,1,318,3,318,4966,
  	8,318,1,318,1,318,3,318,4970,8,318,1,318,1,318,1,318,1,318,3,318,4976,
  	8,318,3,318,4978,8,318,1,318,1,318,1,318,1,318,1,318,1,318,1,318,1,318,
  	1,318,1,318,1,318,3,318,4991,8,318,1,318,1,318,3,318,4995,8,318,3,318,
  	4997,8,318,3,318,4999,8,318,1,319,1,319,1,319,5,319,5004,8,319,10,319,
  	12,319,5007,9,319,1,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,3,320,
  	5017,8,320,1,320,3,320,5020,8,320,3,320,5022,8,320,1,320,1,320,3,320,
  	5026,8,320,1,320,1,320,1,320,3,320,5031,8,320,3,320,5033,8,320,1,320,
  	1,320,1,320,3,320,5038,8,320,1,320,1,320,1,320,1,320,3,320,5044,8,320,
  	1,320,3,320,5047,8,320,3,320,5049,8,320,1,320,1,320,3,320,5053,8,320,
  	1,320,3,320,5056,8,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,
  	3,320,5066,8,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,1,320,3,320,
  	5076,8,320,1,320,1,320,1,320,1,320,1,320,3,320,5083,8,320,3,320,5085,
  	8,320,3,320,5087,8,320,1,321,1,321,1,321,1,321,1,321,1,321,3,321,5095,
  	8,321,1,321,1,321,3,321,5099,8,321,1,321,1,321,1,321,1,321,3,321,5105,
  	8,321,1,321,3,321,5108,8,321,3,321,5110,8,321,1,321,1,321,1,321,1,321,
  	1,321,1,321,1,321,1,321,3,321,5120,8,321,1,321,1,321,3,321,5124,8,321,
  	1,321,1,321,1,321,1,321,3,321,5130,8,321,1,321,1,321,1,321,1,321,1,321,
  	3,321,5137,8,321,3,321,5139,8,321,1,321,1,321,1,321,3,321,5144,8,321,
  	3,321,5146,8,321,1,322,1,322,1,322,1,323,1,323,1,323,1,323,3,323,5155,
  	8,323,1,323,1,323,1,323,1,323,1,324,1,324,3,324,5163,8,324,1,324,3,324,
  	5166,8,324,1,324,5,324,5169,8,324,10,324,12,324,5172,9,324,1,324,1,324,
  	3,324,5176,8,324,1,324,3,324,5179,8,324,1,325,1,325,1,325,1,325,3,325,
  	5185,8,325,1,326,1,326,1,326,1,326,3,326,5191,8,326,1,326,3,326,5194,
  	8,326,1,327,1,327,1,327,3,327,5199,8,327,1,328,1,328,1,328,1,328,1,328,
  	1,328,1,328,1,328,1,328,4,328,5210,8,328,11,328,12,328,5211,1,329,1,329,
  	1,329,1,329,1,329,1,329,1,329,1,329,1,329,1,329,3,329,5224,8,329,1,329,
  	1,329,1,329,3,329,5229,8,329,1,329,1,329,1,329,1,329,1,329,1,329,3,329,
  	5237,8,329,1,329,1,329,1,329,1,329,3,329,5243,8,329,3,329,5245,8,329,
  	1,329,1,329,1,329,1,329,1,329,1,329,1,329,3,329,5254,8,329,3,329,5256,
  	8,329,1,330,1,330,1,330,1,330,3,330,5262,8,330,1,330,1,330,1,331,1,331,
  	1,331,1,331,1,331,1,331,1,331,1,331,3,331,5274,8,331,1,331,1,331,1,331,
  	3,331,5279,8,331,3,331,5281,8,331,1,331,1,331,3,331,5285,8,331,1,331,
  	1,331,1,331,1,331,3,331,5291,8,331,1,331,3,331,5294,8,331,1,331,3,331,
  	5297,8,331,1,331,1,331,1,331,1,331,1,331,1,331,1,331,1,331,3,331,5307,
  	8,331,3,331,5309,8,331,1,332,1,332,1,332,1,332,3,332,5315,8,332,1,333,
  	1,333,1,333,1,334,1,334,1,334,1,335,1,335,1,335,1,335,1,335,3,335,5328,
  	8,335,1,335,1,335,3,335,5332,8,335,1,336,1,336,1,336,3,336,5337,8,336,
  	1,337,1,337,1,337,1,338,1,338,1,338,1,338,1,338,1,338,1,338,1,338,1,338,
  	1,338,5,338,5352,8,338,10,338,12,338,5355,9,338,1,339,1,339,1,339,3,339,
  	5360,8,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,3,339,5370,
  	8,339,1,339,1,339,1,339,1,339,1,339,1,339,3,339,5378,8,339,1,339,1,339,
  	1,339,3,339,5383,8,339,1,339,1,339,1,339,1,339,3,339,5389,8,339,1,339,
  	1,339,1,339,1,339,1,339,1,339,1,339,1,339,3,339,5399,8,339,1,339,1,339,
  	3,339,5403,8,339,1,340,1,340,1,341,1,341,1,341,5,341,5410,8,341,10,341,
  	12,341,5413,9,341,1,342,1,342,1,342,3,342,5418,8,342,1,342,1,342,1,342,
  	1,342,3,342,5424,8,342,3,342,5426,8,342,1,342,1,342,3,342,5430,8,342,
  	1,342,1,342,1,342,1,342,1,342,1,342,1,342,1,342,1,342,3,342,5441,8,342,
  	1,342,1,342,1,342,1,342,1,342,3,342,5448,8,342,1,342,1,342,1,342,1,342,
  	3,342,5454,8,342,1,342,1,342,1,342,3,342,5459,8,342,1,343,1,343,1,343,
  	3,343,5464,8,343,1,343,1,343,1,343,3,343,5469,8,343,1,343,1,343,1,343,
  	1,343,1,343,1,343,3,343,5477,8,343,1,344,1,344,3,344,5481,8,344,1,344,
  	5,344,5484,8,344,10,344,12,344,5487,9,344,1,345,1,345,1,345,1,345,1,345,
  	1,345,3,345,5495,8,345,1,346,1,346,1,346,1,346,1,346,1,346,1,346,1,346,
  	1,346,1,346,1,346,3,346,5508,8,346,3,346,5510,8,346,1,347,1,347,1,347,
  	1,347,1,347,1,347,1,347,1,347,1,347,1,347,1,347,1,347,3,347,5524,8,347,
  	1,347,1,347,1,347,1,347,1,347,1,347,1,347,3,347,5533,8,347,3,347,5535,
  	8,347,1,348,1,348,1,348,5,348,5540,8,348,10,348,12,348,5543,9,348,1,349,
  	1,349,1,349,1,349,3,349,5549,8,349,3,349,5551,8,349,1,350,1,350,3,350,
  	5555,8,350,1,350,1,350,1,350,1,350,3,350,5561,8,350,1,350,1,350,1,350,
  	1,350,5,350,5567,8,350,10,350,12,350,5570,9,350,1,350,1,350,1,350,1,350,
  	3,350,5576,8,350,1,350,1,350,3,350,5580,8,350,1,350,1,350,1,350,1,350,
  	3,350,5586,8,350,1,350,1,350,1,350,5,350,5591,8,350,10,350,12,350,5594,
  	9,350,3,350,5596,8,350,1,351,1,351,1,351,1,351,1,352,3,352,5603,8,352,
  	1,352,3,352,5606,8,352,1,352,1,352,1,352,1,352,3,352,5612,8,352,1,353,
  	1,353,1,353,1,353,1,354,1,354,1,354,1,354,1,354,1,354,1,354,1,354,1,354,
  	1,354,3,354,5628,8,354,1,355,1,355,1,355,3,355,5633,8,355,1,356,1,356,
  	1,357,1,357,1,357,1,357,1,357,1,357,1,357,5,357,5644,8,357,10,357,12,
  	357,5647,9,357,3,357,5649,8,357,1,358,1,358,1,358,1,358,1,358,1,358,1,
  	358,1,358,1,358,3,358,5660,8,358,3,358,5662,8,358,1,359,1,359,1,360,1,
  	360,3,360,5668,8,360,1,361,1,361,1,361,1,361,1,361,1,362,1,362,1,362,
  	1,362,1,362,5,362,5680,8,362,10,362,12,362,5683,9,362,1,363,1,363,1,363,
  	1,364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,3,364,
  	5699,8,364,1,364,1,364,1,364,3,364,5704,8,364,1,364,3,364,5707,8,364,
  	1,364,1,364,3,364,5711,8,364,1,364,3,364,5714,8,364,1,364,1,364,1,364,
  	1,364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,1,364,3,364,5728,8,364,
  	1,364,1,364,1,364,1,364,3,364,5734,8,364,1,364,1,364,1,364,3,364,5739,
  	8,364,1,364,3,364,5742,8,364,3,364,5744,8,364,1,365,1,365,3,365,5748,
  	8,365,1,365,1,365,1,365,3,365,5753,8,365,3,365,5755,8,365,1,366,1,366,
  	1,366,1,367,1,367,1,367,1,367,1,367,1,367,1,367,3,367,5767,8,367,1,368,
  	1,368,5,368,5771,8,368,10,368,12,368,5774,9,368,1,369,1,369,1,369,1,369,
  	1,369,1,369,1,369,1,369,1,369,1,369,1,369,1,369,3,369,5788,8,369,1,369,
  	1,369,1,369,1,369,1,369,1,369,1,369,1,369,1,369,1,369,3,369,5800,8,369,
  	1,369,1,369,3,369,5804,8,369,3,369,5806,8,369,1,370,1,370,1,370,1,370,
  	1,370,1,370,3,370,5814,8,370,1,371,1,371,1,371,1,371,1,371,3,371,5821,
  	8,371,1,372,1,372,1,372,1,372,1,373,1,373,1,373,1,373,1,373,1,373,1,373,
  	1,373,1,373,3,373,5836,8,373,1,374,1,374,1,374,3,374,5841,8,374,1,375,
  	1,375,3,375,5845,8,375,1,375,1,375,3,375,5849,8,375,1,375,3,375,5852,
  	8,375,1,376,1,376,3,376,5856,8,376,1,376,1,376,3,376,5860,8,376,1,376,
  	3,376,5863,8,376,1,377,1,377,1,377,3,377,5868,8,377,1,377,3,377,5871,
  	8,377,1,378,1,378,1,378,1,378,3,378,5877,8,378,1,378,3,378,5880,8,378,
  	1,379,1,379,1,379,1,379,3,379,5886,8,379,1,379,3,379,5889,8,379,1,380,
  	1,380,1,380,1,380,1,380,1,381,1,381,1,381,1,382,1,382,1,382,1,382,1,382,
  	1,383,1,383,1,383,1,383,1,383,1,384,1,384,1,384,1,384,1,384,1,385,1,385,
  	3,385,5916,8,385,1,385,1,385,1,385,1,385,3,385,5922,8,385,1,385,3,385,
  	5925,8,385,1,386,1,386,1,386,1,386,3,386,5931,8,386,1,386,1,386,1,387,
  	1,387,1,387,1,387,1,387,1,388,1,388,1,388,1,388,3,388,5944,8,388,1,389,
  	1,389,1,389,1,389,1,389,3,389,5951,8,389,1,389,1,389,3,389,5955,8,389,
  	1,389,3,389,5958,8,389,1,389,3,389,5961,8,389,1,390,1,390,1,390,1,390,
  	1,390,3,390,5968,8,390,1,390,1,390,3,390,5972,8,390,1,390,3,390,5975,
  	8,390,1,390,3,390,5978,8,390,1,391,1,391,1,391,3,391,5983,8,391,1,391,
  	1,391,1,391,1,391,3,391,5989,8,391,1,391,3,391,5992,8,391,1,392,1,392,
  	3,392,5996,8,392,1,392,1,392,1,393,1,393,1,393,1,393,1,393,1,393,1,393,
  	1,394,1,394,1,394,1,394,1,394,1,394,1,394,1,395,1,395,1,395,3,395,6017,
  	8,395,1,396,1,396,1,396,3,396,6022,8,396,1,397,1,397,1,397,1,398,1,398,
  	1,398,3,398,6030,8,398,1,398,1,398,1,398,3,398,6035,8,398,1,398,3,398,
  	6038,8,398,1,399,1,399,3,399,6042,8,399,1,399,1,399,3,399,6046,8,399,
  	1,400,1,400,3,400,6050,8,400,1,400,1,400,1,401,1,401,3,401,6056,8,401,
  	1,401,1,401,3,401,6060,8,401,1,402,1,402,1,402,3,402,6065,8,402,1,403,
  	1,403,1,403,3,403,6070,8,403,1,404,1,404,1,404,1,405,1,405,1,405,1,405,
  	1,405,1,405,3,405,6081,8,405,3,405,6083,8,405,1,406,1,406,1,406,1,406,
  	3,406,6089,8,406,1,406,1,406,1,407,1,407,1,407,1,407,1,407,1,408,1,408,
  	1,408,1,408,1,408,1,409,1,409,1,409,1,409,1,410,1,410,1,410,1,410,1,410,
  	3,410,6112,8,410,1,410,3,410,6115,8,410,1,411,1,411,1,411,1,411,1,411,
  	1,412,1,412,1,412,1,412,1,412,1,413,1,413,1,413,1,413,1,413,1,414,1,414,
  	1,414,1,414,1,414,1,415,1,415,1,415,1,415,3,415,6141,8,415,1,416,1,416,
  	1,416,1,416,3,416,6147,8,416,1,417,1,417,1,417,1,417,1,417,1,418,1,418,
  	1,418,1,418,1,418,1,419,1,419,1,419,1,419,1,419,1,420,1,420,1,420,1,420,
  	1,420,1,421,1,421,1,421,1,421,3,421,6173,8,421,3,421,6175,8,421,1,422,
  	1,422,3,422,6179,8,422,1,423,1,423,1,424,1,424,1,424,1,425,1,425,1,425,
  	5,425,6189,8,425,10,425,12,425,6192,9,425,1,426,1,426,1,426,1,426,1,426,
  	1,426,1,426,3,426,6201,8,426,1,427,1,427,1,427,1,427,1,427,1,427,1,427,
  	1,427,3,427,6211,8,427,1,427,1,427,3,427,6215,8,427,1,427,1,427,1,427,
  	1,427,5,427,6221,8,427,10,427,12,427,6224,9,427,3,427,6226,8,427,1,427,
  	1,427,3,427,6230,8,427,1,427,1,427,1,427,1,427,1,427,1,427,1,427,1,427,
  	3,427,6240,8,427,1,428,1,428,3,428,6244,8,428,1,429,1,429,1,429,5,429,
  	6249,8,429,10,429,12,429,6252,9,429,1,430,1,430,3,430,6256,8,430,1,431,
  	1,431,1,431,1,431,1,431,1,431,3,431,6264,8,431,1,432,1,432,1,432,3,432,
  	6269,8,432,1,432,1,432,1,433,1,433,3,433,6275,8,433,1,434,1,434,1,434,
  	5,434,6280,8,434,10,434,12,434,6283,9,434,1,435,1,435,1,435,1,435,3,435,
  	6289,8,435,1,435,1,435,1,435,1,435,3,435,6295,8,435,1,435,1,435,1,435,
  	1,435,1,435,3,435,6302,8,435,1,436,1,436,1,437,1,437,1,437,1,437,1,437,
  	1,437,3,437,6312,8,437,3,437,6314,8,437,1,438,1,438,1,438,1,438,1,438,
  	3,438,6321,8,438,1,439,1,439,1,439,3,439,6326,8,439,1,439,1,439,3,439,
  	6330,8,439,1,439,3,439,6333,8,439,1,440,1,440,1,440,5,440,6338,8,440,
  	10,440,12,440,6341,9,440,1,441,1,441,3,441,6345,8,441,1,441,1,441,3,441,
  	6349,8,441,1,442,1,442,1,442,1,442,1,442,1,443,1,443,1,443,1,443,3,443,
  	6360,8,443,1,444,1,444,1,444,1,444,1,444,1,444,3,444,6368,8,444,1,444,
  	1,444,3,444,6372,8,444,1,444,3,444,6375,8,444,1,444,3,444,6378,8,444,
  	1,445,1,445,3,445,6382,8,445,1,445,1,445,3,445,6386,8,445,1,445,5,445,
  	6389,8,445,10,445,12,445,6392,9,445,1,446,1,446,1,446,3,446,6397,8,446,
  	1,447,1,447,3,447,6401,8,447,1,447,1,447,1,448,1,448,1,449,1,449,1,449,
  	1,449,1,449,3,449,6412,8,449,1,449,3,449,6415,8,449,1,449,3,449,6418,
  	8,449,1,449,3,449,6421,8,449,1,450,1,450,1,450,1,450,1,450,1,450,3,450,
  	6429,8,450,1,451,1,451,3,451,6433,8,451,1,451,5,451,6436,8,451,10,451,
  	12,451,6439,9,451,1,452,1,452,1,452,1,452,1,452,3,452,6446,8,452,1,453,
  	1,453,1,453,1,453,1,453,1,453,3,453,6454,8,453,1,454,1,454,1,454,1,454,
  	3,454,6460,8,454,1,455,1,455,3,455,6464,8,455,1,455,1,455,1,455,1,455,
  	3,455,6470,8,455,1,455,1,455,1,456,1,456,1,456,1,456,1,456,3,456,6479,
  	8,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,1,456,
  	3,456,6492,8,456,1,457,1,457,1,457,1,457,1,457,1,457,1,457,1,457,3,457,
  	6502,8,457,1,458,1,458,1,458,1,458,1,459,1,459,1,459,1,460,1,460,1,460,
  	1,461,1,461,1,462,1,462,1,462,1,462,3,462,6520,8,462,1,462,3,462,6523,
  	8,462,1,462,1,462,3,462,6527,8,462,1,462,1,462,1,462,1,462,1,462,1,462,
  	1,462,1,462,1,462,5,462,6538,8,462,10,462,12,462,6541,9,462,1,463,1,463,
  	1,463,1,463,1,463,1,463,3,463,6549,8,463,1,463,1,463,1,463,1,463,1,463,
  	1,463,1,463,1,463,1,463,1,463,5,463,6561,8,463,10,463,12,463,6564,9,463,
  	1,464,1,464,1,465,1,465,3,465,6570,8,465,1,465,1,465,1,465,1,465,3,465,
  	6576,8,465,1,465,1,465,1,465,1,465,3,465,6582,8,465,1,466,1,466,1,466,
  	1,466,1,466,1,466,3,466,6590,8,466,1,466,1,466,1,466,1,466,1,466,1,466,
  	1,466,1,466,1,466,3,466,6601,8,466,1,466,1,466,3,466,6605,8,466,1,467,
  	1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,
  	1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,1,467,
  	1,467,1,467,5,467,6634,8,467,10,467,12,467,6637,9,467,1,468,1,468,1,468,
  	3,468,6642,8,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,3,468,6661,8,468,1,468,
  	1,468,1,468,1,468,1,468,3,468,6668,8,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,1,468,1,468,1,468,1,468,1,468,1,468,3,468,6682,8,468,1,468,1,468,
  	1,468,1,468,1,468,1,468,1,468,1,468,1,468,3,468,6693,8,468,1,468,1,468,
  	1,468,3,468,6698,8,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,1,468,3,468,6710,8,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,3,468,6720,8,468,1,468,1,468,1,468,4,468,6725,8,468,11,468,12,468,
  	6726,1,468,3,468,6730,8,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,1,468,
  	1,468,3,468,6764,8,468,1,468,1,468,1,468,1,468,1,468,1,468,5,468,6772,
  	8,468,10,468,12,468,6775,9,468,1,469,1,469,1,469,1,470,1,470,1,470,1,
  	470,1,470,1,470,3,470,6786,8,470,1,471,1,471,1,471,3,471,6791,8,471,1,
  	471,1,471,1,471,1,471,3,471,6797,8,471,1,471,1,471,1,471,1,471,1,471,
  	1,471,3,471,6805,8,471,1,471,1,471,1,471,1,471,1,471,1,471,3,471,6813,
  	8,471,1,471,1,471,1,471,3,471,6818,8,471,1,471,1,471,1,471,3,471,6823,
  	8,471,1,471,1,471,1,471,1,471,3,471,6829,8,471,1,471,1,471,1,471,3,471,
  	6834,8,471,1,471,1,471,1,471,3,471,6839,8,471,1,471,1,471,1,471,1,471,
  	3,471,6845,8,471,1,471,1,471,1,471,1,471,1,471,1,471,3,471,6853,8,471,
  	1,471,1,471,1,471,1,471,1,471,1,471,1,471,3,471,6862,8,471,1,471,1,471,
  	1,471,3,471,6867,8,471,1,471,1,471,3,471,6871,8,471,1,471,1,471,3,471,
  	6875,8,471,1,471,1,471,1,471,3,471,6880,8,471,3,471,6882,8,471,1,472,
  	1,472,1,472,1,472,1,472,1,473,1,473,1,473,1,473,1,473,1,473,1,473,1,473,
  	1,473,1,473,1,473,3,473,6900,8,473,1,473,1,473,1,473,1,473,1,473,1,473,
  	3,473,6908,8,473,1,473,1,473,3,473,6912,8,473,1,473,1,473,1,473,1,473,
  	1,473,3,473,6919,8,473,1,473,1,473,1,473,1,473,1,473,1,473,1,473,1,473,
  	1,473,1,473,3,473,6931,8,473,1,473,3,473,6934,8,473,1,473,1,473,3,473,
  	6938,8,473,1,474,1,474,1,475,1,475,1,475,1,475,3,475,6946,8,475,1,476,
  	1,476,1,476,1,476,1,476,1,476,1,476,1,477,1,477,1,477,3,477,6958,8,477,
  	1,478,1,478,1,478,1,478,1,478,3,478,6965,8,478,1,478,1,478,3,478,6969,
  	8,478,1,479,1,479,3,479,6973,8,479,1,480,1,480,1,480,3,480,6978,8,480,
  	1,481,1,481,1,481,1,482,1,482,1,482,1,482,1,482,3,482,6988,8,482,1,482,
  	1,482,1,482,1,482,1,482,1,482,1,482,3,482,6997,8,482,3,482,6999,8,482,
  	1,483,3,483,7002,8,483,1,483,1,483,1,484,1,484,1,484,1,484,1,484,3,484,
  	7011,8,484,1,485,1,485,1,485,5,485,7016,8,485,10,485,12,485,7019,9,485,
  	1,486,1,486,1,486,1,486,1,486,1,486,1,486,1,486,1,486,1,486,3,486,7031,
  	8,486,1,486,1,486,1,486,3,486,7036,8,486,1,487,1,487,1,487,1,487,1,487,
  	3,487,7043,8,487,1,487,1,487,1,487,1,487,3,487,7049,8,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,4,487,7073,8,487,11,487,
  	12,487,7074,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,3,487,
  	7086,8,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,3,487,7118,8,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,3,487,7137,8,487,1,487,1,487,1,487,1,487,3,487,
  	7143,8,487,1,487,1,487,3,487,7147,8,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	3,487,7178,8,487,1,487,1,487,1,487,1,487,3,487,7184,8,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,3,487,7196,8,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,3,487,7209,
  	8,487,1,487,1,487,3,487,7213,8,487,1,487,1,487,3,487,7217,8,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,3,487,7245,8,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,1,487,3,487,7295,8,487,1,487,1,487,1,487,1,487,1,487,
  	1,487,1,487,1,487,3,487,7305,8,487,1,487,1,487,3,487,7309,8,487,1,487,
  	1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,1,487,3,487,7321,8,487,
  	1,487,1,487,1,487,3,487,7326,8,487,1,488,1,488,1,488,1,489,1,489,1,489,
  	1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,3,489,7342,8,489,1,489,
  	1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,1,489,
  	1,489,1,489,1,489,1,489,1,489,3,489,7362,8,489,1,490,1,490,3,490,7366,
  	8,490,1,490,1,490,1,491,1,491,1,492,1,492,1,492,1,492,1,492,1,492,1,492,
  	1,492,5,492,7380,8,492,10,492,12,492,7383,9,492,3,492,7385,8,492,1,493,
  	1,493,1,493,3,493,7390,8,493,1,493,3,493,7393,8,493,1,494,1,494,1,495,
  	1,495,1,495,1,495,1,495,3,495,7402,8,495,1,495,1,495,3,495,7406,8,495,
  	1,495,1,495,1,495,1,495,3,495,7412,8,495,1,495,1,495,1,495,1,495,3,495,
  	7418,8,495,1,495,1,495,3,495,7422,8,495,1,495,1,495,1,496,1,496,1,496,
  	1,496,1,496,1,496,1,496,3,496,7433,8,496,1,496,1,496,1,496,1,496,3,496,
  	7439,8,496,3,496,7441,8,496,1,496,1,496,1,497,1,497,1,497,3,497,7448,
  	8,497,1,497,1,497,1,497,1,497,1,497,3,497,7455,8,497,1,497,1,497,3,497,
  	7459,8,497,1,498,1,498,1,498,5,498,7464,8,498,10,498,12,498,7467,9,498,
  	1,499,1,499,3,499,7471,8,499,1,500,1,500,1,500,1,501,1,501,3,501,7478,
  	8,501,1,502,1,502,1,502,1,502,1,503,1,503,1,503,1,503,3,503,7488,8,503,
  	1,503,3,503,7491,8,503,1,504,1,504,3,504,7495,8,504,1,504,1,504,1,504,
  	3,504,7500,8,504,3,504,7502,8,504,1,504,1,504,3,504,7506,8,504,1,505,
  	1,505,3,505,7510,8,505,1,506,1,506,1,506,1,507,1,507,1,507,1,508,1,508,
  	1,508,1,509,1,509,3,509,7523,8,509,1,509,1,509,3,509,7527,8,509,1,509,
  	3,509,7530,8,509,1,509,1,509,3,509,7534,8,509,1,509,1,509,3,509,7538,
  	8,509,1,509,1,509,3,509,7542,8,509,1,509,1,509,1,509,1,509,1,509,3,509,
  	7549,8,509,1,509,1,509,3,509,7553,8,509,1,509,1,509,3,509,7557,8,509,
  	1,509,1,509,1,509,1,509,1,509,1,509,1,509,3,509,7566,8,509,1,509,1,509,
  	3,509,7570,8,509,1,510,1,510,1,510,5,510,7575,8,510,10,510,12,510,7578,
  	9,510,1,511,1,511,1,511,3,511,7583,8,511,1,512,1,512,1,513,1,513,1,514,
  	1,514,3,514,7591,8,514,1,515,1,515,1,516,1,516,1,516,1,516,1,517,1,517,
  	1,517,1,517,1,518,1,518,1,518,1,518,1,519,1,519,1,519,5,519,7610,8,519,
  	10,519,12,519,7613,9,519,1,520,1,520,3,520,7617,8,520,1,521,1,521,1,521,
  	5,521,7622,8,521,10,521,12,521,7625,9,521,1,522,1,522,1,523,1,523,1,523,
  	1,523,1,523,1,524,1,524,1,524,1,524,1,524,1,524,1,524,1,524,1,524,1,524,
  	1,524,1,524,1,524,3,524,7647,8,524,1,525,1,525,1,525,1,526,1,526,1,526,
  	1,526,1,526,1,527,1,527,1,527,1,527,1,527,1,527,3,527,7663,8,527,1,528,
  	1,528,1,528,1,529,1,529,1,529,4,529,7671,8,529,11,529,12,529,7672,1,530,
  	1,530,3,530,7677,8,530,1,530,1,530,1,530,4,530,7682,8,530,11,530,12,530,
  	7683,1,530,3,530,7687,8,530,1,530,1,530,1,530,1,531,1,531,1,531,1,532,
  	1,532,1,532,3,532,7698,8,532,1,533,1,533,1,534,1,534,1,534,1,535,1,535,
  	3,535,7707,8,535,1,535,3,535,7710,8,535,1,535,1,535,1,536,1,536,1,536,
  	3,536,7717,8,536,1,537,1,537,1,537,3,537,7722,8,537,1,538,1,538,1,538,
  	1,538,1,538,1,539,1,539,1,539,1,539,1,539,1,539,1,539,1,540,1,540,1,540,
  	1,540,1,540,1,540,1,540,1,541,1,541,1,541,4,541,7746,8,541,11,541,12,
  	541,7747,1,542,1,542,1,542,1,542,3,542,7754,8,542,1,543,1,543,1,543,1,
  	543,3,543,7760,8,543,1,543,1,543,3,543,7764,8,543,1,544,1,544,1,544,1,
  	544,1,544,1,544,1,545,1,545,3,545,7774,8,545,1,546,1,546,3,546,7778,8,
  	546,1,546,1,546,1,547,1,547,1,547,1,547,1,547,1,547,1,547,5,547,7789,
  	8,547,10,547,12,547,7792,9,547,1,547,1,547,1,548,1,548,1,548,1,548,1,
  	548,1,548,1,548,3,548,7803,8,548,1,549,1,549,1,549,1,549,1,549,1,549,
  	1,550,1,550,1,550,1,551,1,551,1,551,1,552,1,552,3,552,7819,8,552,1,552,
  	1,552,1,552,1,552,5,552,7825,8,552,10,552,12,552,7828,9,552,1,552,1,552,
  	1,552,1,552,1,552,5,552,7835,8,552,10,552,12,552,7838,9,552,3,552,7840,
  	8,552,1,553,1,553,1,553,3,553,7845,8,553,1,554,1,554,3,554,7849,8,554,
  	1,554,1,554,1,554,1,555,1,555,3,555,7856,8,555,1,555,1,555,1,555,3,555,
  	7861,8,555,1,556,1,556,1,557,1,557,1,557,3,557,7868,8,557,1,557,1,557,
  	1,557,1,557,5,557,7874,8,557,10,557,12,557,7877,9,557,3,557,7879,8,557,
  	1,558,1,558,1,558,3,558,7884,8,558,1,558,1,558,1,558,1,558,5,558,7890,
  	8,558,10,558,12,558,7893,9,558,3,558,7895,8,558,1,559,1,559,1,559,1,559,
  	1,560,1,560,1,560,1,561,1,561,1,561,1,562,1,562,3,562,7909,8,562,1,562,
  	3,562,7912,8,562,1,562,1,562,1,562,1,562,1,563,1,563,1,563,1,563,1,563,
  	1,563,1,563,3,563,7925,8,563,1,563,1,563,3,563,7929,8,563,3,563,7931,
  	8,563,1,564,1,564,1,564,3,564,7936,8,564,1,565,1,565,1,565,3,565,7941,
  	8,565,1,566,1,566,1,566,1,567,1,567,3,567,7948,8,567,1,567,1,567,1,568,
  	1,568,3,568,7954,8,568,1,568,1,568,5,568,7958,8,568,10,568,12,568,7961,
  	9,568,1,568,1,568,3,568,7965,8,568,1,568,3,568,7968,8,568,1,568,1,568,
  	5,568,7972,8,568,10,568,12,568,7975,9,568,1,568,1,568,3,568,7979,8,568,
  	1,568,3,568,7982,8,568,1,568,1,568,5,568,7986,8,568,10,568,12,568,7989,
  	9,568,1,568,3,568,7992,8,568,1,568,1,568,1,568,1,568,3,568,7998,8,568,
  	3,568,8000,8,568,1,568,3,568,8003,8,568,1,568,1,568,5,568,8007,8,568,
  	10,568,12,568,8010,9,568,1,568,1,568,1,568,3,568,8015,8,568,1,568,1,568,
  	1,568,1,568,1,568,3,568,8022,8,568,3,568,8024,8,568,3,568,8026,8,568,
  	1,569,1,569,3,569,8030,8,569,1,570,1,570,5,570,8034,8,570,10,570,12,570,
  	8037,9,570,1,570,1,570,3,570,8041,8,570,1,570,1,570,3,570,8045,8,570,
  	1,570,1,570,1,570,3,570,8050,8,570,1,570,1,570,5,570,8054,8,570,10,570,
  	12,570,8057,9,570,1,570,1,570,5,570,8061,8,570,10,570,12,570,8064,9,570,
  	3,570,8066,8,570,3,570,8068,8,570,1,571,3,571,8071,8,571,1,571,1,571,
  	1,571,1,571,1,571,1,571,1,571,1,571,3,571,8081,8,571,1,571,1,571,1,571,
  	1,571,3,571,8087,8,571,1,571,1,571,1,571,1,571,1,571,3,571,8094,8,571,
  	1,571,1,571,1,571,3,571,8099,8,571,1,571,1,571,1,571,1,571,1,571,1,571,
  	1,571,1,571,1,571,1,571,1,571,1,571,3,571,8113,8,571,1,571,1,571,1,571,
  	1,571,1,571,1,571,3,571,8121,8,571,1,571,1,571,1,571,1,571,3,571,8127,
  	8,571,1,571,1,571,1,571,3,571,8132,8,571,1,572,1,572,1,573,1,573,1,574,
  	1,574,1,574,1,575,1,575,3,575,8143,8,575,1,576,1,576,3,576,8147,8,576,
  	1,576,1,576,1,576,3,576,8152,8,576,1,576,1,576,3,576,8156,8,576,1,576,
  	3,576,8159,8,576,1,577,1,577,1,577,3,577,8164,8,577,1,577,1,577,3,577,
  	8168,8,577,1,577,1,577,1,577,1,577,1,577,1,577,3,577,8176,8,577,1,577,
  	1,577,1,577,1,577,1,577,1,577,3,577,8184,8,577,3,577,8186,8,577,1,578,
  	1,578,1,578,1,578,1,578,1,578,1,578,3,578,8195,8,578,1,579,1,579,1,579,
  	1,579,5,579,8201,8,579,10,579,12,579,8204,9,579,1,579,1,579,1,580,1,580,
  	3,580,8210,8,580,1,580,3,580,8213,8,580,1,581,1,581,1,581,1,581,5,581,
  	8219,8,581,10,581,12,581,8222,9,581,1,581,1,581,1,582,1,582,1,582,1,582,
  	3,582,8230,8,582,3,582,8232,8,582,1,583,1,583,1,584,1,584,3,584,8238,
  	8,584,1,585,1,585,3,585,8242,8,585,1,585,1,585,1,585,1,585,1,585,1,585,
  	1,585,1,585,3,585,8252,8,585,1,585,1,585,1,585,1,585,3,585,8258,8,585,
  	1,585,3,585,8261,8,585,1,586,1,586,1,587,1,587,1,587,1,588,1,588,1,588,
  	1,588,3,588,8272,8,588,1,589,1,589,1,590,1,590,1,590,1,591,1,591,3,591,
  	8281,8,591,1,591,3,591,8284,8,591,1,591,1,591,1,591,3,591,8289,8,591,
  	3,591,8291,8,591,1,591,3,591,8294,8,591,1,591,3,591,8297,8,591,1,591,
  	1,591,3,591,8301,8,591,1,591,3,591,8304,8,591,1,591,1,591,3,591,8308,
  	8,591,1,591,1,591,1,591,3,591,8313,8,591,1,591,3,591,8316,8,591,1,591,
  	1,591,3,591,8320,8,591,1,591,3,591,8323,8,591,1,591,1,591,3,591,8327,
  	8,591,1,591,1,591,1,591,3,591,8332,8,591,1,591,1,591,3,591,8336,8,591,
  	1,591,1,591,1,591,1,591,1,591,1,591,1,591,1,591,1,591,1,591,3,591,8348,
  	8,591,1,591,1,591,3,591,8352,8,591,1,591,1,591,1,591,1,591,3,591,8358,
  	8,591,1,591,1,591,3,591,8362,8,591,1,591,3,591,8365,8,591,1,591,1,591,
  	1,591,3,591,8370,8,591,1,591,1,591,3,591,8374,8,591,1,591,1,591,3,591,
  	8378,8,591,1,591,1,591,1,591,3,591,8383,8,591,1,591,1,591,1,591,1,591,
  	1,591,1,591,1,591,3,591,8392,8,591,1,591,3,591,8395,8,591,1,591,1,591,
  	3,591,8399,8,591,1,591,1,591,3,591,8403,8,591,1,591,3,591,8406,8,591,
  	1,591,1,591,3,591,8410,8,591,1,591,1,591,3,591,8414,8,591,1,591,1,591,
  	1,591,3,591,8419,8,591,1,591,1,591,1,591,3,591,8424,8,591,1,591,1,591,
  	1,591,1,591,3,591,8430,8,591,1,592,1,592,1,592,3,592,8435,8,592,1,593,
  	1,593,1,593,3,593,8440,8,593,3,593,8442,8,593,1,594,1,594,1,594,3,594,
  	8447,8,594,1,594,1,594,1,595,4,595,8452,8,595,11,595,12,595,8453,1,596,
  	1,596,1,596,1,596,1,596,1,596,3,596,8462,8,596,1,596,1,596,1,596,1,596,
  	3,596,8468,8,596,3,596,8470,8,596,1,597,1,597,3,597,8474,8,597,1,597,
  	1,597,3,597,8478,8,597,1,598,1,598,3,598,8482,8,598,1,598,1,598,3,598,
  	8486,8,598,1,599,1,599,1,599,1,599,1,600,1,600,1,600,1,600,1,601,1,601,
  	1,601,1,601,1,601,3,601,8501,8,601,1,602,1,602,1,602,1,602,3,602,8507,
  	8,602,1,603,1,603,1,603,1,603,1,603,3,603,8514,8,603,1,604,1,604,3,604,
  	8518,8,604,1,604,5,604,8521,8,604,10,604,12,604,8524,9,604,1,605,1,605,
  	3,605,8528,8,605,1,605,3,605,8531,8,605,1,606,1,606,3,606,8535,8,606,
  	1,606,3,606,8538,8,606,1,607,4,607,8541,8,607,11,607,12,607,8542,1,608,
  	1,608,3,608,8547,8,608,1,608,1,608,1,608,1,608,3,608,8553,8,608,1,608,
  	1,608,3,608,8557,8,608,1,608,1,608,3,608,8561,8,608,1,608,1,608,1,608,
  	3,608,8566,8,608,1,608,1,608,1,608,3,608,8571,8,608,1,608,1,608,1,608,
  	3,608,8576,8,608,1,608,1,608,1,608,3,608,8581,8,608,1,608,1,608,1,608,
  	1,608,3,608,8587,8,608,1,608,1,608,1,608,1,608,3,608,8593,8,608,1,608,
  	1,608,1,608,3,608,8598,8,608,1,608,1,608,1,608,3,608,8603,8,608,1,608,
  	1,608,1,608,3,608,8608,8,608,1,608,1,608,1,608,3,608,8613,8,608,1,608,
  	1,608,1,608,3,608,8618,8,608,1,608,1,608,1,608,3,608,8623,8,608,1,608,
  	1,608,1,608,3,608,8628,8,608,1,608,1,608,1,608,1,608,1,608,1,608,1,608,
  	1,608,3,608,8638,8,608,1,608,1,608,1,608,1,608,3,608,8644,8,608,1,608,
  	1,608,1,608,1,608,3,608,8650,8,608,1,608,1,608,1,608,1,608,3,608,8656,
  	8,608,1,608,3,608,8659,8,608,1,608,1,608,1,608,1,608,1,608,3,608,8666,
  	8,608,1,608,1,608,1,608,3,608,8671,8,608,1,608,1,608,1,608,1,608,1,608,
  	1,608,1,608,3,608,8680,8,608,1,608,1,608,1,608,1,608,3,608,8686,8,608,
  	1,608,1,608,1,608,3,608,8691,8,608,1,609,1,609,3,609,8695,8,609,1,610,
  	3,610,8698,8,610,1,610,1,610,3,610,8702,8,610,1,610,1,610,1,611,3,611,
  	8707,8,611,1,611,1,611,3,611,8711,8,611,1,611,1,611,1,612,3,612,8716,
  	8,612,1,612,1,612,3,612,8720,8,612,1,612,1,612,1,613,1,613,1,613,1,613,
  	1,613,3,613,8729,8,613,1,613,3,613,8732,8,613,1,613,3,613,8735,8,613,
  	1,614,3,614,8738,8,614,1,614,1,614,3,614,8742,8,614,1,614,1,614,3,614,
  	8746,8,614,1,614,1,614,3,614,8750,8,614,1,614,1,614,1,614,1,614,1,614,
  	1,614,1,614,1,614,1,614,1,614,1,614,1,614,1,614,3,614,8765,8,614,1,614,
  	3,614,8768,8,614,3,614,8770,8,614,1,615,1,615,1,615,3,615,8775,8,615,
  	1,615,1,615,1,615,1,615,1,615,1,615,1,615,3,615,8784,8,615,1,615,3,615,
  	8787,8,615,1,615,1,615,3,615,8791,8,615,1,616,1,616,1,616,1,616,1,617,
  	1,617,1,617,1,617,5,617,8801,8,617,10,617,12,617,8804,9,617,1,617,1,617,
  	1,618,1,618,1,618,1,618,1,618,1,618,1,618,3,618,8815,8,618,1,618,1,618,
  	1,618,3,618,8820,8,618,1,618,5,618,8823,8,618,10,618,12,618,8826,9,618,
  	1,618,1,618,1,618,1,618,5,618,8832,8,618,10,618,12,618,8835,9,618,1,618,
  	1,618,3,618,8839,8,618,1,619,1,619,1,619,1,619,1,619,5,619,8846,8,619,
  	10,619,12,619,8849,9,619,1,619,1,619,3,619,8853,8,619,1,620,1,620,3,620,
  	8857,8,620,1,620,1,620,3,620,8861,8,620,1,620,1,620,3,620,8865,8,620,
  	1,620,1,620,1,620,3,620,8870,8,620,1,620,1,620,1,620,3,620,8875,8,620,
  	1,620,1,620,1,620,1,620,3,620,8881,8,620,1,620,1,620,1,620,3,620,8886,
  	8,620,1,620,3,620,8889,8,620,1,621,1,621,1,621,5,621,8894,8,621,10,621,
  	12,621,8897,9,621,1,622,1,622,1,622,1,622,5,622,8903,8,622,10,622,12,
  	622,8906,9,622,1,622,1,622,1,623,1,623,3,623,8912,8,623,1,624,1,624,1,
  	624,1,624,1,625,1,625,1,625,1,626,3,626,8922,8,626,1,626,1,626,1,627,
  	1,627,1,627,1,627,1,627,3,627,8931,8,627,3,627,8933,8,627,1,628,1,628,
  	1,628,1,628,1,629,1,629,1,629,1,629,1,630,3,630,8944,8,630,1,630,1,630,
  	1,631,1,631,1,631,1,632,1,632,1,632,1,633,1,633,3,633,8956,8,633,1,634,
  	1,634,1,634,1,634,1,634,1,634,1,635,1,635,1,635,5,635,8967,8,635,10,635,
  	12,635,8970,9,635,1,636,1,636,1,636,5,636,8975,8,636,10,636,12,636,8978,
  	9,636,1,637,1,637,1,637,1,637,3,637,8984,8,637,1,638,1,638,1,638,1,639,
  	1,639,4,639,8991,8,639,11,639,12,639,8992,1,640,1,640,1,640,1,640,3,640,
  	8999,8,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,
  	1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,1,640,3,640,
  	9022,8,640,3,640,9024,8,640,1,641,1,641,4,641,9028,8,641,11,641,12,641,
  	9029,1,642,1,642,1,642,1,642,1,643,1,643,1,643,5,643,9039,8,643,10,643,
  	12,643,9042,9,643,1,644,1,644,1,644,5,644,9047,8,644,10,644,12,644,9050,
  	9,644,1,645,1,645,1,645,1,645,3,645,9056,8,645,1,645,1,645,1,645,3,645,
  	9061,8,645,1,645,1,645,3,645,9065,8,645,1,646,1,646,1,646,1,646,3,646,
  	9071,8,646,1,647,1,647,1,647,1,647,1,647,1,647,1,647,1,647,1,647,3,647,
  	9082,8,647,1,648,1,648,1,648,1,648,3,648,9088,8,648,1,648,1,648,1,649,
  	1,649,1,649,1,649,1,649,1,650,1,650,1,650,1,650,1,651,1,651,1,651,1,651,
  	1,651,1,651,1,652,1,652,1,652,1,652,1,652,1,652,1,653,1,653,1,653,1,653,
  	1,653,1,653,1,653,1,654,1,654,1,654,1,654,1,654,3,654,9125,8,654,1,655,
  	1,655,1,655,1,655,1,656,1,656,1,656,1,656,1,657,1,657,1,657,1,657,1,657,
  	1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,1,657,3,657,9150,
  	8,657,1,658,1,658,1,658,1,659,1,659,1,659,1,660,1,660,1,660,1,660,3,660,
  	9162,8,660,3,660,9164,8,660,1,661,1,661,1,661,3,661,9169,8,661,3,661,
  	9171,8,661,1,662,1,662,1,662,1,663,1,663,3,663,9178,8,663,1,664,1,664,
  	1,665,1,665,1,666,1,666,1,666,1,667,1,667,1,667,3,667,9190,8,667,3,667,
  	9192,8,667,1,668,1,668,1,668,1,668,3,668,9198,8,668,1,669,1,669,1,670,
  	1,670,1,670,1,670,5,670,9206,8,670,10,670,12,670,9209,9,670,1,670,1,670,
  	1,671,1,671,1,672,1,672,3,672,9217,8,672,1,673,1,673,1,674,1,674,1,675,
  	1,675,1,675,1,675,1,675,3,675,9228,8,675,1,675,1,675,1,676,1,676,1,677,
  	1,677,1,678,1,678,1,679,1,679,1,680,1,680,1,681,1,681,1,682,1,682,1,683,
  	1,683,1,684,1,684,3,684,9250,8,684,1,685,1,685,3,685,9254,8,685,1,686,
  	1,686,1,687,1,687,1,688,1,688,1,689,1,689,1,690,1,690,1,691,1,691,1,692,
  	1,692,1,693,1,693,1,694,1,694,1,695,1,695,1,696,1,696,3,696,9278,8,696,
  	1,697,1,697,1,697,1,698,1,698,1,698,1,698,1,698,1,698,3,698,9289,8,698,
  	3,698,9291,8,698,1,699,1,699,3,699,9295,8,699,1,700,1,700,1,700,5,700,
  	9300,8,700,10,700,12,700,9303,9,700,1,701,1,701,1,701,5,701,9308,8,701,
  	10,701,12,701,9311,9,701,1,702,1,702,1,703,1,703,3,703,9317,8,703,1,704,
  	1,704,1,705,1,705,3,705,9323,8,705,1,706,1,706,1,707,1,707,1,708,1,708,
  	1,709,1,709,1,710,1,710,1,711,1,711,1,712,1,712,1,712,3,712,9340,8,712,
  	1,713,1,713,3,713,9344,8,713,1,714,1,714,1,714,5,714,9349,8,714,10,714,
  	12,714,9352,9,714,1,715,1,715,1,715,1,715,1,716,1,716,3,716,9360,8,716,
  	1,717,1,717,1,717,3,717,9365,8,717,3,717,9367,8,717,1,717,1,717,1,717,
  	1,717,3,717,9373,8,717,1,718,1,718,1,718,1,719,1,719,1,720,1,720,1,721,
  	1,721,1,722,1,722,1,722,1,722,1,722,3,722,9389,8,722,1,723,1,723,1,723,
  	1,723,1,723,3,723,9396,8,723,1,724,1,724,1,724,3,724,9401,8,724,1,725,
  	1,725,1,725,1,725,1,725,1,725,3,725,9409,8,725,1,725,3,725,9412,8,725,
  	1,726,1,726,1,726,3,726,9417,8,726,1,727,1,727,1,728,1,728,1,728,1,728,
  	5,728,9425,8,728,10,728,12,728,9428,9,728,1,728,1,728,1,729,1,729,1,729,
  	3,729,9435,8,729,1,730,1,730,1,730,3,730,9440,8,730,1,731,1,731,1,731,
  	3,731,9445,8,731,1,732,3,732,9448,8,732,1,732,1,732,3,732,9452,8,732,
  	1,732,5,732,9455,8,732,10,732,12,732,9458,9,732,1,733,1,733,1,734,1,734,
  	1,734,5,734,9465,8,734,10,734,12,734,9468,9,734,1,735,1,735,1,735,3,735,
  	9473,8,735,1,736,1,736,1,737,1,737,1,738,1,738,1,739,1,739,1,739,1,739,
  	1,739,1,739,3,739,9487,8,739,1,740,1,740,3,740,9491,8,740,1,741,1,741,
  	1,742,1,742,1,742,1,742,1,742,1,742,1,743,1,743,3,743,9503,8,743,1,744,
  	1,744,3,744,9507,8,744,1,745,1,745,3,745,9511,8,745,1,746,1,746,3,746,
  	9515,8,746,1,747,1,747,1,747,1,748,1,748,1,749,1,749,1,749,1,749,1,749,
  	1,749,1,749,3,749,9529,8,749,1,750,1,750,1,750,1,750,1,750,1,750,3,750,
  	9537,8,750,1,751,1,751,1,751,1,751,1,751,1,751,1,751,3,751,9546,8,751,
  	1,751,1,751,1,752,1,752,1,753,1,753,1,753,1,753,1,753,1,753,1,753,1,753,
  	3,753,9560,8,753,1,753,1,753,1,753,1,753,1,753,3,753,9567,8,753,3,753,
  	9569,8,753,1,754,1,754,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,
  	1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,
  	1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,1,755,
  	1,755,1,755,1,755,1,755,1,755,3,755,9610,8,755,1,756,1,756,1,756,1,756,
  	1,756,1,756,1,756,1,756,1,756,1,756,1,756,3,756,9623,8,756,1,756,1,756,
  	1,756,3,756,9628,8,756,3,756,9630,8,756,1,757,1,757,1,758,1,758,1,758,
  	1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,1,758,3,758,9647,
  	8,758,1,759,1,759,1,759,3,759,9652,8,759,1,759,1,759,1,759,3,759,9657,
  	8,759,3,759,9659,8,759,1,760,1,760,1,760,1,760,3,760,9665,8,760,1,761,
  	1,761,1,762,1,762,1,762,1,762,1,762,3,762,9674,8,762,1,763,1,763,1,763,
  	1,763,1,763,1,763,1,763,1,763,1,763,1,763,1,763,3,763,9687,8,763,1,763,
  	0,4,924,926,934,936,764,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,
  	34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,78,
  	80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,116,118,
  	120,122,124,126,128,130,132,134,136,138,140,142,144,146,148,150,152,154,
  	156,158,160,162,164,166,168,170,172,174,176,178,180,182,184,186,188,190,
  	192,194,196,198,200,202,204,206,208,210,212,214,216,218,220,222,224,226,
  	228,230,232,234,236,238,240,242,244,246,248,250,252,254,256,258,260,262,
  	264,266,268,270,272,274,276,278,280,282,284,286,288,290,292,294,296,298,
  	300,302,304,306,308,310,312,314,316,318,320,322,324,326,328,330,332,334,
  	336,338,340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,
  	372,374,376,378,380,382,384,386,388,390,392,394,396,398,400,402,404,406,
  	408,410,412,414,416,418,420,422,424,426,428,430,432,434,436,438,440,442,
  	444,446,448,450,452,454,456,458,460,462,464,466,468,470,472,474,476,478,
  	480,482,484,486,488,490,492,494,496,498,500,502,504,506,508,510,512,514,
  	516,518,520,522,524,526,528,530,532,534,536,538,540,542,544,546,548,550,
  	552,554,556,558,560,562,564,566,568,570,572,574,576,578,580,582,584,586,
  	588,590,592,594,596,598,600,602,604,606,608,610,612,614,616,618,620,622,
  	624,626,628,630,632,634,636,638,640,642,644,646,648,650,652,654,656,658,
  	660,662,664,666,668,670,672,674,676,678,680,682,684,686,688,690,692,694,
  	696,698,700,702,704,706,708,710,712,714,716,718,720,722,724,726,728,730,
  	732,734,736,738,740,742,744,746,748,750,752,754,756,758,760,762,764,766,
  	768,770,772,774,776,778,780,782,784,786,788,790,792,794,796,798,800,802,
  	804,806,808,810,812,814,816,818,820,822,824,826,828,830,832,834,836,838,
  	840,842,844,846,848,850,852,854,856,858,860,862,864,866,868,870,872,874,
  	876,878,880,882,884,886,888,890,892,894,896,898,900,902,904,906,908,910,
  	912,914,916,918,920,922,924,926,928,930,932,934,936,938,940,942,944,946,
  	948,950,952,954,956,958,960,962,964,966,968,970,972,974,976,978,980,982,
  	984,986,988,990,992,994,996,998,1000,1002,1004,1006,1008,1010,1012,1014,
  	1016,1018,1020,1022,1024,1026,1028,1030,1032,1034,1036,1038,1040,1042,
  	1044,1046,1048,1050,1052,1054,1056,1058,1060,1062,1064,1066,1068,1070,
  	1072,1074,1076,1078,1080,1082,1084,1086,1088,1090,1092,1094,1096,1098,
  	1100,1102,1104,1106,1108,1110,1112,1114,1116,1118,1120,1122,1124,1126,
  	1128,1130,1132,1134,1136,1138,1140,1142,1144,1146,1148,1150,1152,1154,
  	1156,1158,1160,1162,1164,1166,1168,1170,1172,1174,1176,1178,1180,1182,
  	1184,1186,1188,1190,1192,1194,1196,1198,1200,1202,1204,1206,1208,1210,
  	1212,1214,1216,1218,1220,1222,1224,1226,1228,1230,1232,1234,1236,1238,
  	1240,1242,1244,1246,1248,1250,1252,1254,1256,1258,1260,1262,1264,1266,
  	1268,1270,1272,1274,1276,1278,1280,1282,1284,1286,1288,1290,1292,1294,
  	1296,1298,1300,1302,1304,1306,1308,1310,1312,1314,1316,1318,1320,1322,
  	1324,1326,1328,1330,1332,1334,1336,1338,1340,1342,1344,1346,1348,1350,
  	1352,1354,1356,1358,1360,1362,1364,1366,1368,1370,1372,1374,1376,1378,
  	1380,1382,1384,1386,1388,1390,1392,1394,1396,1398,1400,1402,1404,1406,
  	1408,1410,1412,1414,1416,1418,1420,1422,1424,1426,1428,1430,1432,1434,
  	1436,1438,1440,1442,1444,1446,1448,1450,1452,1454,1456,1458,1460,1462,
  	1464,1466,1468,1470,1472,1474,1476,1478,1480,1482,1484,1486,1488,1490,
  	1492,1494,1496,1498,1500,1502,1504,1506,1508,1510,1512,1514,1516,1518,
  	1520,1522,1524,1526,0,174,2,0,63,63,616,616,2,0,94,94,501,501,1,0,670,
  	671,2,0,50,50,187,187,1,0,749,750,2,0,95,95,316,316,2,0,180,180,195,195,
  	2,0,268,268,488,488,4,0,166,166,284,284,467,467,582,582,2,0,170,170,285,
  	285,2,0,471,471,630,630,2,0,404,404,663,663,3,0,367,367,604,604,628,628,
  	2,0,52,52,73,73,3,0,173,173,278,278,640,640,2,0,233,233,445,445,2,0,597,
  	597,600,600,3,0,268,268,327,327,461,461,2,0,229,229,397,397,4,0,229,229,
  	302,302,397,397,449,449,2,0,6,6,9,12,3,0,171,171,259,259,327,327,1,0,
  	652,653,2,0,154,154,678,678,2,0,126,126,327,327,2,0,822,822,828,828,2,
  	0,312,312,513,513,2,0,171,171,327,327,2,0,688,688,820,820,7,0,56,56,183,
  	183,259,259,557,558,560,560,562,562,581,581,2,0,29,29,411,411,2,0,3,5,
  	42,42,3,0,462,462,513,513,708,708,2,0,142,142,510,510,2,0,64,64,174,174,
  	2,0,306,306,508,508,2,0,141,141,275,275,2,0,56,56,183,183,2,0,234,234,
  	268,268,2,0,272,272,299,299,2,0,416,416,674,674,2,0,74,74,569,569,2,0,
  	295,295,502,502,2,0,328,328,783,783,2,0,332,332,789,789,2,0,329,329,784,
  	784,2,0,350,350,807,807,2,0,335,335,792,792,2,0,336,336,793,793,2,0,330,
  	330,786,786,2,0,337,337,795,795,2,0,331,331,787,787,2,0,346,346,796,796,
  	2,0,340,340,797,797,2,0,339,339,798,798,2,0,342,342,800,800,2,0,343,343,
  	801,801,2,0,344,344,802,802,2,0,345,345,803,803,2,0,347,347,804,804,2,
  	0,349,349,806,806,2,0,763,763,805,805,2,0,341,341,799,799,2,0,737,737,
  	794,794,2,0,738,738,782,782,2,0,351,351,788,788,2,0,760,760,785,785,2,
  	0,761,761,808,808,3,0,413,413,768,769,823,823,2,0,333,333,790,790,2,0,
  	334,334,791,791,2,0,554,554,556,556,2,0,479,479,564,564,2,0,164,164,187,
  	187,3,0,399,399,565,565,675,675,2,0,319,319,637,637,2,0,168,168,744,744,
  	4,0,242,242,452,452,600,600,837,837,4,0,278,278,473,473,524,524,640,640,
  	13,0,173,173,187,187,209,209,212,212,226,226,272,272,453,453,457,457,
  	481,481,537,537,591,591,620,620,642,642,4,0,512,512,598,598,644,644,661,
  	661,2,0,140,140,187,187,2,0,168,168,399,399,2,0,219,219,461,461,1,0,830,
  	831,5,0,101,101,219,219,223,223,365,365,461,461,3,0,219,219,461,461,645,
  	645,2,0,250,250,683,683,2,0,120,120,627,627,2,0,239,239,286,286,2,0,271,
  	272,297,297,6,0,56,56,139,139,290,290,366,366,548,548,593,593,2,0,128,
  	128,460,460,4,0,176,176,451,451,573,573,643,643,5,0,77,77,202,202,204,
  	204,244,244,542,542,2,0,644,644,735,735,2,0,174,175,217,217,3,0,222,222,
  	622,622,636,636,2,0,23,23,61,61,2,0,26,26,424,424,2,0,56,56,62,62,2,0,
  	6,6,8,13,3,0,16,18,184,184,380,380,1,0,14,15,1,0,21,22,2,0,14,15,20,20,
  	2,0,80,81,83,83,2,0,358,358,376,376,5,0,574,574,577,577,590,590,657,657,
  	660,660,4,0,703,704,717,717,719,719,721,721,2,0,709,709,711,711,2,0,706,
  	706,710,710,2,0,229,229,302,302,2,0,735,735,832,832,2,0,268,268,720,720,
  	2,0,51,51,584,584,1,0,156,157,1,0,610,611,4,0,155,155,158,158,609,609,
  	612,612,4,0,247,247,313,313,382,384,441,442,2,0,1,1,401,401,2,0,1,1,19,
  	19,5,0,159,162,262,264,372,373,521,521,680,680,9,0,163,163,265,265,369,
  	369,374,374,381,381,459,459,522,522,665,665,681,681,3,0,136,136,214,214,
  	631,631,2,0,144,144,566,566,2,0,407,407,514,514,10,0,98,98,108,108,117,
  	117,131,133,149,149,368,368,386,386,520,520,583,583,602,602,2,0,580,580,
  	662,662,3,0,168,168,191,191,230,230,3,0,168,168,182,182,366,366,3,0,240,
  	240,432,432,540,540,3,0,89,89,256,256,517,517,1,0,686,687,2,0,625,625,
  	647,647,5,0,76,76,284,284,363,363,543,543,614,614,3,0,166,166,230,231,
  	408,408,1,0,86,87,2,0,322,322,362,362,4,0,247,248,313,313,382,384,441,
  	442,3,0,539,539,638,638,682,682,1,0,570,572,2,0,105,105,601,601,6,0,122,
  	122,124,124,168,168,191,191,230,230,472,472,3,0,229,229,302,302,403,403,
  	2,0,182,182,366,366,2,0,314,314,462,462,2,0,355,355,375,375,2,0,154,154,
  	272,272,3,0,276,276,286,286,427,427,2,0,567,567,605,605,2,0,410,410,415,
  	415,2,0,316,316,405,405,2,0,842,842,844,844,3,0,3,5,43,43,45,46,2,0,3,
  	5,43,43,2,0,3,5,45,46,1,0,43,44,2,0,222,222,622,622,2,0,41,41,406,406,
  	1,0,3,5,1,0,6,7,3,0,212,212,537,537,739,739,9,0,209,209,226,226,399,399,
  	453,453,457,457,481,481,489,489,591,591,734,734,160,0,48,49,51,55,58,
  	58,62,62,67,72,78,78,82,82,85,87,89,89,95,95,98,99,101,102,107,112,114,
  	115,117,118,120,120,122,126,128,129,131,133,135,135,139,139,144,144,149,
  	149,153,155,158,158,163,163,169,170,172,172,178,182,189,191,195,195,197,
  	197,199,199,201,205,207,208,210,211,215,216,218,220,223,224,227,230,237,
  	238,240,240,244,244,246,249,252,252,256,256,260,261,265,266,269,269,271,
  	271,274,274,279,280,285,285,289,290,292,293,296,296,298,298,302,302,304,
  	304,307,308,313,314,318,318,320,321,328,328,330,346,348,351,353,356,359,
  	360,365,369,371,371,374,375,377,377,379,379,381,389,392,393,395,398,404,
  	404,407,407,409,409,411,411,414,414,416,417,420,420,428,434,436,443,448,
  	449,451,451,454,456,459,461,464,464,468,469,471,472,475,479,482,482,484,
  	484,486,486,490,496,500,500,502,504,506,506,510,512,514,515,517,517,519,
  	520,522,523,527,528,530,530,535,535,540,540,542,542,544,548,554,556,558,
  	558,561,561,564,564,566,566,568,568,570,573,579,579,582,587,592,594,597,
  	598,601,604,606,607,609,612,618,619,624,625,627,630,636,636,639,639,641,
  	641,643,645,651,651,653,653,656,656,661,661,663,666,671,673,675,675,677,
  	678,681,681,684,687,689,689,694,696,699,700,705,705,707,707,714,715,718,
  	718,720,720,722,723,727,733,736,738,740,750,752,755,757,757,760,763,770,
  	773,775,777,779,819,4,0,609,609,612,612,756,756,758,769,2,0,821,821,823,
  	823,2,0,825,826,828,828,2,0,830,830,832,832,5,0,250,250,316,316,529,529,
  	683,683,698,698,54,0,48,48,58,58,65,65,72,72,74,74,91,92,103,103,105,
  	105,110,110,119,119,121,121,134,134,164,164,186,186,198,198,232,233,237,
  	237,246,246,255,255,258,258,260,260,281,281,301,301,403,403,417,417,420,
  	420,428,428,431,431,435,435,443,443,445,445,447,447,482,482,485,485,498,
  	498,500,500,509,509,518,518,523,523,530,530,539,539,541,541,545,546,569,
  	569,578,578,623,623,632,633,641,641,673,673,676,676,684,684,686,687,702,
  	702,745,748,154,0,49,49,51,55,59,59,62,62,67,71,78,78,82,82,85,87,89,
  	89,95,95,98,99,101,102,107,109,111,112,114,115,117,118,120,120,122,126,
  	128,129,131,133,135,135,139,139,144,144,149,149,153,155,158,158,163,163,
  	169,170,172,172,176,176,178,182,189,191,195,195,197,197,199,199,201,205,
  	207,208,210,210,215,215,218,220,223,224,227,230,238,238,240,240,244,244,
  	247,250,252,252,256,256,261,261,265,266,269,269,271,271,274,274,279,280,
  	285,285,289,290,292,293,296,296,298,298,302,302,304,304,307,308,313,314,
  	316,316,318,318,320,321,328,328,330,337,339,346,348,351,353,357,359,360,
  	365,369,371,371,374,375,377,377,379,379,381,389,392,393,395,398,404,404,
  	407,407,409,409,411,412,414,414,429,430,432,434,436,442,448,449,451,451,
  	454,456,459,461,464,464,468,472,475,479,484,484,486,486,490,496,502,504,
  	506,506,510,512,514,515,517,517,519,520,522,522,527,529,535,535,540,540,
  	542,542,544,544,547,548,554,556,558,559,561,561,564,564,566,566,568,568,
  	570,573,579,579,582,587,591,594,597,598,601,604,606,607,609,612,618,619,
  	624,630,636,636,639,639,643,645,653,653,656,656,661,661,663,666,672,672,
  	675,675,677,678,681,681,689,689,694,696,699,701,705,705,707,707,714,715,
  	718,718,720,720,722,723,727,733,736,737,741,742,744,744,749,750,752,753,
  	774,774,5,0,142,142,242,242,270,270,513,513,516,516,6,0,211,211,216,216,
  	416,416,591,591,651,651,671,671,10851,0,1535,1,0,0,0,2,1623,1,0,0,0,4,
  	1625,1,0,0,0,6,1648,1,0,0,0,8,1669,1,0,0,0,10,1672,1,0,0,0,12,1710,1,
  	0,0,0,14,1719,1,0,0,0,16,1732,1,0,0,0,18,1734,1,0,0,0,20,1739,1,0,0,0,
  	22,1759,1,0,0,0,24,1768,1,0,0,0,26,1770,1,0,0,0,28,1796,1,0,0,0,30,1894,
  	1,0,0,0,32,1898,1,0,0,0,34,1914,1,0,0,0,36,2056,1,0,0,0,38,2061,1,0,0,
  	0,40,2063,1,0,0,0,42,2065,1,0,0,0,44,2079,1,0,0,0,46,2087,1,0,0,0,48,
  	2103,1,0,0,0,50,2105,1,0,0,0,52,2109,1,0,0,0,54,2114,1,0,0,0,56,2116,
  	1,0,0,0,58,2131,1,0,0,0,60,2139,1,0,0,0,62,2149,1,0,0,0,64,2151,1,0,0,
  	0,66,2173,1,0,0,0,68,2182,1,0,0,0,70,2185,1,0,0,0,72,2198,1,0,0,0,74,
  	2203,1,0,0,0,76,2207,1,0,0,0,78,2247,1,0,0,0,80,2249,1,0,0,0,82,2272,
  	1,0,0,0,84,2287,1,0,0,0,86,2290,1,0,0,0,88,2315,1,0,0,0,90,2325,1,0,0,
  	0,92,2328,1,0,0,0,94,2333,1,0,0,0,96,2342,1,0,0,0,98,2344,1,0,0,0,100,
  	2348,1,0,0,0,102,2360,1,0,0,0,104,2390,1,0,0,0,106,2396,1,0,0,0,108,2399,
  	1,0,0,0,110,2430,1,0,0,0,112,2454,1,0,0,0,114,2456,1,0,0,0,116,2464,1,
  	0,0,0,118,2472,1,0,0,0,120,2497,1,0,0,0,122,2500,1,0,0,0,124,2552,1,0,
  	0,0,126,2554,1,0,0,0,128,2558,1,0,0,0,130,2567,1,0,0,0,132,2583,1,0,0,
  	0,134,2585,1,0,0,0,136,2593,1,0,0,0,138,2619,1,0,0,0,140,2621,1,0,0,0,
  	142,2633,1,0,0,0,144,2641,1,0,0,0,146,2658,1,0,0,0,148,2660,1,0,0,0,150,
  	2663,1,0,0,0,152,2685,1,0,0,0,154,2687,1,0,0,0,156,2693,1,0,0,0,158,2699,
  	1,0,0,0,160,2705,1,0,0,0,162,2711,1,0,0,0,164,2717,1,0,0,0,166,2724,1,
  	0,0,0,168,2732,1,0,0,0,170,2734,1,0,0,0,172,2740,1,0,0,0,174,2746,1,0,
  	0,0,176,2752,1,0,0,0,178,2759,1,0,0,0,180,2781,1,0,0,0,182,2783,1,0,0,
  	0,184,2787,1,0,0,0,186,2792,1,0,0,0,188,2812,1,0,0,0,190,2816,1,0,0,0,
  	192,2849,1,0,0,0,194,2880,1,0,0,0,196,2897,1,0,0,0,198,2899,1,0,0,0,200,
  	2921,1,0,0,0,202,2927,1,0,0,0,204,2933,1,0,0,0,206,2939,1,0,0,0,208,2946,
  	1,0,0,0,210,2955,1,0,0,0,212,2972,1,0,0,0,214,2974,1,0,0,0,216,2981,1,
  	0,0,0,218,2991,1,0,0,0,220,3005,1,0,0,0,222,3011,1,0,0,0,224,3019,1,0,
  	0,0,226,3025,1,0,0,0,228,3033,1,0,0,0,230,3039,1,0,0,0,232,3046,1,0,0,
  	0,234,3056,1,0,0,0,236,3060,1,0,0,0,238,3066,1,0,0,0,240,3071,1,0,0,0,
  	242,3082,1,0,0,0,244,3125,1,0,0,0,246,3130,1,0,0,0,248,3132,1,0,0,0,250,
  	3139,1,0,0,0,252,3169,1,0,0,0,254,3171,1,0,0,0,256,3200,1,0,0,0,258,3207,
  	1,0,0,0,260,3211,1,0,0,0,262,3219,1,0,0,0,264,3232,1,0,0,0,266,3234,1,
  	0,0,0,268,3252,1,0,0,0,270,3264,1,0,0,0,272,3270,1,0,0,0,274,3276,1,0,
  	0,0,276,3332,1,0,0,0,278,3334,1,0,0,0,280,3336,1,0,0,0,282,3342,1,0,0,
  	0,284,3344,1,0,0,0,286,3353,1,0,0,0,288,3359,1,0,0,0,290,3367,1,0,0,0,
  	292,3376,1,0,0,0,294,3384,1,0,0,0,296,3396,1,0,0,0,298,3401,1,0,0,0,300,
  	3406,1,0,0,0,302,3411,1,0,0,0,304,3416,1,0,0,0,306,3438,1,0,0,0,308,3457,
  	1,0,0,0,310,3461,1,0,0,0,312,3476,1,0,0,0,314,3492,1,0,0,0,316,3504,1,
  	0,0,0,318,3506,1,0,0,0,320,3536,1,0,0,0,322,3538,1,0,0,0,324,3540,1,0,
  	0,0,326,3543,1,0,0,0,328,3546,1,0,0,0,330,3553,1,0,0,0,332,3555,1,0,0,
  	0,334,3558,1,0,0,0,336,3561,1,0,0,0,338,3574,1,0,0,0,340,3576,1,0,0,0,
  	342,3621,1,0,0,0,344,3633,1,0,0,0,346,3636,1,0,0,0,348,3640,1,0,0,0,350,
  	3649,1,0,0,0,352,3653,1,0,0,0,354,3658,1,0,0,0,356,3671,1,0,0,0,358,3676,
  	1,0,0,0,360,3680,1,0,0,0,362,3696,1,0,0,0,364,3698,1,0,0,0,366,3716,1,
  	0,0,0,368,3718,1,0,0,0,370,3727,1,0,0,0,372,3739,1,0,0,0,374,3760,1,0,
  	0,0,376,3767,1,0,0,0,378,3769,1,0,0,0,380,3773,1,0,0,0,382,3775,1,0,0,
  	0,384,3780,1,0,0,0,386,3788,1,0,0,0,388,3797,1,0,0,0,390,3800,1,0,0,0,
  	392,3815,1,0,0,0,394,3817,1,0,0,0,396,3838,1,0,0,0,398,3843,1,0,0,0,400,
  	3848,1,0,0,0,402,3852,1,0,0,0,404,3866,1,0,0,0,406,3869,1,0,0,0,408,3875,
  	1,0,0,0,410,3888,1,0,0,0,412,3896,1,0,0,0,414,3922,1,0,0,0,416,3935,1,
  	0,0,0,418,3942,1,0,0,0,420,3944,1,0,0,0,422,3956,1,0,0,0,424,3958,1,0,
  	0,0,426,3971,1,0,0,0,428,3995,1,0,0,0,430,3997,1,0,0,0,432,4004,1,0,0,
  	0,434,4014,1,0,0,0,436,4049,1,0,0,0,438,4056,1,0,0,0,440,4062,1,0,0,0,
  	442,4064,1,0,0,0,444,4068,1,0,0,0,446,4076,1,0,0,0,448,4078,1,0,0,0,450,
  	4083,1,0,0,0,452,4087,1,0,0,0,454,4114,1,0,0,0,456,4116,1,0,0,0,458,4118,
  	1,0,0,0,460,4126,1,0,0,0,462,4128,1,0,0,0,464,4136,1,0,0,0,466,4146,1,
  	0,0,0,468,4150,1,0,0,0,470,4175,1,0,0,0,472,4202,1,0,0,0,474,4204,1,0,
  	0,0,476,4213,1,0,0,0,478,4244,1,0,0,0,480,4268,1,0,0,0,482,4270,1,0,0,
  	0,484,4285,1,0,0,0,486,4287,1,0,0,0,488,4322,1,0,0,0,490,4324,1,0,0,0,
  	492,4356,1,0,0,0,494,4361,1,0,0,0,496,4384,1,0,0,0,498,4393,1,0,0,0,500,
  	4395,1,0,0,0,502,4404,1,0,0,0,504,4406,1,0,0,0,506,4413,1,0,0,0,508,4549,
  	1,0,0,0,510,4551,1,0,0,0,512,4553,1,0,0,0,514,4555,1,0,0,0,516,4557,1,
  	0,0,0,518,4559,1,0,0,0,520,4561,1,0,0,0,522,4563,1,0,0,0,524,4565,1,0,
  	0,0,526,4567,1,0,0,0,528,4569,1,0,0,0,530,4571,1,0,0,0,532,4573,1,0,0,
  	0,534,4575,1,0,0,0,536,4577,1,0,0,0,538,4579,1,0,0,0,540,4581,1,0,0,0,
  	542,4583,1,0,0,0,544,4585,1,0,0,0,546,4587,1,0,0,0,548,4589,1,0,0,0,550,
  	4591,1,0,0,0,552,4593,1,0,0,0,554,4595,1,0,0,0,556,4597,1,0,0,0,558,4599,
  	1,0,0,0,560,4603,1,0,0,0,562,4605,1,0,0,0,564,4610,1,0,0,0,566,4614,1,
  	0,0,0,568,4630,1,0,0,0,570,4632,1,0,0,0,572,4634,1,0,0,0,574,4636,1,0,
  	0,0,576,4649,1,0,0,0,578,4713,1,0,0,0,580,4715,1,0,0,0,582,4723,1,0,0,
  	0,584,4731,1,0,0,0,586,4739,1,0,0,0,588,4741,1,0,0,0,590,4749,1,0,0,0,
  	592,4773,1,0,0,0,594,4786,1,0,0,0,596,4795,1,0,0,0,598,4799,1,0,0,0,600,
  	4803,1,0,0,0,602,4807,1,0,0,0,604,4811,1,0,0,0,606,4819,1,0,0,0,608,4829,
  	1,0,0,0,610,4831,1,0,0,0,612,4842,1,0,0,0,614,4844,1,0,0,0,616,4848,1,
  	0,0,0,618,4852,1,0,0,0,620,4859,1,0,0,0,622,4872,1,0,0,0,624,4874,1,0,
  	0,0,626,4880,1,0,0,0,628,4888,1,0,0,0,630,4925,1,0,0,0,632,4927,1,0,0,
  	0,634,4941,1,0,0,0,636,4943,1,0,0,0,638,5000,1,0,0,0,640,5086,1,0,0,0,
  	642,5145,1,0,0,0,644,5147,1,0,0,0,646,5150,1,0,0,0,648,5178,1,0,0,0,650,
  	5184,1,0,0,0,652,5193,1,0,0,0,654,5195,1,0,0,0,656,5200,1,0,0,0,658,5255,
  	1,0,0,0,660,5257,1,0,0,0,662,5265,1,0,0,0,664,5314,1,0,0,0,666,5316,1,
  	0,0,0,668,5319,1,0,0,0,670,5322,1,0,0,0,672,5333,1,0,0,0,674,5338,1,0,
  	0,0,676,5341,1,0,0,0,678,5356,1,0,0,0,680,5404,1,0,0,0,682,5406,1,0,0,
  	0,684,5458,1,0,0,0,686,5476,1,0,0,0,688,5478,1,0,0,0,690,5494,1,0,0,0,
  	692,5509,1,0,0,0,694,5534,1,0,0,0,696,5536,1,0,0,0,698,5544,1,0,0,0,700,
  	5595,1,0,0,0,702,5597,1,0,0,0,704,5611,1,0,0,0,706,5613,1,0,0,0,708,5627,
  	1,0,0,0,710,5632,1,0,0,0,712,5634,1,0,0,0,714,5636,1,0,0,0,716,5650,1,
  	0,0,0,718,5663,1,0,0,0,720,5667,1,0,0,0,722,5669,1,0,0,0,724,5674,1,0,
  	0,0,726,5684,1,0,0,0,728,5743,1,0,0,0,730,5754,1,0,0,0,732,5756,1,0,0,
  	0,734,5759,1,0,0,0,736,5772,1,0,0,0,738,5805,1,0,0,0,740,5813,1,0,0,0,
  	742,5820,1,0,0,0,744,5822,1,0,0,0,746,5835,1,0,0,0,748,5837,1,0,0,0,750,
  	5842,1,0,0,0,752,5853,1,0,0,0,754,5864,1,0,0,0,756,5872,1,0,0,0,758,5881,
  	1,0,0,0,760,5890,1,0,0,0,762,5895,1,0,0,0,764,5898,1,0,0,0,766,5903,1,
  	0,0,0,768,5908,1,0,0,0,770,5913,1,0,0,0,772,5926,1,0,0,0,774,5934,1,0,
  	0,0,776,5939,1,0,0,0,778,5945,1,0,0,0,780,5962,1,0,0,0,782,5979,1,0,0,
  	0,784,5993,1,0,0,0,786,5999,1,0,0,0,788,6006,1,0,0,0,790,6013,1,0,0,0,
  	792,6018,1,0,0,0,794,6023,1,0,0,0,796,6026,1,0,0,0,798,6039,1,0,0,0,800,
  	6047,1,0,0,0,802,6053,1,0,0,0,804,6061,1,0,0,0,806,6066,1,0,0,0,808,6071,
  	1,0,0,0,810,6074,1,0,0,0,812,6084,1,0,0,0,814,6092,1,0,0,0,816,6097,1,
  	0,0,0,818,6102,1,0,0,0,820,6106,1,0,0,0,822,6116,1,0,0,0,824,6121,1,0,
  	0,0,826,6126,1,0,0,0,828,6131,1,0,0,0,830,6136,1,0,0,0,832,6142,1,0,0,
  	0,834,6148,1,0,0,0,836,6153,1,0,0,0,838,6158,1,0,0,0,840,6163,1,0,0,0,
  	842,6174,1,0,0,0,844,6178,1,0,0,0,846,6180,1,0,0,0,848,6182,1,0,0,0,850,
  	6185,1,0,0,0,852,6200,1,0,0,0,854,6239,1,0,0,0,856,6243,1,0,0,0,858,6245,
  	1,0,0,0,860,6253,1,0,0,0,862,6257,1,0,0,0,864,6265,1,0,0,0,866,6274,1,
  	0,0,0,868,6276,1,0,0,0,870,6301,1,0,0,0,872,6303,1,0,0,0,874,6305,1,0,
  	0,0,876,6320,1,0,0,0,878,6332,1,0,0,0,880,6334,1,0,0,0,882,6342,1,0,0,
  	0,884,6350,1,0,0,0,886,6359,1,0,0,0,888,6361,1,0,0,0,890,6379,1,0,0,0,
  	892,6393,1,0,0,0,894,6398,1,0,0,0,896,6404,1,0,0,0,898,6406,1,0,0,0,900,
  	6422,1,0,0,0,902,6430,1,0,0,0,904,6440,1,0,0,0,906,6453,1,0,0,0,908,6455,
  	1,0,0,0,910,6461,1,0,0,0,912,6491,1,0,0,0,914,6501,1,0,0,0,916,6503,1,
  	0,0,0,918,6507,1,0,0,0,920,6510,1,0,0,0,922,6513,1,0,0,0,924,6526,1,0,
  	0,0,926,6542,1,0,0,0,928,6565,1,0,0,0,930,6567,1,0,0,0,932,6604,1,0,0,
  	0,934,6606,1,0,0,0,936,6763,1,0,0,0,938,6776,1,0,0,0,940,6785,1,0,0,0,
  	942,6881,1,0,0,0,944,6883,1,0,0,0,946,6937,1,0,0,0,948,6939,1,0,0,0,950,
  	6945,1,0,0,0,952,6947,1,0,0,0,954,6954,1,0,0,0,956,6959,1,0,0,0,958,6972,
  	1,0,0,0,960,6977,1,0,0,0,962,6979,1,0,0,0,964,6998,1,0,0,0,966,7001,1,
  	0,0,0,968,7010,1,0,0,0,970,7012,1,0,0,0,972,7035,1,0,0,0,974,7325,1,0,
  	0,0,976,7327,1,0,0,0,978,7361,1,0,0,0,980,7363,1,0,0,0,982,7369,1,0,0,
  	0,984,7371,1,0,0,0,986,7386,1,0,0,0,988,7394,1,0,0,0,990,7396,1,0,0,0,
  	992,7425,1,0,0,0,994,7458,1,0,0,0,996,7460,1,0,0,0,998,7468,1,0,0,0,1000,
  	7472,1,0,0,0,1002,7477,1,0,0,0,1004,7479,1,0,0,0,1006,7490,1,0,0,0,1008,
  	7505,1,0,0,0,1010,7507,1,0,0,0,1012,7511,1,0,0,0,1014,7514,1,0,0,0,1016,
  	7517,1,0,0,0,1018,7569,1,0,0,0,1020,7571,1,0,0,0,1022,7582,1,0,0,0,1024,
  	7584,1,0,0,0,1026,7586,1,0,0,0,1028,7590,1,0,0,0,1030,7592,1,0,0,0,1032,
  	7594,1,0,0,0,1034,7598,1,0,0,0,1036,7602,1,0,0,0,1038,7606,1,0,0,0,1040,
  	7614,1,0,0,0,1042,7618,1,0,0,0,1044,7626,1,0,0,0,1046,7628,1,0,0,0,1048,
  	7646,1,0,0,0,1050,7648,1,0,0,0,1052,7651,1,0,0,0,1054,7656,1,0,0,0,1056,
  	7664,1,0,0,0,1058,7670,1,0,0,0,1060,7674,1,0,0,0,1062,7691,1,0,0,0,1064,
  	7694,1,0,0,0,1066,7699,1,0,0,0,1068,7701,1,0,0,0,1070,7704,1,0,0,0,1072,
  	7713,1,0,0,0,1074,7721,1,0,0,0,1076,7723,1,0,0,0,1078,7728,1,0,0,0,1080,
  	7735,1,0,0,0,1082,7745,1,0,0,0,1084,7753,1,0,0,0,1086,7755,1,0,0,0,1088,
  	7765,1,0,0,0,1090,7773,1,0,0,0,1092,7775,1,0,0,0,1094,7781,1,0,0,0,1096,
  	7802,1,0,0,0,1098,7804,1,0,0,0,1100,7810,1,0,0,0,1102,7813,1,0,0,0,1104,
  	7816,1,0,0,0,1106,7844,1,0,0,0,1108,7848,1,0,0,0,1110,7855,1,0,0,0,1112,
  	7862,1,0,0,0,1114,7864,1,0,0,0,1116,7880,1,0,0,0,1118,7896,1,0,0,0,1120,
  	7900,1,0,0,0,1122,7903,1,0,0,0,1124,7906,1,0,0,0,1126,7930,1,0,0,0,1128,
  	7932,1,0,0,0,1130,7940,1,0,0,0,1132,7942,1,0,0,0,1134,7945,1,0,0,0,1136,
  	8025,1,0,0,0,1138,8027,1,0,0,0,1140,8031,1,0,0,0,1142,8131,1,0,0,0,1144,
  	8133,1,0,0,0,1146,8135,1,0,0,0,1148,8137,1,0,0,0,1150,8142,1,0,0,0,1152,
  	8158,1,0,0,0,1154,8160,1,0,0,0,1156,8194,1,0,0,0,1158,8196,1,0,0,0,1160,
  	8207,1,0,0,0,1162,8214,1,0,0,0,1164,8231,1,0,0,0,1166,8233,1,0,0,0,1168,
  	8237,1,0,0,0,1170,8260,1,0,0,0,1172,8262,1,0,0,0,1174,8264,1,0,0,0,1176,
  	8271,1,0,0,0,1178,8273,1,0,0,0,1180,8275,1,0,0,0,1182,8429,1,0,0,0,1184,
  	8434,1,0,0,0,1186,8441,1,0,0,0,1188,8443,1,0,0,0,1190,8451,1,0,0,0,1192,
  	8469,1,0,0,0,1194,8477,1,0,0,0,1196,8485,1,0,0,0,1198,8487,1,0,0,0,1200,
  	8491,1,0,0,0,1202,8500,1,0,0,0,1204,8506,1,0,0,0,1206,8513,1,0,0,0,1208,
  	8515,1,0,0,0,1210,8530,1,0,0,0,1212,8537,1,0,0,0,1214,8540,1,0,0,0,1216,
  	8690,1,0,0,0,1218,8694,1,0,0,0,1220,8697,1,0,0,0,1222,8706,1,0,0,0,1224,
  	8715,1,0,0,0,1226,8723,1,0,0,0,1228,8769,1,0,0,0,1230,8771,1,0,0,0,1232,
  	8792,1,0,0,0,1234,8796,1,0,0,0,1236,8807,1,0,0,0,1238,8852,1,0,0,0,1240,
  	8888,1,0,0,0,1242,8890,1,0,0,0,1244,8898,1,0,0,0,1246,8911,1,0,0,0,1248,
  	8913,1,0,0,0,1250,8917,1,0,0,0,1252,8921,1,0,0,0,1254,8932,1,0,0,0,1256,
  	8934,1,0,0,0,1258,8938,1,0,0,0,1260,8943,1,0,0,0,1262,8947,1,0,0,0,1264,
  	8950,1,0,0,0,1266,8953,1,0,0,0,1268,8957,1,0,0,0,1270,8963,1,0,0,0,1272,
  	8971,1,0,0,0,1274,8979,1,0,0,0,1276,8985,1,0,0,0,1278,8988,1,0,0,0,1280,
  	9023,1,0,0,0,1282,9025,1,0,0,0,1284,9031,1,0,0,0,1286,9035,1,0,0,0,1288,
  	9043,1,0,0,0,1290,9051,1,0,0,0,1292,9066,1,0,0,0,1294,9081,1,0,0,0,1296,
  	9083,1,0,0,0,1298,9091,1,0,0,0,1300,9096,1,0,0,0,1302,9100,1,0,0,0,1304,
  	9106,1,0,0,0,1306,9112,1,0,0,0,1308,9119,1,0,0,0,1310,9126,1,0,0,0,1312,
  	9130,1,0,0,0,1314,9149,1,0,0,0,1316,9151,1,0,0,0,1318,9154,1,0,0,0,1320,
  	9157,1,0,0,0,1322,9170,1,0,0,0,1324,9172,1,0,0,0,1326,9177,1,0,0,0,1328,
  	9179,1,0,0,0,1330,9181,1,0,0,0,1332,9183,1,0,0,0,1334,9191,1,0,0,0,1336,
  	9197,1,0,0,0,1338,9199,1,0,0,0,1340,9201,1,0,0,0,1342,9212,1,0,0,0,1344,
  	9216,1,0,0,0,1346,9218,1,0,0,0,1348,9220,1,0,0,0,1350,9222,1,0,0,0,1352,
  	9231,1,0,0,0,1354,9233,1,0,0,0,1356,9235,1,0,0,0,1358,9237,1,0,0,0,1360,
  	9239,1,0,0,0,1362,9241,1,0,0,0,1364,9243,1,0,0,0,1366,9245,1,0,0,0,1368,
  	9249,1,0,0,0,1370,9253,1,0,0,0,1372,9255,1,0,0,0,1374,9257,1,0,0,0,1376,
  	9259,1,0,0,0,1378,9261,1,0,0,0,1380,9263,1,0,0,0,1382,9265,1,0,0,0,1384,
  	9267,1,0,0,0,1386,9269,1,0,0,0,1388,9271,1,0,0,0,1390,9273,1,0,0,0,1392,
  	9277,1,0,0,0,1394,9279,1,0,0,0,1396,9282,1,0,0,0,1398,9294,1,0,0,0,1400,
  	9296,1,0,0,0,1402,9304,1,0,0,0,1404,9312,1,0,0,0,1406,9316,1,0,0,0,1408,
  	9318,1,0,0,0,1410,9322,1,0,0,0,1412,9324,1,0,0,0,1414,9326,1,0,0,0,1416,
  	9328,1,0,0,0,1418,9330,1,0,0,0,1420,9332,1,0,0,0,1422,9334,1,0,0,0,1424,
  	9339,1,0,0,0,1426,9343,1,0,0,0,1428,9345,1,0,0,0,1430,9353,1,0,0,0,1432,
  	9357,1,0,0,0,1434,9372,1,0,0,0,1436,9374,1,0,0,0,1438,9377,1,0,0,0,1440,
  	9379,1,0,0,0,1442,9381,1,0,0,0,1444,9388,1,0,0,0,1446,9395,1,0,0,0,1448,
  	9400,1,0,0,0,1450,9411,1,0,0,0,1452,9416,1,0,0,0,1454,9418,1,0,0,0,1456,
  	9420,1,0,0,0,1458,9434,1,0,0,0,1460,9439,1,0,0,0,1462,9444,1,0,0,0,1464,
  	9451,1,0,0,0,1466,9459,1,0,0,0,1468,9461,1,0,0,0,1470,9472,1,0,0,0,1472,
  	9474,1,0,0,0,1474,9476,1,0,0,0,1476,9478,1,0,0,0,1478,9486,1,0,0,0,1480,
  	9490,1,0,0,0,1482,9492,1,0,0,0,1484,9494,1,0,0,0,1486,9502,1,0,0,0,1488,
  	9506,1,0,0,0,1490,9510,1,0,0,0,1492,9514,1,0,0,0,1494,9516,1,0,0,0,1496,
  	9519,1,0,0,0,1498,9528,1,0,0,0,1500,9536,1,0,0,0,1502,9545,1,0,0,0,1504,
  	9549,1,0,0,0,1506,9568,1,0,0,0,1508,9570,1,0,0,0,1510,9609,1,0,0,0,1512,
  	9629,1,0,0,0,1514,9631,1,0,0,0,1516,9646,1,0,0,0,1518,9658,1,0,0,0,1520,
  	9664,1,0,0,0,1522,9666,1,0,0,0,1524,9673,1,0,0,0,1526,9686,1,0,0,0,1528,
  	1531,3,2,1,0,1529,1531,3,474,237,0,1530,1528,1,0,0,0,1530,1529,1,0,0,
  	0,1531,1533,1,0,0,0,1532,1534,5,30,0,0,1533,1532,1,0,0,0,1533,1534,1,
  	0,0,0,1534,1536,1,0,0,0,1535,1530,1,0,0,0,1535,1536,1,0,0,0,1536,1537,
  	1,0,0,0,1537,1538,5,0,0,1,1538,1,1,0,0,0,1539,1624,3,4,2,0,1540,1624,
  	3,80,40,0,1541,1624,3,198,99,0,1542,1624,3,232,116,0,1543,1624,3,236,
  	118,0,1544,1545,4,1,0,0,1545,1624,3,238,119,0,1546,1624,3,240,120,0,1547,
  	1624,3,242,121,0,1548,1624,3,248,124,0,1549,1624,3,250,125,0,1550,1624,
  	3,254,127,0,1551,1624,3,274,137,0,1552,1624,3,304,152,0,1553,1624,3,306,
  	153,0,1554,1624,3,468,234,0,1555,1624,3,470,235,0,1556,1624,3,492,246,
  	0,1557,1624,3,622,311,0,1558,1559,4,1,1,0,1559,1624,3,628,314,0,1560,
  	1624,3,634,317,0,1561,1624,3,700,350,0,1562,1624,3,714,357,0,1563,1624,
  	3,716,358,0,1564,1624,3,726,363,0,1565,1624,3,748,374,0,1566,1624,3,750,
  	375,0,1567,1624,3,752,376,0,1568,1624,3,754,377,0,1569,1624,3,756,378,
  	0,1570,1624,3,758,379,0,1571,1624,3,760,380,0,1572,1624,3,762,381,0,1573,
  	1624,3,764,382,0,1574,1624,3,766,383,0,1575,1624,3,768,384,0,1576,1624,
  	3,770,385,0,1577,1624,3,772,386,0,1578,1579,4,1,2,0,1579,1624,3,774,387,
  	0,1580,1624,3,776,388,0,1581,1624,3,778,389,0,1582,1624,3,780,390,0,1583,
  	1624,3,782,391,0,1584,1624,3,784,392,0,1585,1624,3,786,393,0,1586,1624,
  	3,788,394,0,1587,1624,3,790,395,0,1588,1624,3,792,396,0,1589,1624,3,794,
  	397,0,1590,1624,3,796,398,0,1591,1624,3,798,399,0,1592,1624,3,800,400,
  	0,1593,1624,3,802,401,0,1594,1624,3,804,402,0,1595,1624,3,806,403,0,1596,
  	1624,3,808,404,0,1597,1624,3,810,405,0,1598,1624,3,812,406,0,1599,1624,
  	3,814,407,0,1600,1624,3,816,408,0,1601,1602,4,1,3,0,1602,1624,3,818,409,
  	0,1603,1624,3,820,410,0,1604,1624,3,822,411,0,1605,1624,3,824,412,0,1606,
  	1607,4,1,4,0,1607,1624,3,826,413,0,1608,1624,3,828,414,0,1609,1624,3,
  	830,415,0,1610,1624,3,832,416,0,1611,1624,3,834,417,0,1612,1624,3,836,
  	418,0,1613,1624,3,838,419,0,1614,1615,4,1,5,0,1615,1624,3,840,420,0,1616,
  	1617,4,1,6,0,1617,1624,3,886,443,0,1618,1624,3,854,427,0,1619,1624,3,
  	906,453,0,1620,1624,3,1104,552,0,1621,1624,3,1114,557,0,1622,1624,3,1116,
  	558,0,1623,1539,1,0,0,0,1623,1540,1,0,0,0,1623,1541,1,0,0,0,1623,1542,
  	1,0,0,0,1623,1543,1,0,0,0,1623,1544,1,0,0,0,1623,1546,1,0,0,0,1623,1547,
  	1,0,0,0,1623,1548,1,0,0,0,1623,1549,1,0,0,0,1623,1550,1,0,0,0,1623,1551,
  	1,0,0,0,1623,1552,1,0,0,0,1623,1553,1,0,0,0,1623,1554,1,0,0,0,1623,1555,
  	1,0,0,0,1623,1556,1,0,0,0,1623,1557,1,0,0,0,1623,1558,1,0,0,0,1623,1560,
  	1,0,0,0,1623,1561,1,0,0,0,1623,1562,1,0,0,0,1623,1563,1,0,0,0,1623,1564,
  	1,0,0,0,1623,1565,1,0,0,0,1623,1566,1,0,0,0,1623,1567,1,0,0,0,1623,1568,
  	1,0,0,0,1623,1569,1,0,0,0,1623,1570,1,0,0,0,1623,1571,1,0,0,0,1623,1572,
  	1,0,0,0,1623,1573,1,0,0,0,1623,1574,1,0,0,0,1623,1575,1,0,0,0,1623,1576,
  	1,0,0,0,1623,1577,1,0,0,0,1623,1578,1,0,0,0,1623,1580,1,0,0,0,1623,1581,
  	1,0,0,0,1623,1582,1,0,0,0,1623,1583,1,0,0,0,1623,1584,1,0,0,0,1623,1585,
  	1,0,0,0,1623,1586,1,0,0,0,1623,1587,1,0,0,0,1623,1588,1,0,0,0,1623,1589,
  	1,0,0,0,1623,1590,1,0,0,0,1623,1591,1,0,0,0,1623,1592,1,0,0,0,1623,1593,
  	1,0,0,0,1623,1594,1,0,0,0,1623,1595,1,0,0,0,1623,1596,1,0,0,0,1623,1597,
  	1,0,0,0,1623,1598,1,0,0,0,1623,1599,1,0,0,0,1623,1600,1,0,0,0,1623,1601,
  	1,0,0,0,1623,1603,1,0,0,0,1623,1604,1,0,0,0,1623,1605,1,0,0,0,1623,1606,
  	1,0,0,0,1623,1608,1,0,0,0,1623,1609,1,0,0,0,1623,1610,1,0,0,0,1623,1611,
  	1,0,0,0,1623,1612,1,0,0,0,1623,1613,1,0,0,0,1623,1614,1,0,0,0,1623,1616,
  	1,0,0,0,1623,1618,1,0,0,0,1623,1619,1,0,0,0,1623,1620,1,0,0,0,1623,1621,
  	1,0,0,0,1623,1622,1,0,0,0,1624,3,1,0,0,0,1625,1646,5,57,0,0,1626,1647,
  	3,20,10,0,1627,1647,3,6,3,0,1628,1629,5,452,0,0,1629,1631,3,1358,679,
  	0,1630,1632,3,118,59,0,1631,1630,1,0,0,0,1631,1632,1,0,0,0,1632,1647,
  	1,0,0,0,1633,1634,5,242,0,0,1634,1636,3,1362,681,0,1635,1637,3,118,59,
  	0,1636,1635,1,0,0,0,1636,1637,1,0,0,0,1637,1647,1,0,0,0,1638,1647,3,70,
  	35,0,1639,1647,3,10,5,0,1640,1647,3,56,28,0,1641,1642,4,2,7,0,1642,1647,
  	3,58,29,0,1643,1647,3,12,6,0,1644,1647,3,18,9,0,1645,1647,3,78,39,0,1646,
  	1626,1,0,0,0,1646,1627,1,0,0,0,1646,1628,1,0,0,0,1646,1633,1,0,0,0,1646,
  	1638,1,0,0,0,1646,1639,1,0,0,0,1646,1640,1,0,0,0,1646,1641,1,0,0,0,1646,
  	1643,1,0,0,0,1646,1644,1,0,0,0,1646,1645,1,0,0,0,1647,5,1,0,0,0,1648,
  	1649,5,151,0,0,1649,1660,3,1354,677,0,1650,1652,3,8,4,0,1651,1650,1,0,
  	0,0,1652,1653,1,0,0,0,1653,1651,1,0,0,0,1653,1654,1,0,0,0,1654,1661,1,
  	0,0,0,1655,1656,4,3,8,0,1656,1657,5,641,0,0,1657,1658,5,154,0,0,1658,
  	1659,5,179,0,0,1659,1661,5,388,0,0,1660,1651,1,0,0,0,1660,1655,1,0,0,
  	0,1661,7,1,0,0,0,1662,1670,3,84,42,0,1663,1664,5,465,0,0,1664,1666,5,
  	416,0,0,1665,1667,5,6,0,0,1666,1665,1,0,0,0,1666,1667,1,0,0,0,1667,1668,
  	1,0,0,0,1668,1670,3,1218,609,0,1669,1662,1,0,0,0,1669,1663,1,0,0,0,1670,
  	9,1,0,0,0,1671,1673,3,1248,624,0,1672,1671,1,0,0,0,1672,1673,1,0,0,0,
  	1673,1674,1,0,0,0,1674,1675,5,209,0,0,1675,1679,3,1382,691,0,1676,1677,
  	5,413,0,0,1677,1678,5,519,0,0,1678,1680,3,1126,563,0,1679,1676,1,0,0,
  	0,1679,1680,1,0,0,0,1680,1687,1,0,0,0,1681,1682,5,413,0,0,1682,1684,5,
  	123,0,0,1683,1685,5,401,0,0,1684,1683,1,0,0,0,1684,1685,1,0,0,0,1685,
  	1686,1,0,0,0,1686,1688,5,448,0,0,1687,1681,1,0,0,0,1687,1688,1,0,0,0,
  	1688,1692,1,0,0,0,1689,1690,5,483,0,0,1690,1691,5,616,0,0,1691,1693,3,
  	1426,713,0,1692,1689,1,0,0,0,1692,1693,1,0,0,0,1693,1700,1,0,0,0,1694,
  	1701,5,195,0,0,1695,1698,5,180,0,0,1696,1697,5,413,0,0,1697,1699,3,620,
  	310,0,1698,1696,1,0,0,0,1698,1699,1,0,0,0,1699,1701,1,0,0,0,1700,1694,
  	1,0,0,0,1700,1695,1,0,0,0,1700,1701,1,0,0,0,1701,1704,1,0,0,0,1702,1703,
  	5,119,0,0,1703,1705,3,1464,732,0,1704,1702,1,0,0,0,1704,1705,1,0,0,0,
  	1705,1708,1,0,0,0,1706,1707,5,186,0,0,1707,1709,3,1048,524,0,1708,1706,
  	1,0,0,0,1708,1709,1,0,0,0,1709,11,1,0,0,0,1710,1711,5,320,0,0,1711,1712,
  	5,253,0,0,1712,1713,3,1378,689,0,1713,1714,5,50,0,0,1714,1715,5,629,0,
  	0,1715,1717,3,1464,732,0,1716,1718,3,14,7,0,1717,1716,1,0,0,0,1717,1718,
  	1,0,0,0,1718,13,1,0,0,0,1719,1726,3,16,8,0,1720,1722,5,29,0,0,1721,1720,
  	1,0,0,0,1721,1722,1,0,0,0,1722,1723,1,0,0,0,1723,1725,3,16,8,0,1724,1721,
  	1,0,0,0,1725,1728,1,0,0,0,1726,1724,1,0,0,0,1726,1727,1,0,0,0,1727,15,
  	1,0,0,0,1728,1726,1,0,0,0,1729,1733,3,154,77,0,1730,1733,3,166,83,0,1731,
  	1733,3,168,84,0,1732,1729,1,0,0,0,1732,1730,1,0,0,0,1732,1731,1,0,0,0,
  	1733,17,1,0,0,0,1734,1735,5,530,0,0,1735,1736,3,1388,694,0,1736,1737,
  	3,136,68,0,1737,19,1,0,0,0,1738,1740,3,1328,664,0,1739,1738,1,0,0,0,1739,
  	1740,1,0,0,0,1740,1741,1,0,0,0,1741,1742,5,600,0,0,1742,1744,3,1398,699,
  	0,1743,1745,3,22,11,0,1744,1743,1,0,0,0,1744,1745,1,0,0,0,1745,21,1,0,
  	0,0,1746,1749,3,24,12,0,1747,1750,3,1226,613,0,1748,1750,3,52,26,0,1749,
  	1747,1,0,0,0,1749,1748,1,0,0,0,1749,1750,1,0,0,0,1750,1760,1,0,0,0,1751,
  	1760,3,1226,613,0,1752,1760,3,52,26,0,1753,1754,3,26,13,0,1754,1755,5,
  	29,0,0,1755,1757,1,0,0,0,1756,1753,1,0,0,0,1756,1757,1,0,0,0,1757,1758,
  	1,0,0,0,1758,1760,3,28,14,0,1759,1746,1,0,0,0,1759,1751,1,0,0,0,1759,
  	1752,1,0,0,0,1759,1756,1,0,0,0,1760,23,1,0,0,0,1761,1769,3,26,13,0,1762,
  	1763,3,26,13,0,1763,1764,5,29,0,0,1764,1766,1,0,0,0,1765,1762,1,0,0,0,
  	1765,1766,1,0,0,0,1766,1767,1,0,0,0,1767,1769,3,32,16,0,1768,1761,1,0,
  	0,0,1768,1765,1,0,0,0,1769,25,1,0,0,0,1770,1775,3,34,17,0,1771,1772,5,
  	29,0,0,1772,1774,3,34,17,0,1773,1771,1,0,0,0,1774,1777,1,0,0,0,1775,1773,
  	1,0,0,0,1775,1776,1,0,0,0,1776,27,1,0,0,0,1777,1775,1,0,0,0,1778,1779,
  	5,181,0,0,1779,1797,5,598,0,0,1780,1781,5,270,0,0,1781,1797,5,598,0,0,
  	1782,1797,3,30,15,0,1783,1794,4,14,9,0,1784,1787,5,747,0,0,1785,1786,
  	4,14,10,0,1786,1788,3,1332,666,0,1787,1785,1,0,0,0,1787,1788,1,0,0,0,
  	1788,1795,1,0,0,0,1789,1792,5,748,0,0,1790,1791,4,14,11,0,1791,1793,3,
  	1332,666,0,1792,1790,1,0,0,0,1792,1793,1,0,0,0,1793,1795,1,0,0,0,1794,
  	1784,1,0,0,0,1794,1789,1,0,0,0,1795,1797,1,0,0,0,1796,1778,1,0,0,0,1796,
  	1780,1,0,0,0,1796,1782,1,0,0,0,1796,1783,1,0,0,0,1797,29,1,0,0,0,1798,
  	1799,5,50,0,0,1799,1801,5,435,0,0,1800,1802,3,1330,665,0,1801,1800,1,
  	0,0,0,1801,1802,1,0,0,0,1802,1806,1,0,0,0,1803,1807,3,1234,617,0,1804,
  	1805,5,434,0,0,1805,1807,3,1440,720,0,1806,1803,1,0,0,0,1806,1804,1,0,
  	0,0,1807,1895,1,0,0,0,1808,1809,5,187,0,0,1809,1810,5,435,0,0,1810,1895,
  	3,1428,714,0,1811,1812,5,468,0,0,1812,1814,5,435,0,0,1813,1815,3,1330,
  	665,0,1814,1813,1,0,0,0,1814,1815,1,0,0,0,1815,1816,1,0,0,0,1816,1895,
  	3,54,27,0,1817,1818,5,418,0,0,1818,1820,5,435,0,0,1819,1821,3,1330,665,
  	0,1820,1819,1,0,0,0,1820,1821,1,0,0,0,1821,1822,1,0,0,0,1822,1824,3,54,
  	27,0,1823,1825,3,1330,665,0,1824,1823,1,0,0,0,1824,1825,1,0,0,0,1825,
  	1895,1,0,0,0,1826,1827,5,60,0,0,1827,1829,5,435,0,0,1828,1830,3,1330,
  	665,0,1829,1828,1,0,0,0,1829,1830,1,0,0,0,1830,1831,1,0,0,0,1831,1895,
  	3,54,27,0,1832,1833,5,106,0,0,1833,1834,5,435,0,0,1834,1838,3,54,27,0,
  	1835,1837,3,710,355,0,1836,1835,1,0,0,0,1837,1840,1,0,0,0,1838,1836,1,
  	0,0,0,1838,1839,1,0,0,0,1839,1895,1,0,0,0,1840,1838,1,0,0,0,1841,1842,
  	5,485,0,0,1842,1844,5,435,0,0,1843,1845,3,1330,665,0,1844,1843,1,0,0,
  	0,1844,1845,1,0,0,0,1845,1846,1,0,0,0,1846,1850,3,54,27,0,1847,1849,3,
  	712,356,0,1848,1847,1,0,0,0,1849,1852,1,0,0,0,1850,1848,1,0,0,0,1850,
  	1851,1,0,0,0,1851,1895,1,0,0,0,1852,1850,1,0,0,0,1853,1854,5,111,0,0,
  	1854,1856,5,435,0,0,1855,1857,3,1330,665,0,1856,1855,1,0,0,0,1856,1857,
  	1,0,0,0,1857,1858,1,0,0,0,1858,1895,3,1440,720,0,1859,1860,5,623,0,0,
  	1860,1861,5,435,0,0,1861,1895,3,54,27,0,1862,1863,5,484,0,0,1863,1865,
  	5,435,0,0,1864,1866,3,1330,665,0,1865,1864,1,0,0,0,1865,1866,1,0,0,0,
  	1866,1871,1,0,0,0,1867,1868,3,1428,714,0,1868,1869,5,283,0,0,1869,1870,
  	3,1234,617,0,1870,1872,1,0,0,0,1871,1867,1,0,0,0,1871,1872,1,0,0,0,1872,
  	1895,1,0,0,0,1873,1874,5,211,0,0,1874,1875,5,435,0,0,1875,1876,3,1426,
  	713,0,1876,1877,5,670,0,0,1877,1878,5,600,0,0,1878,1880,3,1398,699,0,
  	1879,1881,3,50,25,0,1880,1879,1,0,0,0,1880,1881,1,0,0,0,1881,1895,1,0,
  	0,0,1882,1883,4,15,12,0,1883,1884,5,181,0,0,1884,1885,5,435,0,0,1885,
  	1886,3,54,27,0,1886,1887,5,598,0,0,1887,1895,1,0,0,0,1888,1889,4,15,13,
  	0,1889,1890,5,270,0,0,1890,1891,5,435,0,0,1891,1892,3,54,27,0,1892,1893,
  	5,598,0,0,1893,1895,1,0,0,0,1894,1798,1,0,0,0,1894,1808,1,0,0,0,1894,
  	1811,1,0,0,0,1894,1817,1,0,0,0,1894,1826,1,0,0,0,1894,1832,1,0,0,0,1894,
  	1841,1,0,0,0,1894,1853,1,0,0,0,1894,1859,1,0,0,0,1894,1862,1,0,0,0,1894,
  	1873,1,0,0,0,1894,1882,1,0,0,0,1894,1888,1,0,0,0,1895,31,1,0,0,0,1896,
  	1899,3,36,18,0,1897,1899,3,1214,607,0,1898,1896,1,0,0,0,1898,1897,1,0,
  	0,0,1899,1908,1,0,0,0,1900,1904,5,29,0,0,1901,1905,3,36,18,0,1902,1905,
  	3,34,17,0,1903,1905,3,1214,607,0,1904,1901,1,0,0,0,1904,1902,1,0,0,0,
  	1904,1903,1,0,0,0,1905,1907,1,0,0,0,1906,1900,1,0,0,0,1907,1910,1,0,0,
  	0,1908,1906,1,0,0,0,1908,1909,1,0,0,0,1909,33,1,0,0,0,1910,1908,1,0,0,
  	0,1911,1915,3,44,22,0,1912,1915,3,46,23,0,1913,1915,3,50,25,0,1914,1911,
  	1,0,0,0,1914,1912,1,0,0,0,1914,1913,1,0,0,0,1915,35,1,0,0,0,1916,1918,
  	5,50,0,0,1917,1919,5,116,0,0,1918,1917,1,0,0,0,1918,1919,1,0,0,0,1919,
  	1932,1,0,0,0,1920,1921,3,1426,713,0,1921,1923,3,1140,570,0,1922,1924,
  	3,1130,565,0,1923,1922,1,0,0,0,1923,1924,1,0,0,0,1924,1926,1,0,0,0,1925,
  	1927,3,38,19,0,1926,1925,1,0,0,0,1926,1927,1,0,0,0,1927,1933,1,0,0,0,
  	1928,1929,5,32,0,0,1929,1930,3,88,44,0,1930,1931,5,33,0,0,1931,1933,1,
  	0,0,0,1932,1920,1,0,0,0,1932,1928,1,0,0,0,1933,2057,1,0,0,0,1934,1935,
  	5,50,0,0,1935,2057,3,1136,568,0,1936,1938,5,100,0,0,1937,1939,5,116,0,
  	0,1938,1937,1,0,0,0,1938,1939,1,0,0,0,1939,1940,1,0,0,0,1940,1941,3,1338,
  	669,0,1941,1942,3,1426,713,0,1942,1944,3,1140,570,0,1943,1945,3,38,19,
  	0,1944,1943,1,0,0,0,1944,1945,1,0,0,0,1945,2057,1,0,0,0,1946,1948,5,379,
  	0,0,1947,1949,5,116,0,0,1948,1947,1,0,0,0,1948,1949,1,0,0,0,1949,1950,
  	1,0,0,0,1950,1951,3,1338,669,0,1951,1953,3,1140,570,0,1952,1954,3,38,
  	19,0,1953,1952,1,0,0,0,1953,1954,1,0,0,0,1954,2057,1,0,0,0,1955,1977,
  	5,187,0,0,1956,1958,5,116,0,0,1957,1956,1,0,0,0,1957,1958,1,0,0,0,1958,
  	1959,1,0,0,0,1959,1961,3,1338,669,0,1960,1962,3,40,20,0,1961,1960,1,0,
  	0,0,1961,1962,1,0,0,0,1962,1978,1,0,0,0,1963,1964,5,235,0,0,1964,1965,
  	5,299,0,0,1965,1978,3,1338,669,0,1966,1967,5,450,0,0,1967,1978,5,299,
  	0,0,1968,1969,3,458,229,0,1969,1970,3,1348,674,0,1970,1978,1,0,0,0,1971,
  	1972,4,18,14,0,1972,1973,5,106,0,0,1973,1978,3,1426,713,0,1974,1975,4,
  	18,15,0,1975,1976,5,130,0,0,1976,1978,3,1426,713,0,1977,1957,1,0,0,0,
  	1977,1963,1,0,0,0,1977,1966,1,0,0,0,1977,1968,1,0,0,0,1977,1971,1,0,0,
  	0,1977,1974,1,0,0,0,1978,2057,1,0,0,0,1979,1980,5,180,0,0,1980,2057,5,
  	297,0,0,1981,1982,5,195,0,0,1982,2057,5,297,0,0,1983,1985,5,57,0,0,1984,
  	1986,5,116,0,0,1985,1984,1,0,0,0,1985,1986,1,0,0,0,1986,1987,1,0,0,0,
  	1987,2000,3,1338,669,0,1988,1989,5,533,0,0,1989,1993,5,168,0,0,1990,1991,
  	4,18,16,0,1991,1994,3,1034,517,0,1992,1994,3,1448,724,0,1993,1990,1,0,
  	0,0,1993,1992,1,0,0,0,1994,2001,1,0,0,0,1995,1996,5,187,0,0,1996,2001,
  	5,168,0,0,1997,1998,4,18,17,0,1998,1999,5,533,0,0,1999,2001,3,1172,586,
  	0,2000,1988,1,0,0,0,2000,1995,1,0,0,0,2000,1997,1,0,0,0,2001,2057,1,0,
  	0,0,2002,2003,4,18,18,0,2003,2004,5,57,0,0,2004,2005,5,272,0,0,2005,2006,
  	3,1348,674,0,2006,2007,3,1172,586,0,2007,2057,1,0,0,0,2008,2009,4,18,
  	19,0,2009,2010,5,57,0,0,2010,2011,5,106,0,0,2011,2012,3,1426,713,0,2012,
  	2013,3,1134,567,0,2013,2057,1,0,0,0,2014,2015,4,18,20,0,2015,2016,5,57,
  	0,0,2016,2017,5,130,0,0,2017,2018,3,1426,713,0,2018,2019,3,1134,567,0,
  	2019,2057,1,0,0,0,2020,2021,4,18,21,0,2021,2022,5,483,0,0,2022,2023,5,
  	116,0,0,2023,2024,3,1338,669,0,2024,2025,5,616,0,0,2025,2026,3,1426,713,
  	0,2026,2057,1,0,0,0,2027,2029,5,483,0,0,2028,2030,7,0,0,0,2029,2028,1,
  	0,0,0,2029,2030,1,0,0,0,2030,2031,1,0,0,0,2031,2057,3,1392,696,0,2032,
  	2033,5,483,0,0,2033,2034,3,458,229,0,2034,2035,3,1348,674,0,2035,2036,
  	5,616,0,0,2036,2037,3,1346,673,0,2037,2057,1,0,0,0,2038,2039,5,137,0,
  	0,2039,2040,5,616,0,0,2040,2044,3,1022,511,0,2041,2042,4,18,22,0,2042,
  	2045,5,168,0,0,2043,2045,3,1204,602,0,2044,2041,1,0,0,0,2044,2043,1,0,
  	0,0,2045,2047,1,0,0,0,2046,2048,3,1264,632,0,2047,2046,1,0,0,0,2047,2048,
  	1,0,0,0,2048,2057,1,0,0,0,2049,2057,5,234,0,0,2050,2051,5,423,0,0,2051,
  	2052,5,90,0,0,2052,2057,3,42,21,0,2053,2054,4,18,23,0,2054,2055,5,641,
  	0,0,2055,2057,5,433,0,0,2056,1916,1,0,0,0,2056,1934,1,0,0,0,2056,1936,
  	1,0,0,0,2056,1946,1,0,0,0,2056,1955,1,0,0,0,2056,1979,1,0,0,0,2056,1981,
  	1,0,0,0,2056,1983,1,0,0,0,2056,2002,1,0,0,0,2056,2008,1,0,0,0,2056,2014,
  	1,0,0,0,2056,2020,1,0,0,0,2056,2027,1,0,0,0,2056,2032,1,0,0,0,2056,2038,
  	1,0,0,0,2056,2049,1,0,0,0,2056,2050,1,0,0,0,2056,2053,1,0,0,0,2057,37,
  	1,0,0,0,2058,2059,5,52,0,0,2059,2062,3,1426,713,0,2060,2062,5,229,0,0,
  	2061,2058,1,0,0,0,2061,2060,1,0,0,0,2062,39,1,0,0,0,2063,2064,7,1,0,0,
  	2064,41,1,0,0,0,2065,2067,3,1426,713,0,2066,2068,3,380,190,0,2067,2066,
  	1,0,0,0,2067,2068,1,0,0,0,2068,2076,1,0,0,0,2069,2070,5,29,0,0,2070,2072,
  	3,1426,713,0,2071,2073,3,380,190,0,2072,2071,1,0,0,0,2072,2073,1,0,0,
  	0,2073,2075,1,0,0,0,2074,2069,1,0,0,0,2075,2078,1,0,0,0,2076,2074,1,0,
  	0,0,2076,2077,1,0,0,0,2077,43,1,0,0,0,2078,2076,1,0,0,0,2079,2081,5,55,
  	0,0,2080,2082,5,6,0,0,2081,2080,1,0,0,0,2081,2082,1,0,0,0,2082,2085,1,
  	0,0,0,2083,2086,5,168,0,0,2084,2086,3,1426,713,0,2085,2083,1,0,0,0,2085,
  	2084,1,0,0,0,2086,45,1,0,0,0,2087,2089,5,319,0,0,2088,2090,5,6,0,0,2089,
  	2088,1,0,0,0,2089,2090,1,0,0,0,2090,2093,1,0,0,0,2091,2094,5,168,0,0,
  	2092,2094,3,1426,713,0,2093,2091,1,0,0,0,2093,2092,1,0,0,0,2094,47,1,
  	0,0,0,2095,2097,3,44,22,0,2096,2098,3,46,23,0,2097,2096,1,0,0,0,2097,
  	2098,1,0,0,0,2098,2104,1,0,0,0,2099,2101,3,46,23,0,2100,2102,3,44,22,
  	0,2101,2100,1,0,0,0,2101,2102,1,0,0,0,2102,2104,1,0,0,0,2103,2095,1,0,
  	0,0,2103,2099,1,0,0,0,2104,49,1,0,0,0,2105,2106,4,25,24,0,2106,2107,7,
  	2,0,0,2107,2108,5,651,0,0,2108,51,1,0,0,0,2109,2110,5,482,0,0,2110,2111,
  	5,433,0,0,2111,53,1,0,0,0,2112,2115,5,56,0,0,2113,2115,3,1428,714,0,2114,
  	2112,1,0,0,0,2114,2113,1,0,0,0,2115,55,1,0,0,0,2116,2117,5,598,0,0,2117,
  	2129,3,1374,687,0,2118,2119,7,3,0,0,2119,2120,5,153,0,0,2120,2122,3,1464,
  	732,0,2121,2123,3,64,32,0,2122,2121,1,0,0,0,2122,2123,1,0,0,0,2123,2130,
  	1,0,0,0,2124,2125,5,483,0,0,2125,2126,5,616,0,0,2126,2130,3,1426,713,
  	0,2127,2128,4,28,25,0,2128,2130,3,64,32,0,2129,2118,1,0,0,0,2129,2124,
  	1,0,0,0,2129,2127,1,0,0,0,2130,57,1,0,0,0,2131,2132,5,631,0,0,2132,2133,
  	5,598,0,0,2133,2134,3,1374,687,0,2134,2135,5,533,0,0,2135,2137,7,4,0,
  	0,2136,2138,3,60,30,0,2137,2136,1,0,0,0,2137,2138,1,0,0,0,2138,59,1,0,
  	0,0,2139,2146,3,62,31,0,2140,2142,5,29,0,0,2141,2140,1,0,0,0,2141,2142,
  	1,0,0,0,2142,2143,1,0,0,0,2143,2145,3,62,31,0,2144,2141,1,0,0,0,2145,
  	2148,1,0,0,0,2146,2144,1,0,0,0,2146,2147,1,0,0,0,2147,61,1,0,0,0,2148,
  	2146,1,0,0,0,2149,2150,3,166,83,0,2150,63,1,0,0,0,2151,2158,3,66,33,0,
  	2152,2154,5,29,0,0,2153,2152,1,0,0,0,2153,2154,1,0,0,0,2154,2155,1,0,
  	0,0,2155,2157,3,66,33,0,2156,2153,1,0,0,0,2157,2160,1,0,0,0,2158,2156,
  	1,0,0,0,2158,2159,1,0,0,0,2159,65,1,0,0,0,2160,2158,1,0,0,0,2161,2163,
  	5,274,0,0,2162,2164,5,6,0,0,2163,2162,1,0,0,0,2163,2164,1,0,0,0,2164,
  	2165,1,0,0,0,2165,2174,3,1492,746,0,2166,2174,3,158,79,0,2167,2174,3,
  	160,80,0,2168,2174,3,166,83,0,2169,2174,3,168,84,0,2170,2174,3,174,87,
  	0,2171,2172,4,33,26,0,2172,2174,3,176,88,0,2173,2161,1,0,0,0,2173,2166,
  	1,0,0,0,2173,2167,1,0,0,0,2173,2168,1,0,0,0,2173,2169,1,0,0,0,2173,2170,
  	1,0,0,0,2173,2171,1,0,0,0,2174,67,1,0,0,0,2175,2177,5,274,0,0,2176,2178,
  	5,6,0,0,2177,2176,1,0,0,0,2177,2178,1,0,0,0,2178,2179,1,0,0,0,2179,2183,
  	3,1492,746,0,2180,2183,3,158,79,0,2181,2183,3,160,80,0,2182,2175,1,0,
  	0,0,2182,2180,1,0,0,0,2182,2181,1,0,0,0,2183,69,1,0,0,0,2184,2186,3,182,
  	91,0,2185,2184,1,0,0,0,2185,2186,1,0,0,0,2186,2188,1,0,0,0,2187,2189,
  	3,1248,624,0,2188,2187,1,0,0,0,2188,2189,1,0,0,0,2189,2191,1,0,0,0,2190,
  	2192,3,184,92,0,2191,2190,1,0,0,0,2191,2192,1,0,0,0,2192,2193,1,0,0,0,
  	2193,2194,5,661,0,0,2194,2195,3,1370,685,0,2195,2196,3,72,36,0,2196,71,
  	1,0,0,0,2197,2199,3,1340,670,0,2198,2197,1,0,0,0,2198,2199,1,0,0,0,2199,
  	2200,1,0,0,0,2200,2201,5,63,0,0,2201,2202,3,74,37,0,2202,73,1,0,0,0,2203,
  	2205,3,98,49,0,2204,2206,3,76,38,0,2205,2204,1,0,0,0,2205,2206,1,0,0,
  	0,2206,75,1,0,0,0,2207,2209,5,670,0,0,2208,2210,7,5,0,0,2209,2208,1,0,
  	0,0,2209,2210,1,0,0,0,2210,2211,1,0,0,0,2211,2212,5,106,0,0,2212,2213,
  	5,421,0,0,2213,77,1,0,0,0,2214,2215,4,39,27,0,2215,2244,5,280,0,0,2216,
  	2217,5,511,0,0,2217,2218,3,1486,743,0,2218,2219,5,348,0,0,2219,2220,5,
  	299,0,0,2220,2245,1,0,0,0,2221,2222,4,39,28,0,2222,2223,5,481,0,0,2223,
  	2228,5,772,0,0,2224,2225,4,39,29,0,2225,2226,5,236,0,0,2226,2227,5,102,
  	0,0,2227,2229,3,1426,713,0,2228,2224,1,0,0,0,2228,2229,1,0,0,0,2229,2234,
  	1,0,0,0,2230,2231,5,403,0,0,2231,2232,5,509,0,0,2232,2233,5,413,0,0,2233,
  	2235,5,204,0,0,2234,2230,1,0,0,0,2234,2235,1,0,0,0,2235,2245,1,0,0,0,
  	2236,2237,4,39,30,0,2237,2238,7,6,0,0,2238,2239,3,1426,713,0,2239,2240,
  	3,1426,713,0,2240,2245,1,0,0,0,2241,2242,4,39,31,0,2242,2243,5,481,0,
  	0,2243,2245,5,810,0,0,2244,2216,1,0,0,0,2244,2221,1,0,0,0,2244,2236,1,
  	0,0,0,2244,2241,1,0,0,0,2245,2248,1,0,0,0,2246,2248,1,0,0,0,2247,2214,
  	1,0,0,0,2247,2246,1,0,0,0,2248,79,1,0,0,0,2249,2270,5,140,0,0,2250,2271,
  	3,82,41,0,2251,2271,3,86,43,0,2252,2271,3,108,54,0,2253,2271,3,102,51,
  	0,2254,2271,3,110,55,0,2255,2271,3,128,64,0,2256,2271,3,178,89,0,2257,
  	2271,3,186,93,0,2258,2271,3,122,61,0,2259,2271,3,134,67,0,2260,2271,3,
  	140,70,0,2261,2271,3,190,95,0,2262,2263,4,40,32,0,2263,2271,3,192,96,
  	0,2264,2265,4,40,33,0,2265,2271,3,194,97,0,2266,2267,4,40,34,0,2267,2271,
  	3,142,71,0,2268,2269,4,40,35,0,2269,2271,3,144,72,0,2270,2250,1,0,0,0,
  	2270,2251,1,0,0,0,2270,2252,1,0,0,0,2270,2253,1,0,0,0,2270,2254,1,0,0,
  	0,2270,2255,1,0,0,0,2270,2256,1,0,0,0,2270,2257,1,0,0,0,2270,2258,1,0,
  	0,0,2270,2259,1,0,0,0,2270,2260,1,0,0,0,2270,2261,1,0,0,0,2270,2262,1,
  	0,0,0,2270,2264,1,0,0,0,2270,2266,1,0,0,0,2270,2268,1,0,0,0,2271,81,1,
  	0,0,0,2272,2274,5,151,0,0,2273,2275,3,1256,628,0,2274,2273,1,0,0,0,2274,
  	2275,1,0,0,0,2275,2276,1,0,0,0,2276,2280,3,1352,676,0,2277,2279,3,84,
  	42,0,2278,2277,1,0,0,0,2279,2282,1,0,0,0,2280,2278,1,0,0,0,2280,2281,
  	1,0,0,0,2281,83,1,0,0,0,2282,2280,1,0,0,0,2283,2288,3,1224,612,0,2284,
  	2288,3,1220,610,0,2285,2286,4,42,36,0,2286,2288,3,1222,611,0,2287,2283,
  	1,0,0,0,2287,2284,1,0,0,0,2287,2285,1,0,0,0,2288,85,1,0,0,0,2289,2291,
  	5,603,0,0,2290,2289,1,0,0,0,2290,2291,1,0,0,0,2291,2292,1,0,0,0,2292,
  	2294,5,600,0,0,2293,2295,3,1256,628,0,2294,2293,1,0,0,0,2294,2295,1,0,
  	0,0,2295,2296,1,0,0,0,2296,2313,3,1392,696,0,2297,2298,5,32,0,0,2298,
  	2299,3,88,44,0,2299,2300,5,33,0,0,2300,2302,1,0,0,0,2301,2297,1,0,0,0,
  	2301,2302,1,0,0,0,2302,2304,1,0,0,0,2303,2305,3,1210,605,0,2304,2303,
  	1,0,0,0,2304,2305,1,0,0,0,2305,2314,1,0,0,0,2306,2307,5,309,0,0,2307,
  	2314,3,1398,699,0,2308,2309,5,32,0,0,2309,2310,5,309,0,0,2310,2311,3,
  	1398,699,0,2311,2312,5,33,0,0,2312,2314,1,0,0,0,2313,2301,1,0,0,0,2313,
  	2306,1,0,0,0,2313,2308,1,0,0,0,2314,87,1,0,0,0,2315,2320,3,90,45,0,2316,
  	2317,5,29,0,0,2317,2319,3,90,45,0,2318,2316,1,0,0,0,2319,2322,1,0,0,0,
  	2320,2318,1,0,0,0,2320,2321,1,0,0,0,2321,89,1,0,0,0,2322,2320,1,0,0,0,
  	2323,2326,3,1128,564,0,2324,2326,3,1136,568,0,2325,2323,1,0,0,0,2325,
  	2324,1,0,0,0,2326,91,1,0,0,0,2327,2329,7,7,0,0,2328,2327,1,0,0,0,2328,
  	2329,1,0,0,0,2329,2330,1,0,0,0,2330,2331,3,94,47,0,2331,93,1,0,0,0,2332,
  	2334,5,63,0,0,2333,2332,1,0,0,0,2333,2334,1,0,0,0,2334,2335,1,0,0,0,2335,
  	2336,3,98,49,0,2336,95,1,0,0,0,2337,2339,3,310,155,0,2338,2340,3,394,
  	197,0,2339,2338,1,0,0,0,2339,2340,1,0,0,0,2340,2343,1,0,0,0,2341,2343,
  	3,314,157,0,2342,2337,1,0,0,0,2342,2341,1,0,0,0,2343,97,1,0,0,0,2344,
  	2346,3,310,155,0,2345,2347,3,394,197,0,2346,2345,1,0,0,0,2346,2347,1,
  	0,0,0,2347,99,1,0,0,0,2348,2352,5,140,0,0,2349,2353,3,102,51,0,2350,2353,
  	3,108,54,0,2351,2353,3,110,55,0,2352,2349,1,0,0,0,2352,2350,1,0,0,0,2352,
  	2351,1,0,0,0,2353,2355,1,0,0,0,2354,2356,5,30,0,0,2355,2354,1,0,0,0,2355,
  	2356,1,0,0,0,2356,2357,1,0,0,0,2357,2358,5,0,0,1,2358,101,1,0,0,0,2359,
  	2361,3,1248,624,0,2360,2359,1,0,0,0,2360,2361,1,0,0,0,2361,2362,1,0,0,
  	0,2362,2365,5,452,0,0,2363,2364,4,51,37,0,2364,2366,3,1256,628,0,2365,
  	2363,1,0,0,0,2365,2366,1,0,0,0,2366,2367,1,0,0,0,2367,2368,3,1356,678,
  	0,2368,2377,5,32,0,0,2369,2374,3,1260,630,0,2370,2371,5,29,0,0,2371,2373,
  	3,1260,630,0,2372,2370,1,0,0,0,2373,2376,1,0,0,0,2374,2372,1,0,0,0,2374,
  	2375,1,0,0,0,2375,2378,1,0,0,0,2376,2374,1,0,0,0,2377,2369,1,0,0,0,2377,
  	2378,1,0,0,0,2378,2379,1,0,0,0,2379,2383,5,33,0,0,2380,2382,3,112,56,
  	0,2381,2380,1,0,0,0,2382,2385,1,0,0,0,2383,2381,1,0,0,0,2383,2384,1,0,
  	0,0,2384,2386,1,0,0,0,2385,2383,1,0,0,0,2386,2387,3,106,53,0,2387,103,
  	1,0,0,0,2388,2391,3,1458,729,0,2389,2391,5,841,0,0,2390,2388,1,0,0,0,
  	2390,2389,1,0,0,0,2391,105,1,0,0,0,2392,2397,3,1048,524,0,2393,2394,4,
  	53,38,0,2394,2395,5,63,0,0,2395,2397,3,104,52,0,2396,2392,1,0,0,0,2396,
  	2393,1,0,0,0,2397,107,1,0,0,0,2398,2400,3,1248,624,0,2399,2398,1,0,0,
  	0,2399,2400,1,0,0,0,2400,2401,1,0,0,0,2401,2404,5,242,0,0,2402,2403,4,
  	54,39,0,2403,2405,3,1256,628,0,2404,2402,1,0,0,0,2404,2405,1,0,0,0,2405,
  	2406,1,0,0,0,2406,2407,3,1360,680,0,2407,2416,5,32,0,0,2408,2413,3,1262,
  	631,0,2409,2410,5,29,0,0,2410,2412,3,1262,631,0,2411,2409,1,0,0,0,2412,
  	2415,1,0,0,0,2413,2411,1,0,0,0,2413,2414,1,0,0,0,2414,2417,1,0,0,0,2415,
  	2413,1,0,0,0,2416,2408,1,0,0,0,2416,2417,1,0,0,0,2417,2418,1,0,0,0,2418,
  	2419,5,33,0,0,2419,2420,5,504,0,0,2420,2424,3,1266,633,0,2421,2423,3,
  	112,56,0,2422,2421,1,0,0,0,2423,2426,1,0,0,0,2424,2422,1,0,0,0,2424,2425,
  	1,0,0,0,2425,2427,1,0,0,0,2426,2424,1,0,0,0,2427,2428,3,106,53,0,2428,
  	109,1,0,0,0,2429,2431,5,54,0,0,2430,2429,1,0,0,0,2430,2431,1,0,0,0,2431,
  	2432,1,0,0,0,2432,2435,5,242,0,0,2433,2434,4,55,40,0,2434,2436,3,1256,
  	628,0,2435,2433,1,0,0,0,2435,2436,1,0,0,0,2436,2437,1,0,0,0,2437,2438,
  	3,1384,692,0,2438,2439,5,504,0,0,2439,2440,7,8,0,0,2440,2441,5,546,0,
  	0,2441,2442,3,1464,732,0,2442,111,1,0,0,0,2443,2455,3,120,60,0,2444,2446,
  	5,401,0,0,2445,2444,1,0,0,0,2445,2446,1,0,0,0,2446,2447,1,0,0,0,2447,
  	2455,5,177,0,0,2448,2449,4,56,41,0,2449,2450,5,647,0,0,2450,2451,5,32,
  	0,0,2451,2452,3,114,57,0,2452,2453,5,33,0,0,2453,2455,1,0,0,0,2454,2443,
  	1,0,0,0,2454,2445,1,0,0,0,2454,2448,1,0,0,0,2455,113,1,0,0,0,2456,2461,
  	3,116,58,0,2457,2458,5,29,0,0,2458,2460,3,116,58,0,2459,2457,1,0,0,0,
  	2460,2463,1,0,0,0,2461,2459,1,0,0,0,2461,2462,1,0,0,0,2462,115,1,0,0,
  	0,2463,2461,1,0,0,0,2464,2469,3,1420,710,0,2465,2467,5,63,0,0,2466,2465,
  	1,0,0,0,2466,2467,1,0,0,0,2467,2468,1,0,0,0,2468,2470,3,1426,713,0,2469,
  	2466,1,0,0,0,2469,2470,1,0,0,0,2470,117,1,0,0,0,2471,2473,3,120,60,0,
  	2472,2471,1,0,0,0,2473,2474,1,0,0,0,2474,2472,1,0,0,0,2474,2475,1,0,0,
  	0,2475,119,1,0,0,0,2476,2477,5,119,0,0,2477,2498,3,1464,732,0,2478,2482,
  	5,301,0,0,2479,2483,5,563,0,0,2480,2481,4,60,42,0,2481,2483,3,1426,713,
  	0,2482,2479,1,0,0,0,2482,2480,1,0,0,0,2483,2498,1,0,0,0,2484,2485,5,403,
  	0,0,2485,2498,5,563,0,0,2486,2487,5,134,0,0,2487,2498,5,563,0,0,2488,
  	2489,5,463,0,0,2489,2490,5,563,0,0,2490,2498,5,154,0,0,2491,2492,5,378,
  	0,0,2492,2493,5,563,0,0,2493,2498,5,154,0,0,2494,2495,5,563,0,0,2495,
  	2496,5,523,0,0,2496,2498,7,9,0,0,2497,2476,1,0,0,0,2497,2478,1,0,0,0,
  	2497,2484,1,0,0,0,2497,2486,1,0,0,0,2497,2488,1,0,0,0,2497,2491,1,0,0,
  	0,2497,2494,1,0,0,0,2498,121,1,0,0,0,2499,2501,3,1328,664,0,2500,2499,
  	1,0,0,0,2500,2501,1,0,0,0,2501,2537,1,0,0,0,2502,2504,5,635,0,0,2503,
  	2502,1,0,0,0,2503,2504,1,0,0,0,2504,2505,1,0,0,0,2505,2506,5,272,0,0,
  	2506,2508,3,1346,673,0,2507,2509,3,1174,587,0,2508,2507,1,0,0,0,2508,
  	2509,1,0,0,0,2509,2510,1,0,0,0,2510,2514,3,126,63,0,2511,2513,3,1168,
  	584,0,2512,2511,1,0,0,0,2513,2516,1,0,0,0,2514,2512,1,0,0,0,2514,2515,
  	1,0,0,0,2515,2538,1,0,0,0,2516,2514,1,0,0,0,2517,2518,5,241,0,0,2518,
  	2519,5,272,0,0,2519,2520,3,1346,673,0,2520,2524,3,126,63,0,2521,2523,
  	3,1176,588,0,2522,2521,1,0,0,0,2523,2526,1,0,0,0,2524,2522,1,0,0,0,2524,
  	2525,1,0,0,0,2525,2538,1,0,0,0,2526,2524,1,0,0,0,2527,2528,5,549,0,0,
  	2528,2529,5,272,0,0,2529,2530,3,1346,673,0,2530,2534,3,126,63,0,2531,
  	2533,3,1178,589,0,2532,2531,1,0,0,0,2533,2536,1,0,0,0,2534,2532,1,0,0,
  	0,2534,2535,1,0,0,0,2535,2538,1,0,0,0,2536,2534,1,0,0,0,2537,2503,1,0,
  	0,0,2537,2517,1,0,0,0,2537,2527,1,0,0,0,2538,2540,1,0,0,0,2539,2541,3,
  	48,24,0,2540,2539,1,0,0,0,2540,2541,1,0,0,0,2541,123,1,0,0,0,2542,2553,
  	3,1346,673,0,2543,2545,3,1346,673,0,2544,2543,1,0,0,0,2544,2545,1,0,0,
  	0,2545,2546,1,0,0,0,2546,2547,5,647,0,0,2547,2553,3,1166,583,0,2548,2549,
  	3,1346,673,0,2549,2550,5,625,0,0,2550,2551,3,1166,583,0,2551,2553,1,0,
  	0,0,2552,2542,1,0,0,0,2552,2544,1,0,0,0,2552,2548,1,0,0,0,2553,125,1,
  	0,0,0,2554,2555,5,413,0,0,2555,2556,3,1398,699,0,2556,2557,3,1162,581,
  	0,2557,127,1,0,0,0,2558,2559,5,320,0,0,2559,2560,5,253,0,0,2560,2561,
  	3,1376,688,0,2561,2562,5,50,0,0,2562,2563,5,629,0,0,2563,2565,3,1464,
  	732,0,2564,2566,3,130,65,0,2565,2564,1,0,0,0,2565,2566,1,0,0,0,2566,129,
  	1,0,0,0,2567,2574,3,132,66,0,2568,2570,5,29,0,0,2569,2568,1,0,0,0,2569,
  	2570,1,0,0,0,2570,2571,1,0,0,0,2571,2573,3,132,66,0,2572,2569,1,0,0,0,
  	2573,2576,1,0,0,0,2574,2572,1,0,0,0,2574,2575,1,0,0,0,2575,131,1,0,0,
  	0,2576,2574,1,0,0,0,2577,2584,3,154,77,0,2578,2584,3,156,78,0,2579,2584,
  	3,164,82,0,2580,2584,3,166,83,0,2581,2584,3,168,84,0,2582,2584,3,170,
  	85,0,2583,2577,1,0,0,0,2583,2578,1,0,0,0,2583,2579,1,0,0,0,2583,2580,
  	1,0,0,0,2583,2581,1,0,0,0,2583,2582,1,0,0,0,2584,133,1,0,0,0,2585,2586,
  	5,530,0,0,2586,2587,3,1386,693,0,2587,2588,5,235,0,0,2588,2589,5,154,
  	0,0,2589,2590,5,673,0,0,2590,2591,3,1486,743,0,2591,2592,3,136,68,0,2592,
  	135,1,0,0,0,2593,2594,5,420,0,0,2594,2595,5,32,0,0,2595,2600,3,138,69,
  	0,2596,2597,5,29,0,0,2597,2599,3,138,69,0,2598,2596,1,0,0,0,2599,2602,
  	1,0,0,0,2600,2598,1,0,0,0,2600,2601,1,0,0,0,2601,2603,1,0,0,0,2602,2600,
  	1,0,0,0,2603,2604,5,33,0,0,2604,137,1,0,0,0,2605,2606,5,260,0,0,2606,
  	2620,3,1464,732,0,2607,2608,5,151,0,0,2608,2620,3,1464,732,0,2609,2610,
  	5,644,0,0,2610,2620,3,1464,732,0,2611,2612,5,436,0,0,2612,2620,3,1464,
  	732,0,2613,2614,5,545,0,0,2614,2620,3,1464,732,0,2615,2616,5,428,0,0,
  	2616,2620,3,1464,732,0,2617,2618,5,443,0,0,2618,2620,3,1438,719,0,2619,
  	2605,1,0,0,0,2619,2607,1,0,0,0,2619,2609,1,0,0,0,2619,2611,1,0,0,0,2619,
  	2613,1,0,0,0,2619,2615,1,0,0,0,2619,2617,1,0,0,0,2620,139,1,0,0,0,2621,
  	2622,5,598,0,0,2622,2623,3,1372,686,0,2623,2628,3,146,73,0,2624,2625,
  	5,646,0,0,2625,2626,5,320,0,0,2626,2627,5,253,0,0,2627,2629,3,1378,689,
  	0,2628,2624,1,0,0,0,2628,2629,1,0,0,0,2629,2631,1,0,0,0,2630,2632,3,150,
  	75,0,2631,2630,1,0,0,0,2631,2632,1,0,0,0,2632,141,1,0,0,0,2633,2634,5,
  	631,0,0,2634,2635,5,598,0,0,2635,2636,3,1372,686,0,2636,2637,5,50,0,0,
  	2637,2639,3,148,74,0,2638,2640,3,60,30,0,2639,2638,1,0,0,0,2639,2640,
  	1,0,0,0,2640,143,1,0,0,0,2641,2643,5,837,0,0,2642,2644,3,1256,628,0,2643,
  	2642,1,0,0,0,2643,2644,1,0,0,0,2644,2645,1,0,0,0,2645,2646,3,1420,710,
  	0,2646,2647,5,301,0,0,2647,2648,3,1426,713,0,2648,2649,5,63,0,0,2649,
  	2650,3,104,52,0,2650,145,1,0,0,0,2651,2652,5,50,0,0,2652,2659,3,148,74,
  	0,2653,2656,4,73,43,0,2654,2655,5,50,0,0,2655,2657,3,148,74,0,2656,2654,
  	1,0,0,0,2656,2657,1,0,0,0,2657,2659,1,0,0,0,2658,2651,1,0,0,0,2658,2653,
  	1,0,0,0,2659,147,1,0,0,0,2660,2661,5,153,0,0,2661,2662,3,1464,732,0,2662,
  	149,1,0,0,0,2663,2670,3,152,76,0,2664,2666,5,29,0,0,2665,2664,1,0,0,0,
  	2665,2666,1,0,0,0,2666,2667,1,0,0,0,2667,2669,3,152,76,0,2668,2665,1,
  	0,0,0,2669,2672,1,0,0,0,2670,2668,1,0,0,0,2670,2671,1,0,0,0,2671,151,
  	1,0,0,0,2672,2670,1,0,0,0,2673,2686,3,154,77,0,2674,2686,3,158,79,0,2675,
  	2686,3,160,80,0,2676,2686,3,162,81,0,2677,2686,3,164,82,0,2678,2686,3,
  	166,83,0,2679,2686,3,168,84,0,2680,2686,3,170,85,0,2681,2682,4,76,44,
  	0,2682,2686,3,172,86,0,2683,2684,4,76,45,0,2684,2686,3,174,87,0,2685,
  	2673,1,0,0,0,2685,2674,1,0,0,0,2685,2675,1,0,0,0,2685,2676,1,0,0,0,2685,
  	2677,1,0,0,0,2685,2678,1,0,0,0,2685,2679,1,0,0,0,2685,2680,1,0,0,0,2685,
  	2681,1,0,0,0,2685,2683,1,0,0,0,2686,153,1,0,0,0,2687,2689,5,274,0,0,2688,
  	2690,5,6,0,0,2689,2688,1,0,0,0,2689,2690,1,0,0,0,2690,2691,1,0,0,0,2691,
  	2692,3,1492,746,0,2692,155,1,0,0,0,2693,2695,7,10,0,0,2694,2696,5,6,0,
  	0,2695,2694,1,0,0,0,2695,2696,1,0,0,0,2696,2697,1,0,0,0,2697,2698,3,1492,
  	746,0,2698,157,1,0,0,0,2699,2701,5,68,0,0,2700,2702,5,6,0,0,2701,2700,
  	1,0,0,0,2701,2702,1,0,0,0,2702,2703,1,0,0,0,2703,2704,3,1492,746,0,2704,
  	159,1,0,0,0,2705,2707,5,356,0,0,2706,2708,5,6,0,0,2707,2706,1,0,0,0,2707,
  	2708,1,0,0,0,2708,2709,1,0,0,0,2709,2710,3,1492,746,0,2710,161,1,0,0,
  	0,2711,2713,5,220,0,0,2712,2714,5,6,0,0,2713,2712,1,0,0,0,2713,2714,1,
  	0,0,0,2714,2715,1,0,0,0,2715,2716,3,1492,746,0,2716,163,1,0,0,0,2717,
  	2719,5,398,0,0,2718,2720,5,6,0,0,2719,2718,1,0,0,0,2719,2720,1,0,0,0,
  	2720,2721,1,0,0,0,2721,2722,3,1440,720,0,2722,165,1,0,0,0,2723,2725,5,
  	579,0,0,2724,2723,1,0,0,0,2724,2725,1,0,0,0,2725,2726,1,0,0,0,2726,2728,
  	5,202,0,0,2727,2729,5,6,0,0,2728,2727,1,0,0,0,2728,2729,1,0,0,0,2729,
  	2730,1,0,0,0,2730,2731,3,1390,695,0,2731,167,1,0,0,0,2732,2733,7,11,0,
  	0,2733,169,1,0,0,0,2734,2736,5,119,0,0,2735,2737,5,6,0,0,2736,2735,1,
  	0,0,0,2736,2737,1,0,0,0,2737,2738,1,0,0,0,2738,2739,3,1464,732,0,2739,
  	171,1,0,0,0,2740,2742,5,227,0,0,2741,2743,5,6,0,0,2742,2741,1,0,0,0,2742,
  	2743,1,0,0,0,2743,2744,1,0,0,0,2744,2745,3,1492,746,0,2745,173,1,0,0,
  	0,2746,2748,5,197,0,0,2747,2749,5,6,0,0,2748,2747,1,0,0,0,2748,2749,1,
  	0,0,0,2749,2750,1,0,0,0,2750,2751,3,1458,729,0,2751,175,1,0,0,0,2752,
  	2754,5,202,0,0,2753,2755,5,6,0,0,2754,2753,1,0,0,0,2754,2755,1,0,0,0,
  	2755,2756,1,0,0,0,2756,2757,3,1504,752,0,2757,177,1,0,0,0,2758,2760,3,
  	180,90,0,2759,2758,1,0,0,0,2759,2760,1,0,0,0,2760,2762,1,0,0,0,2761,2763,
  	3,1248,624,0,2762,2761,1,0,0,0,2762,2763,1,0,0,0,2763,2765,1,0,0,0,2764,
  	2766,3,184,92,0,2765,2764,1,0,0,0,2765,2766,1,0,0,0,2766,2767,1,0,0,0,
  	2767,2770,5,661,0,0,2768,2769,4,89,46,0,2769,2771,3,1256,628,0,2770,2768,
  	1,0,0,0,2770,2771,1,0,0,0,2771,2772,1,0,0,0,2772,2773,3,1368,684,0,2773,
  	2774,3,72,36,0,2774,179,1,0,0,0,2775,2776,5,424,0,0,2776,2778,5,488,0,
  	0,2777,2779,3,182,91,0,2778,2777,1,0,0,0,2778,2779,1,0,0,0,2779,2782,
  	1,0,0,0,2780,2782,3,182,91,0,2781,2775,1,0,0,0,2781,2780,1,0,0,0,2782,
  	181,1,0,0,0,2783,2784,5,55,0,0,2784,2785,5,6,0,0,2785,2786,7,12,0,0,2786,
  	183,1,0,0,0,2787,2788,5,563,0,0,2788,2789,5,523,0,0,2789,2790,7,9,0,0,
  	2790,185,1,0,0,0,2791,2793,3,1248,624,0,2792,2791,1,0,0,0,2792,2793,1,
  	0,0,0,2793,2794,1,0,0,0,2794,2797,5,620,0,0,2795,2796,4,93,47,0,2796,
  	2798,3,1256,628,0,2797,2795,1,0,0,0,2797,2798,1,0,0,0,2798,2799,1,0,0,
  	0,2799,2800,3,1364,682,0,2800,2801,7,13,0,0,2801,2802,7,14,0,0,2802,2803,
  	5,413,0,0,2803,2804,3,1398,699,0,2804,2805,5,236,0,0,2805,2806,5,192,
  	0,0,2806,2808,5,516,0,0,2807,2809,3,188,94,0,2808,2807,1,0,0,0,2808,2809,
  	1,0,0,0,2809,2810,1,0,0,0,2810,2811,3,1048,524,0,2811,187,1,0,0,0,2812,
  	2813,7,15,0,0,2813,2814,3,1486,743,0,2814,189,1,0,0,0,2815,2817,3,1248,
  	624,0,2816,2815,1,0,0,0,2816,2817,1,0,0,0,2817,2818,1,0,0,0,2818,2820,
  	5,209,0,0,2819,2821,3,1256,628,0,2820,2819,1,0,0,0,2820,2821,1,0,0,0,
  	2821,2822,1,0,0,0,2822,2823,3,1380,690,0,2823,2824,5,413,0,0,2824,2825,
  	5,519,0,0,2825,2832,3,1126,563,0,2826,2827,5,413,0,0,2827,2829,5,123,
  	0,0,2828,2830,5,401,0,0,2829,2828,1,0,0,0,2829,2830,1,0,0,0,2830,2831,
  	1,0,0,0,2831,2833,5,448,0,0,2832,2826,1,0,0,0,2832,2833,1,0,0,0,2833,
  	2840,1,0,0,0,2834,2841,5,195,0,0,2835,2838,5,180,0,0,2836,2837,5,413,
  	0,0,2837,2839,3,620,310,0,2838,2836,1,0,0,0,2838,2839,1,0,0,0,2839,2841,
  	1,0,0,0,2840,2834,1,0,0,0,2840,2835,1,0,0,0,2840,2841,1,0,0,0,2841,2844,
  	1,0,0,0,2842,2843,5,119,0,0,2843,2845,3,1464,732,0,2844,2842,1,0,0,0,
  	2844,2845,1,0,0,0,2845,2846,1,0,0,0,2846,2847,5,186,0,0,2847,2848,3,1048,
  	524,0,2848,191,1,0,0,0,2849,2851,5,684,0,0,2850,2852,3,1256,628,0,2851,
  	2850,1,0,0,0,2851,2852,1,0,0,0,2852,2853,1,0,0,0,2853,2854,3,696,348,
  	0,2854,193,1,0,0,0,2855,2856,5,424,0,0,2856,2857,5,488,0,0,2857,2858,
  	5,549,0,0,2858,2859,5,743,0,0,2859,2860,5,735,0,0,2860,2864,3,1444,722,
  	0,2861,2863,3,196,98,0,2862,2861,1,0,0,0,2863,2866,1,0,0,0,2864,2862,
  	1,0,0,0,2864,2865,1,0,0,0,2865,2881,1,0,0,0,2866,2864,1,0,0,0,2867,2868,
  	5,549,0,0,2868,2869,5,743,0,0,2869,2871,5,735,0,0,2870,2872,3,1256,628,
  	0,2871,2870,1,0,0,0,2871,2872,1,0,0,0,2872,2873,1,0,0,0,2873,2877,3,1444,
  	722,0,2874,2876,3,196,98,0,2875,2874,1,0,0,0,2876,2879,1,0,0,0,2877,2875,
  	1,0,0,0,2877,2878,1,0,0,0,2878,2881,1,0,0,0,2879,2877,1,0,0,0,2880,2855,
  	1,0,0,0,2880,2867,1,0,0,0,2881,195,1,0,0,0,2882,2883,5,388,0,0,2883,2884,
  	5,606,0,0,2884,2898,3,1466,733,0,2885,2886,5,740,0,0,2886,2887,5,606,
  	0,0,2887,2898,3,1466,733,0,2888,2889,5,742,0,0,2889,2890,3,1466,733,0,
  	2890,2891,5,266,0,0,2891,2892,5,90,0,0,2892,2893,3,1444,722,0,2893,2898,
  	1,0,0,0,2894,2895,5,741,0,0,2895,2896,5,606,0,0,2896,2898,3,1466,733,
  	0,2897,2882,1,0,0,0,2897,2885,1,0,0,0,2897,2888,1,0,0,0,2897,2894,1,0,
  	0,0,2898,197,1,0,0,0,2899,2919,5,187,0,0,2900,2920,3,200,100,0,2901,2920,
  	3,202,101,0,2902,2920,3,204,102,0,2903,2920,3,206,103,0,2904,2920,3,208,
  	104,0,2905,2920,3,210,105,0,2906,2920,3,214,107,0,2907,2920,3,216,108,
  	0,2908,2920,3,218,109,0,2909,2920,3,220,110,0,2910,2920,3,222,111,0,2911,
  	2912,4,99,48,0,2912,2920,3,224,112,0,2913,2914,4,99,49,0,2914,2920,3,
  	226,113,0,2915,2916,4,99,50,0,2916,2920,3,228,114,0,2917,2918,4,99,51,
  	0,2918,2920,3,230,115,0,2919,2900,1,0,0,0,2919,2901,1,0,0,0,2919,2902,
  	1,0,0,0,2919,2903,1,0,0,0,2919,2904,1,0,0,0,2919,2905,1,0,0,0,2919,2906,
  	1,0,0,0,2919,2907,1,0,0,0,2919,2908,1,0,0,0,2919,2909,1,0,0,0,2919,2910,
  	1,0,0,0,2919,2911,1,0,0,0,2919,2913,1,0,0,0,2919,2915,1,0,0,0,2919,2917,
  	1,0,0,0,2920,199,1,0,0,0,2921,2923,5,151,0,0,2922,2924,3,1250,625,0,2923,
  	2922,1,0,0,0,2923,2924,1,0,0,0,2924,2925,1,0,0,0,2925,2926,3,1354,677,
  	0,2926,201,1,0,0,0,2927,2929,5,209,0,0,2928,2930,3,1250,625,0,2929,2928,
  	1,0,0,0,2929,2930,1,0,0,0,2930,2931,1,0,0,0,2931,2932,3,1382,691,0,2932,
  	203,1,0,0,0,2933,2935,5,242,0,0,2934,2936,3,1250,625,0,2935,2934,1,0,
  	0,0,2935,2936,1,0,0,0,2936,2937,1,0,0,0,2937,2938,3,1362,681,0,2938,205,
  	1,0,0,0,2939,2941,5,452,0,0,2940,2942,3,1250,625,0,2941,2940,1,0,0,0,
  	2941,2942,1,0,0,0,2942,2943,1,0,0,0,2943,2944,3,1358,679,0,2944,207,1,
  	0,0,0,2945,2947,3,1328,664,0,2946,2945,1,0,0,0,2946,2947,1,0,0,0,2947,
  	2948,1,0,0,0,2948,2949,5,272,0,0,2949,2950,3,1348,674,0,2950,2951,5,413,
  	0,0,2951,2953,3,1398,699,0,2952,2954,3,48,24,0,2953,2952,1,0,0,0,2953,
  	2954,1,0,0,0,2954,209,1,0,0,0,2955,2956,5,320,0,0,2956,2957,5,253,0,0,
  	2957,2968,3,1378,689,0,2958,2965,3,212,106,0,2959,2961,5,29,0,0,2960,
  	2959,1,0,0,0,2960,2961,1,0,0,0,2961,2962,1,0,0,0,2962,2964,3,212,106,
  	0,2963,2960,1,0,0,0,2964,2967,1,0,0,0,2965,2963,1,0,0,0,2965,2966,1,0,
  	0,0,2966,2969,1,0,0,0,2967,2965,1,0,0,0,2968,2958,1,0,0,0,2968,2969,1,
  	0,0,0,2969,211,1,0,0,0,2970,2973,3,168,84,0,2971,2973,3,166,83,0,2972,
  	2970,1,0,0,0,2972,2971,1,0,0,0,2973,213,1,0,0,0,2974,2976,5,530,0,0,2975,
  	2977,3,1250,625,0,2976,2975,1,0,0,0,2976,2977,1,0,0,0,2977,2978,1,0,0,
  	0,2978,2979,3,1388,694,0,2979,215,1,0,0,0,2980,2982,5,603,0,0,2981,2980,
  	1,0,0,0,2981,2982,1,0,0,0,2982,2983,1,0,0,0,2983,2985,7,16,0,0,2984,2986,
  	3,1250,625,0,2985,2984,1,0,0,0,2985,2986,1,0,0,0,2986,2987,1,0,0,0,2987,
  	2989,3,1400,700,0,2988,2990,7,1,0,0,2989,2988,1,0,0,0,2989,2990,1,0,0,
  	0,2990,217,1,0,0,0,2991,2992,5,598,0,0,2992,3003,3,1374,687,0,2993,3000,
  	3,212,106,0,2994,2996,5,29,0,0,2995,2994,1,0,0,0,2995,2996,1,0,0,0,2996,
  	2997,1,0,0,0,2997,2999,3,212,106,0,2998,2995,1,0,0,0,2999,3002,1,0,0,
  	0,3000,2998,1,0,0,0,3000,3001,1,0,0,0,3001,3004,1,0,0,0,3002,3000,1,0,
  	0,0,3003,2993,1,0,0,0,3003,3004,1,0,0,0,3004,219,1,0,0,0,3005,3007,5,
  	620,0,0,3006,3008,3,1250,625,0,3007,3006,1,0,0,0,3007,3008,1,0,0,0,3008,
  	3009,1,0,0,0,3009,3010,3,1366,683,0,3010,221,1,0,0,0,3011,3013,5,661,
  	0,0,3012,3014,3,1250,625,0,3013,3012,1,0,0,0,3013,3014,1,0,0,0,3014,3015,
  	1,0,0,0,3015,3017,3,1270,635,0,3016,3018,7,1,0,0,3017,3016,1,0,0,0,3017,
  	3018,1,0,0,0,3018,223,1,0,0,0,3019,3021,5,684,0,0,3020,3022,3,1250,625,
  	0,3021,3020,1,0,0,0,3021,3022,1,0,0,0,3022,3023,1,0,0,0,3023,3024,3,696,
  	348,0,3024,225,1,0,0,0,3025,3026,5,549,0,0,3026,3027,5,743,0,0,3027,3029,
  	5,735,0,0,3028,3030,3,1250,625,0,3029,3028,1,0,0,0,3029,3030,1,0,0,0,
  	3030,3031,1,0,0,0,3031,3032,3,1444,722,0,3032,227,1,0,0,0,3033,3034,5,
  	631,0,0,3034,3035,5,598,0,0,3035,3037,3,1374,687,0,3036,3038,3,60,30,
  	0,3037,3036,1,0,0,0,3037,3038,1,0,0,0,3038,229,1,0,0,0,3039,3040,5,187,
  	0,0,3040,3042,5,837,0,0,3041,3043,3,1250,625,0,3042,3041,1,0,0,0,3042,
  	3043,1,0,0,0,3043,3044,1,0,0,0,3044,3045,3,1422,711,0,3045,231,1,0,0,
  	0,3046,3047,5,483,0,0,3047,3048,7,16,0,0,3048,3053,3,234,117,0,3049,3050,
  	5,29,0,0,3050,3052,3,234,117,0,3051,3049,1,0,0,0,3052,3055,1,0,0,0,3053,
  	3051,1,0,0,0,3053,3054,1,0,0,0,3054,233,1,0,0,0,3055,3053,1,0,0,0,3056,
  	3057,3,1398,699,0,3057,3058,5,616,0,0,3058,3059,3,1392,696,0,3059,235,
  	1,0,0,0,3060,3062,5,623,0,0,3061,3063,5,600,0,0,3062,3061,1,0,0,0,3062,
  	3063,1,0,0,0,3063,3064,1,0,0,0,3064,3065,3,1398,699,0,3065,237,1,0,0,
  	0,3066,3067,5,270,0,0,3067,3068,5,600,0,0,3068,3069,5,239,0,0,3069,3070,
  	3,1468,734,0,3070,239,1,0,0,0,3071,3072,5,93,0,0,3072,3078,3,1358,679,
  	0,3073,3075,5,32,0,0,3074,3076,3,1020,510,0,3075,3074,1,0,0,0,3075,3076,
  	1,0,0,0,3076,3077,1,0,0,0,3077,3079,5,33,0,0,3078,3073,1,0,0,0,3078,3079,
  	1,0,0,0,3079,241,1,0,0,0,3080,3081,4,121,52,0,3081,3083,3,370,185,0,3082,
  	3080,1,0,0,0,3082,3083,1,0,0,0,3083,3084,1,0,0,0,3084,3088,5,173,0,0,
  	3085,3087,3,246,123,0,3086,3085,1,0,0,0,3087,3090,1,0,0,0,3088,3086,1,
  	0,0,0,3088,3089,1,0,0,0,3089,3123,1,0,0,0,3090,3088,1,0,0,0,3091,3115,
  	5,239,0,0,3092,3093,3,1402,701,0,3093,3094,5,647,0,0,3094,3096,3,384,
  	192,0,3095,3097,3,408,204,0,3096,3095,1,0,0,0,3096,3097,1,0,0,0,3097,
  	3116,1,0,0,0,3098,3101,3,1398,699,0,3099,3100,4,121,53,0,3100,3102,3,
  	450,225,0,3101,3099,1,0,0,0,3101,3102,1,0,0,0,3102,3104,1,0,0,0,3103,
  	3105,3,244,122,0,3104,3103,1,0,0,0,3104,3105,1,0,0,0,3105,3107,1,0,0,
  	0,3106,3108,3,408,204,0,3107,3106,1,0,0,0,3107,3108,1,0,0,0,3108,3110,
  	1,0,0,0,3109,3111,3,378,189,0,3110,3109,1,0,0,0,3110,3111,1,0,0,0,3111,
  	3113,1,0,0,0,3112,3114,3,326,163,0,3113,3112,1,0,0,0,3113,3114,1,0,0,
  	0,3114,3116,1,0,0,0,3115,3092,1,0,0,0,3115,3098,1,0,0,0,3116,3124,1,0,
  	0,0,3117,3118,3,1402,701,0,3118,3119,5,239,0,0,3119,3121,3,384,192,0,
  	3120,3122,3,408,204,0,3121,3120,1,0,0,0,3121,3122,1,0,0,0,3122,3124,1,
  	0,0,0,3123,3091,1,0,0,0,3123,3117,1,0,0,0,3124,243,1,0,0,0,3125,3126,
  	5,435,0,0,3126,3127,5,32,0,0,3127,3128,3,1428,714,0,3128,3129,5,33,0,
  	0,3129,245,1,0,0,0,3130,3131,7,17,0,0,3131,247,1,0,0,0,3132,3137,5,186,
  	0,0,3133,3134,4,124,54,0,3134,3138,3,1020,510,0,3135,3136,4,124,55,0,
  	3136,3138,3,402,201,0,3137,3133,1,0,0,0,3137,3135,1,0,0,0,3138,249,1,
  	0,0,0,3139,3157,5,255,0,0,3140,3141,3,1398,699,0,3141,3143,5,417,0,0,
  	3142,3144,3,450,225,0,3143,3142,1,0,0,0,3143,3144,1,0,0,0,3144,3158,1,
  	0,0,0,3145,3155,3,1426,713,0,3146,3156,5,110,0,0,3147,3148,5,465,0,0,
  	3148,3150,3,252,126,0,3149,3151,3,408,204,0,3150,3149,1,0,0,0,3150,3151,
  	1,0,0,0,3151,3153,1,0,0,0,3152,3154,3,324,162,0,3153,3152,1,0,0,0,3153,
  	3154,1,0,0,0,3154,3156,1,0,0,0,3155,3146,1,0,0,0,3155,3147,1,0,0,0,3156,
  	3158,1,0,0,0,3157,3140,1,0,0,0,3157,3145,1,0,0,0,3158,251,1,0,0,0,3159,
  	3170,7,18,0,0,3160,3167,3,1426,713,0,3161,3168,7,19,0,0,3162,3163,7,20,
  	0,0,3163,3164,5,32,0,0,3164,3165,3,268,134,0,3165,3166,5,33,0,0,3166,
  	3168,1,0,0,0,3167,3161,1,0,0,0,3167,3162,1,0,0,0,3168,3170,1,0,0,0,3169,
  	3159,1,0,0,0,3169,3160,1,0,0,0,3170,253,1,0,0,0,3171,3173,5,278,0,0,3172,
  	3174,3,256,128,0,3173,3172,1,0,0,0,3173,3174,1,0,0,0,3174,3176,1,0,0,
  	0,3175,3177,5,268,0,0,3176,3175,1,0,0,0,3176,3177,1,0,0,0,3177,3179,1,
  	0,0,0,3178,3180,5,283,0,0,3179,3178,1,0,0,0,3179,3180,1,0,0,0,3180,3181,
  	1,0,0,0,3181,3183,3,1398,699,0,3182,3184,3,1332,666,0,3183,3182,1,0,0,
  	0,3183,3184,1,0,0,0,3184,3195,1,0,0,0,3185,3187,3,258,129,0,3186,3188,
  	3,270,135,0,3187,3186,1,0,0,0,3187,3188,1,0,0,0,3188,3196,1,0,0,0,3189,
  	3190,5,533,0,0,3190,3192,3,1272,636,0,3191,3193,3,270,135,0,3192,3191,
  	1,0,0,0,3192,3193,1,0,0,0,3193,3196,1,0,0,0,3194,3196,3,264,132,0,3195,
  	3185,1,0,0,0,3195,3189,1,0,0,0,3195,3194,1,0,0,0,3196,3198,1,0,0,0,3197,
  	3199,3,272,136,0,3198,3197,1,0,0,0,3198,3199,1,0,0,0,3199,255,1,0,0,0,
  	3200,3201,7,21,0,0,3201,257,1,0,0,0,3202,3204,5,32,0,0,3203,3205,3,260,
  	130,0,3204,3203,1,0,0,0,3204,3205,1,0,0,0,3205,3206,1,0,0,0,3206,3208,
  	5,33,0,0,3207,3202,1,0,0,0,3207,3208,1,0,0,0,3208,3209,1,0,0,0,3209,3210,
  	3,262,131,0,3210,259,1,0,0,0,3211,3216,3,1344,672,0,3212,3213,5,29,0,
  	0,3213,3215,3,1344,672,0,3214,3212,1,0,0,0,3215,3218,1,0,0,0,3216,3214,
  	1,0,0,0,3216,3217,1,0,0,0,3217,261,1,0,0,0,3218,3216,1,0,0,0,3219,3220,
  	7,22,0,0,3220,3221,3,266,133,0,3221,263,1,0,0,0,3222,3233,3,310,155,0,
  	3223,3233,3,314,157,0,3224,3226,5,32,0,0,3225,3227,3,260,130,0,3226,3225,
  	1,0,0,0,3226,3227,1,0,0,0,3227,3228,1,0,0,0,3228,3230,5,33,0,0,3229,3224,
  	1,0,0,0,3229,3230,1,0,0,0,3230,3231,1,0,0,0,3231,3233,3,98,49,0,3232,
  	3222,1,0,0,0,3232,3223,1,0,0,0,3232,3229,1,0,0,0,3233,265,1,0,0,0,3234,
  	3236,5,32,0,0,3235,3237,3,268,134,0,3236,3235,1,0,0,0,3236,3237,1,0,0,
  	0,3237,3238,1,0,0,0,3238,3247,5,33,0,0,3239,3240,5,29,0,0,3240,3242,5,
  	32,0,0,3241,3243,3,268,134,0,3242,3241,1,0,0,0,3242,3243,1,0,0,0,3243,
  	3244,1,0,0,0,3244,3246,5,33,0,0,3245,3239,1,0,0,0,3246,3249,1,0,0,0,3247,
  	3245,1,0,0,0,3247,3248,1,0,0,0,3248,267,1,0,0,0,3249,3247,1,0,0,0,3250,
  	3253,3,924,462,0,3251,3253,5,168,0,0,3252,3250,1,0,0,0,3252,3251,1,0,
  	0,0,3253,3261,1,0,0,0,3254,3257,5,29,0,0,3255,3258,3,924,462,0,3256,3258,
  	5,168,0,0,3257,3255,1,0,0,0,3257,3256,1,0,0,0,3258,3260,1,0,0,0,3259,
  	3254,1,0,0,0,3260,3263,1,0,0,0,3261,3259,1,0,0,0,3261,3262,1,0,0,0,3262,
  	269,1,0,0,0,3263,3261,1,0,0,0,3264,3265,4,135,56,0,3265,3266,5,63,0,0,
  	3266,3268,3,1426,713,0,3267,3269,3,1340,670,0,3268,3267,1,0,0,0,3268,
  	3269,1,0,0,0,3269,271,1,0,0,0,3270,3271,5,413,0,0,3271,3272,5,190,0,0,
  	3272,3273,5,299,0,0,3273,3274,5,640,0,0,3274,3275,3,1272,636,0,3275,273,
  	1,0,0,0,3276,3277,5,315,0,0,3277,3279,3,276,138,0,3278,3280,3,278,139,
  	0,3279,3278,1,0,0,0,3279,3280,1,0,0,0,3280,3282,1,0,0,0,3281,3283,3,280,
  	140,0,3282,3281,1,0,0,0,3282,3283,1,0,0,0,3283,3285,1,0,0,0,3284,3286,
  	5,316,0,0,3285,3284,1,0,0,0,3285,3286,1,0,0,0,3286,3288,1,0,0,0,3287,
  	3289,3,282,141,0,3288,3287,1,0,0,0,3288,3289,1,0,0,0,3289,3290,1,0,0,
  	0,3290,3292,3,1458,729,0,3291,3293,3,284,142,0,3292,3291,1,0,0,0,3292,
  	3293,1,0,0,0,3293,3295,1,0,0,0,3294,3296,3,286,143,0,3295,3294,1,0,0,
  	0,3295,3296,1,0,0,0,3296,3298,1,0,0,0,3297,3299,7,7,0,0,3298,3297,1,0,
  	0,0,3298,3299,1,0,0,0,3299,3300,1,0,0,0,3300,3301,5,283,0,0,3301,3302,
  	5,600,0,0,3302,3304,3,1398,699,0,3303,3305,3,1332,666,0,3304,3303,1,0,
  	0,0,3304,3305,1,0,0,0,3305,3308,1,0,0,0,3306,3307,4,137,57,0,3307,3309,
  	3,298,149,0,3308,3306,1,0,0,0,3308,3309,1,0,0,0,3309,3311,1,0,0,0,3310,
  	3312,3,1276,638,0,3311,3310,1,0,0,0,3311,3312,1,0,0,0,3312,3314,1,0,0,
  	0,3313,3315,3,288,144,0,3314,3313,1,0,0,0,3314,3315,1,0,0,0,3315,3317,
  	1,0,0,0,3316,3318,3,1278,639,0,3317,3316,1,0,0,0,3317,3318,1,0,0,0,3318,
  	3320,1,0,0,0,3319,3321,3,1282,641,0,3320,3319,1,0,0,0,3320,3321,1,0,0,
  	0,3321,3322,1,0,0,0,3322,3324,3,290,145,0,3323,3325,3,300,150,0,3324,
  	3323,1,0,0,0,3324,3325,1,0,0,0,3325,3327,1,0,0,0,3326,3328,3,302,151,
  	0,3327,3326,1,0,0,0,3327,3328,1,0,0,0,3328,3330,1,0,0,0,3329,3331,3,296,
  	148,0,3330,3329,1,0,0,0,3330,3331,1,0,0,0,3331,275,1,0,0,0,3332,3333,
  	7,23,0,0,3333,277,1,0,0,0,3334,3335,7,24,0,0,3335,279,1,0,0,0,3336,3337,
  	4,140,58,0,3337,3338,5,239,0,0,3338,281,1,0,0,0,3339,3343,5,273,0,0,3340,
  	3341,4,141,59,0,3341,3343,7,25,0,0,3342,3339,1,0,0,0,3342,3340,1,0,0,
  	0,3343,283,1,0,0,0,3344,3351,4,142,60,0,3345,3346,4,142,61,0,3346,3347,
  	5,138,0,0,3347,3352,5,3,0,0,3348,3349,3,1424,712,0,3349,3350,5,3,0,0,
  	3350,3352,1,0,0,0,3351,3345,1,0,0,0,3351,3348,1,0,0,0,3352,285,1,0,0,
  	0,3353,3354,4,143,62,0,3354,3355,5,286,0,0,3355,3356,5,450,0,0,3356,3357,
  	5,299,0,0,3357,3358,5,423,0,0,3358,287,1,0,0,0,3359,3360,5,513,0,0,3360,
  	3361,5,266,0,0,3361,3362,5,90,0,0,3362,3363,3,1460,730,0,3363,289,1,0,
  	0,0,3364,3365,5,268,0,0,3365,3366,5,3,0,0,3366,3368,7,26,0,0,3367,3364,
  	1,0,0,0,3367,3368,1,0,0,0,3368,3370,1,0,0,0,3369,3371,3,292,146,0,3370,
  	3369,1,0,0,0,3370,3371,1,0,0,0,3371,3374,1,0,0,0,3372,3373,5,533,0,0,
  	3373,3375,3,1272,636,0,3374,3372,1,0,0,0,3374,3375,1,0,0,0,3375,291,1,
  	0,0,0,3376,3378,5,32,0,0,3377,3379,3,294,147,0,3378,3377,1,0,0,0,3378,
  	3379,1,0,0,0,3379,3380,1,0,0,0,3380,3381,5,33,0,0,3381,293,1,0,0,0,3382,
  	3385,3,1342,671,0,3383,3385,3,1000,500,0,3384,3382,1,0,0,0,3384,3383,
  	1,0,0,0,3385,3393,1,0,0,0,3386,3389,5,29,0,0,3387,3390,3,1342,671,0,3388,
  	3390,3,1000,500,0,3389,3387,1,0,0,0,3389,3388,1,0,0,0,3390,3392,1,0,0,
  	0,3391,3386,1,0,0,0,3392,3395,1,0,0,0,3393,3391,1,0,0,0,3393,3394,1,0,
  	0,0,3394,295,1,0,0,0,3395,3393,1,0,0,0,3396,3397,4,148,63,0,3397,3398,
  	5,55,0,0,3398,3399,5,6,0,0,3399,3400,5,821,0,0,3400,297,1,0,0,0,3401,
  	3402,4,149,64,0,3402,3403,5,125,0,0,3403,3404,5,6,0,0,3404,3405,3,1458,
  	729,0,3405,299,1,0,0,0,3406,3407,4,150,65,0,3407,3408,5,827,0,0,3408,
  	3409,5,6,0,0,3409,3410,5,3,0,0,3410,301,1,0,0,0,3411,3412,4,151,66,0,
  	3412,3413,5,366,0,0,3413,3414,5,6,0,0,3414,3415,3,1492,746,0,3415,303,
  	1,0,0,0,3416,3418,5,488,0,0,3417,3419,7,27,0,0,3418,3417,1,0,0,0,3418,
  	3419,1,0,0,0,3419,3421,1,0,0,0,3420,3422,5,283,0,0,3421,3420,1,0,0,0,
  	3421,3422,1,0,0,0,3422,3423,1,0,0,0,3423,3425,3,1398,699,0,3424,3426,
  	3,1332,666,0,3425,3424,1,0,0,0,3425,3426,1,0,0,0,3426,3431,1,0,0,0,3427,
  	3432,3,258,129,0,3428,3429,5,533,0,0,3429,3432,3,1272,636,0,3430,3432,
  	3,264,132,0,3431,3427,1,0,0,0,3431,3428,1,0,0,0,3431,3430,1,0,0,0,3432,
  	305,1,0,0,0,3433,3435,3,310,155,0,3434,3436,3,394,197,0,3435,3434,1,0,
  	0,0,3435,3436,1,0,0,0,3436,3439,1,0,0,0,3437,3439,3,308,154,0,3438,3433,
  	1,0,0,0,3438,3437,1,0,0,0,3439,307,1,0,0,0,3440,3441,5,32,0,0,3441,3442,
  	3,308,154,0,3442,3443,5,33,0,0,3443,3458,1,0,0,0,3444,3445,3,310,155,
  	0,3445,3447,3,340,170,0,3446,3448,3,394,197,0,3447,3446,1,0,0,0,3447,
  	3448,1,0,0,0,3448,3458,1,0,0,0,3449,3450,3,310,155,0,3450,3451,3,394,
  	197,0,3451,3452,3,340,170,0,3452,3458,1,0,0,0,3453,3454,4,154,67,0,3454,
  	3455,3,314,157,0,3455,3456,3,340,170,0,3456,3458,1,0,0,0,3457,3440,1,
  	0,0,0,3457,3444,1,0,0,0,3457,3449,1,0,0,0,3457,3453,1,0,0,0,3458,309,
  	1,0,0,0,3459,3460,4,155,68,0,3460,3462,3,370,185,0,3461,3459,1,0,0,0,
  	3461,3462,1,0,0,0,3462,3463,1,0,0,0,3463,3465,3,312,156,0,3464,3466,3,
  	378,189,0,3465,3464,1,0,0,0,3465,3466,1,0,0,0,3466,3468,1,0,0,0,3467,
  	3469,3,324,162,0,3468,3467,1,0,0,0,3468,3469,1,0,0,0,3469,3472,1,0,0,
  	0,3470,3471,4,155,69,0,3471,3473,3,342,171,0,3472,3470,1,0,0,0,3472,3473,
  	1,0,0,0,3473,311,1,0,0,0,3474,3477,3,316,158,0,3475,3477,3,314,157,0,
  	3476,3474,1,0,0,0,3476,3475,1,0,0,0,3477,3489,1,0,0,0,3478,3482,5,634,
  	0,0,3479,3480,4,156,70,0,3480,3482,7,28,0,0,3481,3478,1,0,0,0,3481,3479,
  	1,0,0,0,3482,3484,1,0,0,0,3483,3485,3,448,224,0,3484,3483,1,0,0,0,3484,
  	3485,1,0,0,0,3485,3486,1,0,0,0,3486,3488,3,312,156,0,3487,3481,1,0,0,
  	0,3488,3491,1,0,0,0,3489,3487,1,0,0,0,3489,3490,1,0,0,0,3490,313,1,0,
  	0,0,3491,3489,1,0,0,0,3492,3495,5,32,0,0,3493,3496,3,314,157,0,3494,3496,
  	3,98,49,0,3495,3493,1,0,0,0,3495,3494,1,0,0,0,3496,3497,1,0,0,0,3497,
  	3498,5,33,0,0,3498,315,1,0,0,0,3499,3505,3,318,159,0,3500,3501,4,158,
  	71,0,3501,3505,3,386,193,0,3502,3503,4,158,72,0,3503,3505,3,388,194,0,
  	3504,3499,1,0,0,0,3504,3500,1,0,0,0,3504,3502,1,0,0,0,3505,317,1,0,0,
  	0,3506,3510,5,524,0,0,3507,3509,3,392,196,0,3508,3507,1,0,0,0,3509,3512,
  	1,0,0,0,3510,3508,1,0,0,0,3510,3511,1,0,0,0,3511,3513,1,0,0,0,3512,3510,
  	1,0,0,0,3513,3515,3,402,201,0,3514,3516,3,340,170,0,3515,3514,1,0,0,0,
  	3515,3516,1,0,0,0,3516,3518,1,0,0,0,3517,3519,3,382,191,0,3518,3517,1,
  	0,0,0,3518,3519,1,0,0,0,3519,3521,1,0,0,0,3520,3522,3,408,204,0,3521,
  	3520,1,0,0,0,3521,3522,1,0,0,0,3522,3524,1,0,0,0,3523,3525,3,374,187,
  	0,3524,3523,1,0,0,0,3524,3525,1,0,0,0,3525,3527,1,0,0,0,3526,3528,3,344,
  	172,0,3527,3526,1,0,0,0,3527,3528,1,0,0,0,3528,3531,1,0,0,0,3529,3530,
  	4,159,73,0,3530,3532,3,348,174,0,3531,3529,1,0,0,0,3531,3532,1,0,0,0,
  	3532,3534,1,0,0,0,3533,3535,3,346,173,0,3534,3533,1,0,0,0,3534,3535,1,
  	0,0,0,3535,319,1,0,0,0,3536,3537,3,314,157,0,3537,321,1,0,0,0,3538,3539,
  	7,29,0,0,3539,323,1,0,0,0,3540,3541,5,310,0,0,3541,3542,3,328,164,0,3542,
  	325,1,0,0,0,3543,3544,5,310,0,0,3544,3545,3,330,165,0,3545,327,1,0,0,
  	0,3546,3549,3,330,165,0,3547,3548,7,30,0,0,3548,3550,3,330,165,0,3549,
  	3547,1,0,0,0,3549,3550,1,0,0,0,3550,329,1,0,0,0,3551,3554,3,1426,713,
  	0,3552,3554,7,31,0,0,3553,3551,1,0,0,0,3553,3552,1,0,0,0,3554,331,1,0,
  	0,0,3555,3556,5,822,0,0,3556,3557,3,1460,730,0,3557,333,1,0,0,0,3558,
  	3559,3,336,168,0,3559,335,1,0,0,0,3560,3562,3,338,169,0,3561,3560,1,0,
  	0,0,3562,3563,1,0,0,0,3563,3561,1,0,0,0,3563,3564,1,0,0,0,3564,337,1,
  	0,0,0,3565,3566,5,237,0,0,3566,3575,3,1426,713,0,3567,3568,5,125,0,0,
  	3568,3575,3,1460,730,0,3569,3570,5,836,0,0,3570,3575,5,413,0,0,3571,3572,
  	5,836,0,0,3572,3575,5,769,0,0,3573,3575,3,1276,638,0,3574,3565,1,0,0,
  	0,3574,3567,1,0,0,0,3574,3569,1,0,0,0,3574,3571,1,0,0,0,3574,3573,1,0,
  	0,0,3575,339,1,0,0,0,3576,3619,5,283,0,0,3577,3595,5,426,0,0,3578,3579,
  	4,170,74,0,3579,3581,3,1458,729,0,3580,3582,3,1276,638,0,3581,3580,1,
  	0,0,0,3581,3582,1,0,0,0,3582,3596,1,0,0,0,3583,3586,4,170,75,0,3584,3587,
  	3,1458,729,0,3585,3587,3,332,166,0,3586,3584,1,0,0,0,3586,3585,1,0,0,
  	0,3587,3589,1,0,0,0,3588,3590,3,334,167,0,3589,3588,1,0,0,0,3589,3590,
  	1,0,0,0,3590,3596,1,0,0,0,3591,3592,4,170,76,0,3592,3593,5,670,0,0,3593,
  	3594,5,835,0,0,3594,3596,3,1504,752,0,3595,3578,1,0,0,0,3595,3583,1,0,
  	0,0,3595,3591,1,0,0,0,3596,3598,1,0,0,0,3597,3599,3,1278,639,0,3598,3597,
  	1,0,0,0,3598,3599,1,0,0,0,3599,3601,1,0,0,0,3600,3602,3,1282,641,0,3601,
  	3600,1,0,0,0,3601,3602,1,0,0,0,3602,3620,1,0,0,0,3603,3604,5,189,0,0,
  	3604,3620,3,1458,729,0,3605,3608,3,1486,743,0,3606,3608,3,1000,500,0,
  	3607,3605,1,0,0,0,3607,3606,1,0,0,0,3608,3616,1,0,0,0,3609,3612,5,29,
  	0,0,3610,3613,3,1486,743,0,3611,3613,3,1000,500,0,3612,3610,1,0,0,0,3612,
  	3611,1,0,0,0,3613,3615,1,0,0,0,3614,3609,1,0,0,0,3615,3618,1,0,0,0,3616,
  	3614,1,0,0,0,3616,3617,1,0,0,0,3617,3620,1,0,0,0,3618,3616,1,0,0,0,3619,
  	3577,1,0,0,0,3619,3603,1,0,0,0,3619,3607,1,0,0,0,3620,341,1,0,0,0,3621,
  	3622,5,452,0,0,3622,3623,5,59,0,0,3623,3629,5,32,0,0,3624,3627,5,3,0,
  	0,3625,3626,5,29,0,0,3626,3628,5,3,0,0,3627,3625,1,0,0,0,3627,3628,1,
  	0,0,0,3628,3630,1,0,0,0,3629,3624,1,0,0,0,3629,3630,1,0,0,0,3630,3631,
  	1,0,0,0,3631,3632,5,33,0,0,3632,343,1,0,0,0,3633,3634,5,257,0,0,3634,
  	3635,3,924,462,0,3635,345,1,0,0,0,3636,3637,4,173,77,0,3637,3638,5,829,
  	0,0,3638,3639,3,924,462,0,3639,347,1,0,0,0,3640,3641,5,724,0,0,3641,3646,
  	3,350,175,0,3642,3643,5,29,0,0,3643,3645,3,350,175,0,3644,3642,1,0,0,
  	0,3645,3648,1,0,0,0,3646,3644,1,0,0,0,3646,3647,1,0,0,0,3647,349,1,0,
  	0,0,3648,3646,1,0,0,0,3649,3650,3,1418,709,0,3650,3651,5,63,0,0,3651,
  	3652,3,352,176,0,3652,351,1,0,0,0,3653,3654,5,32,0,0,3654,3655,3,354,
  	177,0,3655,3656,5,33,0,0,3656,353,1,0,0,0,3657,3659,3,1418,709,0,3658,
  	3657,1,0,0,0,3658,3659,1,0,0,0,3659,3663,1,0,0,0,3660,3661,5,435,0,0,
  	3661,3662,5,90,0,0,3662,3664,3,1038,519,0,3663,3660,1,0,0,0,3663,3664,
  	1,0,0,0,3664,3666,1,0,0,0,3665,3667,3,378,189,0,3666,3665,1,0,0,0,3666,
  	3667,1,0,0,0,3667,3669,1,0,0,0,3668,3670,3,356,178,0,3669,3668,1,0,0,
  	0,3669,3670,1,0,0,0,3670,355,1,0,0,0,3671,3672,3,358,179,0,3672,3674,
  	3,360,180,0,3673,3675,3,368,184,0,3674,3673,1,0,0,0,3674,3675,1,0,0,0,
  	3675,357,1,0,0,0,3676,3677,7,32,0,0,3677,359,1,0,0,0,3678,3681,3,362,
  	181,0,3679,3681,3,364,182,0,3680,3678,1,0,0,0,3680,3679,1,0,0,0,3681,
  	361,1,0,0,0,3682,3683,5,723,0,0,3683,3697,5,718,0,0,3684,3685,3,1442,
  	721,0,3685,3686,5,718,0,0,3686,3697,1,0,0,0,3687,3688,5,42,0,0,3688,3697,
  	5,718,0,0,3689,3690,5,282,0,0,3690,3691,3,924,462,0,3691,3692,3,1028,
  	514,0,3692,3693,5,718,0,0,3693,3697,1,0,0,0,3694,3695,5,144,0,0,3695,
  	3697,5,516,0,0,3696,3682,1,0,0,0,3696,3684,1,0,0,0,3696,3687,1,0,0,0,
  	3696,3689,1,0,0,0,3696,3694,1,0,0,0,3697,363,1,0,0,0,3698,3699,5,75,0,
  	0,3699,3700,3,366,183,0,3700,3701,5,61,0,0,3701,3702,3,366,183,0,3702,
  	365,1,0,0,0,3703,3717,3,362,181,0,3704,3705,5,723,0,0,3705,3717,5,707,
  	0,0,3706,3707,3,1442,721,0,3707,3708,5,707,0,0,3708,3717,1,0,0,0,3709,
  	3710,5,42,0,0,3710,3717,5,707,0,0,3711,3712,5,282,0,0,3712,3713,3,924,
  	462,0,3713,3714,3,1028,514,0,3714,3715,5,707,0,0,3715,3717,1,0,0,0,3716,
  	3703,1,0,0,0,3716,3704,1,0,0,0,3716,3706,1,0,0,0,3716,3709,1,0,0,0,3716,
  	3711,1,0,0,0,3717,367,1,0,0,0,3718,3725,5,705,0,0,3719,3720,5,144,0,0,
  	3720,3726,5,516,0,0,3721,3726,5,253,0,0,3722,3726,5,722,0,0,3723,3724,
  	5,403,0,0,3724,3726,5,715,0,0,3725,3719,1,0,0,0,3725,3721,1,0,0,0,3725,
  	3722,1,0,0,0,3725,3723,1,0,0,0,3726,369,1,0,0,0,3727,3729,5,670,0,0,3728,
  	3730,5,690,0,0,3729,3728,1,0,0,0,3729,3730,1,0,0,0,3730,3731,1,0,0,0,
  	3731,3736,3,372,186,0,3732,3733,5,29,0,0,3733,3735,3,372,186,0,3734,3732,
  	1,0,0,0,3735,3738,1,0,0,0,3736,3734,1,0,0,0,3736,3737,1,0,0,0,3737,371,
  	1,0,0,0,3738,3736,1,0,0,0,3739,3741,3,1426,713,0,3740,3742,3,1340,670,
  	0,3741,3740,1,0,0,0,3741,3742,1,0,0,0,3742,3743,1,0,0,0,3743,3744,5,63,
  	0,0,3744,3745,3,320,160,0,3745,373,1,0,0,0,3746,3747,5,253,0,0,3747,3748,
  	5,90,0,0,3748,3750,3,1038,519,0,3749,3751,3,376,188,0,3750,3749,1,0,0,
  	0,3750,3751,1,0,0,0,3751,3761,1,0,0,0,3752,3753,4,187,78,0,3753,3754,
  	5,253,0,0,3754,3755,5,90,0,0,3755,3756,7,33,0,0,3756,3757,5,32,0,0,3757,
  	3758,3,1042,521,0,3758,3759,5,33,0,0,3759,3761,1,0,0,0,3760,3746,1,0,
  	0,0,3760,3752,1,0,0,0,3761,375,1,0,0,0,3762,3763,5,670,0,0,3763,3768,
  	5,510,0,0,3764,3765,4,188,79,0,3765,3766,5,670,0,0,3766,3768,5,142,0,
  	0,3767,3762,1,0,0,0,3767,3764,1,0,0,0,3768,377,1,0,0,0,3769,3770,5,423,
  	0,0,3770,3771,5,90,0,0,3771,3772,3,1038,519,0,3772,379,1,0,0,0,3773,3774,
  	7,34,0,0,3774,381,1,0,0,0,3775,3778,5,239,0,0,3776,3779,5,188,0,0,3777,
  	3779,3,384,192,0,3778,3776,1,0,0,0,3778,3777,1,0,0,0,3779,383,1,0,0,0,
  	3780,3785,3,410,205,0,3781,3782,5,29,0,0,3782,3784,3,410,205,0,3783,3781,
  	1,0,0,0,3784,3787,1,0,0,0,3785,3783,1,0,0,0,3785,3786,1,0,0,0,3786,385,
  	1,0,0,0,3787,3785,1,0,0,0,3788,3789,5,652,0,0,3789,3794,3,390,195,0,3790,
  	3791,5,29,0,0,3791,3793,3,390,195,0,3792,3790,1,0,0,0,3793,3796,1,0,0,
  	0,3794,3792,1,0,0,0,3794,3795,1,0,0,0,3795,387,1,0,0,0,3796,3794,1,0,
  	0,0,3797,3798,5,600,0,0,3798,3799,3,1398,699,0,3799,389,1,0,0,0,3800,
  	3801,5,516,0,0,3801,3803,5,32,0,0,3802,3804,3,268,134,0,3803,3802,1,0,
  	0,0,3803,3804,1,0,0,0,3804,3805,1,0,0,0,3805,3806,5,33,0,0,3806,391,1,
  	0,0,0,3807,3816,3,322,161,0,3808,3816,5,561,0,0,3809,3810,4,196,80,0,
  	3810,3816,5,559,0,0,3811,3812,4,196,81,0,3812,3813,5,357,0,0,3813,3814,
  	5,6,0,0,3814,3816,3,1440,720,0,3815,3807,1,0,0,0,3815,3808,1,0,0,0,3815,
  	3809,1,0,0,0,3815,3811,1,0,0,0,3816,393,1,0,0,0,3817,3819,4,197,82,0,
  	3818,3820,3,396,198,0,3819,3818,1,0,0,0,3820,3821,1,0,0,0,3821,3819,1,
  	0,0,0,3821,3822,1,0,0,0,3822,395,1,0,0,0,3823,3824,5,236,0,0,3824,3828,
  	3,398,199,0,3825,3826,4,198,83,0,3826,3827,5,693,0,0,3827,3829,3,1402,
  	701,0,3828,3825,1,0,0,0,3828,3829,1,0,0,0,3829,3832,1,0,0,0,3830,3831,
  	4,198,84,0,3831,3833,3,400,200,0,3832,3830,1,0,0,0,3832,3833,1,0,0,0,
  	3833,3839,1,0,0,0,3834,3835,5,319,0,0,3835,3836,5,286,0,0,3836,3837,5,
  	535,0,0,3837,3839,5,377,0,0,3838,3823,1,0,0,0,3838,3834,1,0,0,0,3839,
  	397,1,0,0,0,3840,3844,5,640,0,0,3841,3842,4,199,85,0,3842,3844,5,535,
  	0,0,3843,3840,1,0,0,0,3843,3841,1,0,0,0,3844,399,1,0,0,0,3845,3846,5,
  	694,0,0,3846,3849,5,695,0,0,3847,3849,5,696,0,0,3848,3845,1,0,0,0,3848,
  	3847,1,0,0,0,3849,401,1,0,0,0,3850,3853,3,404,202,0,3851,3853,5,16,0,
  	0,3852,3850,1,0,0,0,3852,3851,1,0,0,0,3853,3858,1,0,0,0,3854,3855,5,29,
  	0,0,3855,3857,3,404,202,0,3856,3854,1,0,0,0,3857,3860,1,0,0,0,3858,3856,
  	1,0,0,0,3858,3859,1,0,0,0,3859,403,1,0,0,0,3860,3858,1,0,0,0,3861,3867,
  	3,1350,675,0,3862,3864,3,924,462,0,3863,3865,3,406,203,0,3864,3863,1,
  	0,0,0,3864,3865,1,0,0,0,3865,3867,1,0,0,0,3866,3861,1,0,0,0,3866,3862,
  	1,0,0,0,3867,405,1,0,0,0,3868,3870,5,63,0,0,3869,3868,1,0,0,0,3869,3870,
  	1,0,0,0,3870,3873,1,0,0,0,3871,3874,3,1426,713,0,3872,3874,3,1458,729,
  	0,3873,3871,1,0,0,0,3873,3872,1,0,0,0,3874,407,1,0,0,0,3875,3876,5,668,
  	0,0,3876,3877,3,924,462,0,3877,409,1,0,0,0,3878,3889,3,422,211,0,3879,
  	3883,5,34,0,0,3880,3881,4,205,86,0,3881,3884,3,1426,713,0,3882,3884,5,
  	757,0,0,3883,3880,1,0,0,0,3883,3882,1,0,0,0,3884,3885,1,0,0,0,3885,3886,
  	3,412,206,0,3886,3887,5,35,0,0,3887,3889,1,0,0,0,3888,3878,1,0,0,0,3888,
  	3879,1,0,0,0,3889,3893,1,0,0,0,3890,3892,3,414,207,0,3891,3890,1,0,0,
  	0,3892,3895,1,0,0,0,3893,3891,1,0,0,0,3893,3894,1,0,0,0,3894,411,1,0,
  	0,0,3895,3893,1,0,0,0,3896,3900,3,422,211,0,3897,3899,3,414,207,0,3898,
  	3897,1,0,0,0,3899,3902,1,0,0,0,3900,3898,1,0,0,0,3900,3901,1,0,0,0,3901,
  	413,1,0,0,0,3902,3900,1,0,0,0,3903,3904,3,418,209,0,3904,3909,3,410,205,
  	0,3905,3906,5,413,0,0,3906,3910,3,924,462,0,3907,3908,5,647,0,0,3908,
  	3910,3,1430,715,0,3909,3905,1,0,0,0,3909,3907,1,0,0,0,3909,3910,1,0,0,
  	0,3910,3923,1,0,0,0,3911,3912,3,420,210,0,3912,3917,3,410,205,0,3913,
  	3914,5,413,0,0,3914,3918,3,924,462,0,3915,3916,5,647,0,0,3916,3918,3,
  	1430,715,0,3917,3913,1,0,0,0,3917,3915,1,0,0,0,3918,3923,1,0,0,0,3919,
  	3920,3,416,208,0,3920,3921,3,422,211,0,3921,3923,1,0,0,0,3922,3903,1,
  	0,0,0,3922,3911,1,0,0,0,3922,3919,1,0,0,0,3923,415,1,0,0,0,3924,3926,
  	5,390,0,0,3925,3927,5,275,0,0,3926,3925,1,0,0,0,3926,3927,1,0,0,0,3927,
  	3928,1,0,0,0,3928,3936,5,295,0,0,3929,3930,5,390,0,0,3930,3932,7,35,0,
  	0,3931,3933,5,425,0,0,3932,3931,1,0,0,0,3932,3933,1,0,0,0,3933,3934,1,
  	0,0,0,3934,3936,5,295,0,0,3935,3924,1,0,0,0,3935,3929,1,0,0,0,3936,417,
  	1,0,0,0,3937,3939,7,36,0,0,3938,3937,1,0,0,0,3938,3939,1,0,0,0,3939,3940,
  	1,0,0,0,3940,3943,5,295,0,0,3941,3943,5,581,0,0,3942,3938,1,0,0,0,3942,
  	3941,1,0,0,0,3943,419,1,0,0,0,3944,3946,7,35,0,0,3945,3947,5,425,0,0,
  	3946,3945,1,0,0,0,3946,3947,1,0,0,0,3947,3948,1,0,0,0,3948,3949,5,295,
  	0,0,3949,421,1,0,0,0,3950,3957,3,424,212,0,3951,3957,3,426,213,0,3952,
  	3957,3,428,214,0,3953,3957,3,430,215,0,3954,3955,4,211,87,0,3955,3957,
  	3,432,216,0,3956,3950,1,0,0,0,3956,3951,1,0,0,0,3956,3952,1,0,0,0,3956,
  	3953,1,0,0,0,3956,3954,1,0,0,0,3957,423,1,0,0,0,3958,3960,3,1398,699,
  	0,3959,3961,3,1332,666,0,3960,3959,1,0,0,0,3960,3961,1,0,0,0,3961,3963,
  	1,0,0,0,3962,3964,3,450,225,0,3963,3962,1,0,0,0,3963,3964,1,0,0,0,3964,
  	3966,1,0,0,0,3965,3967,3,452,226,0,3966,3965,1,0,0,0,3966,3967,1,0,0,
  	0,3967,3969,1,0,0,0,3968,3970,3,952,476,0,3969,3968,1,0,0,0,3969,3970,
  	1,0,0,0,3970,425,1,0,0,0,3971,3974,5,32,0,0,3972,3975,3,424,212,0,3973,
  	3975,3,426,213,0,3974,3972,1,0,0,0,3974,3973,1,0,0,0,3975,3976,1,0,0,
  	0,3976,3977,5,33,0,0,3977,427,1,0,0,0,3978,3980,3,320,160,0,3979,3981,
  	3,450,225,0,3980,3979,1,0,0,0,3980,3981,1,0,0,0,3981,3984,1,0,0,0,3982,
  	3983,4,214,88,0,3983,3985,3,1340,670,0,3984,3982,1,0,0,0,3984,3985,1,
  	0,0,0,3985,3996,1,0,0,0,3986,3987,4,214,89,0,3987,3988,5,751,0,0,3988,
  	3990,3,320,160,0,3989,3991,3,450,225,0,3990,3989,1,0,0,0,3990,3991,1,
  	0,0,0,3991,3993,1,0,0,0,3992,3994,3,1340,670,0,3993,3992,1,0,0,0,3993,
  	3994,1,0,0,0,3994,3996,1,0,0,0,3995,3978,1,0,0,0,3995,3986,1,0,0,0,3996,
  	429,1,0,0,0,3997,4000,5,32,0,0,3998,4001,3,384,192,0,3999,4001,3,430,
  	215,0,4000,3998,1,0,0,0,4000,3999,1,0,0,0,4001,4002,1,0,0,0,4002,4003,
  	5,33,0,0,4003,431,1,0,0,0,4004,4005,5,726,0,0,4005,4006,5,32,0,0,4006,
  	4007,3,924,462,0,4007,4008,5,29,0,0,4008,4009,3,1458,729,0,4009,4010,
  	3,434,217,0,4010,4012,5,33,0,0,4011,4013,3,450,225,0,4012,4011,1,0,0,
  	0,4012,4013,1,0,0,0,4013,433,1,0,0,0,4014,4015,5,115,0,0,4015,4016,5,
  	32,0,0,4016,4021,3,436,218,0,4017,4018,5,29,0,0,4018,4020,3,436,218,0,
  	4019,4017,1,0,0,0,4020,4023,1,0,0,0,4021,4019,1,0,0,0,4021,4022,1,0,0,
  	0,4022,4024,1,0,0,0,4023,4021,1,0,0,0,4024,4025,5,33,0,0,4025,435,1,0,
  	0,0,4026,4027,3,1426,713,0,4027,4028,5,236,0,0,4028,4029,5,728,0,0,4029,
  	4050,1,0,0,0,4030,4031,3,1426,713,0,4031,4034,3,1182,591,0,4032,4033,
  	4,218,90,0,4033,4035,3,1264,632,0,4034,4032,1,0,0,0,4034,4035,1,0,0,0,
  	4035,4037,1,0,0,0,4036,4038,5,213,0,0,4037,4036,1,0,0,0,4037,4038,1,0,
  	0,0,4038,4039,1,0,0,0,4039,4040,5,729,0,0,4040,4042,3,1458,729,0,4041,
  	4043,3,440,220,0,4042,4041,1,0,0,0,4042,4043,1,0,0,0,4043,4050,1,0,0,
  	0,4044,4045,5,727,0,0,4045,4046,5,729,0,0,4046,4047,3,1458,729,0,4047,
  	4048,3,434,217,0,4048,4050,1,0,0,0,4049,4026,1,0,0,0,4049,4030,1,0,0,
  	0,4049,4044,1,0,0,0,4050,437,1,0,0,0,4051,4053,3,442,221,0,4052,4054,
  	3,444,222,0,4053,4052,1,0,0,0,4053,4054,1,0,0,0,4054,4057,1,0,0,0,4055,
  	4057,3,444,222,0,4056,4051,1,0,0,0,4056,4055,1,0,0,0,4057,439,1,0,0,0,
  	4058,4063,3,438,219,0,4059,4060,3,444,222,0,4060,4061,3,442,221,0,4061,
  	4063,1,0,0,0,4062,4058,1,0,0,0,4062,4059,1,0,0,0,4063,441,1,0,0,0,4064,
  	4065,3,446,223,0,4065,4066,5,413,0,0,4066,4067,5,725,0,0,4067,443,1,0,
  	0,0,4068,4069,3,446,223,0,4069,4070,5,413,0,0,4070,4071,5,204,0,0,4071,
  	445,1,0,0,0,4072,4077,5,204,0,0,4073,4077,5,406,0,0,4074,4075,5,168,0,
  	0,4075,4077,3,1458,729,0,4076,4072,1,0,0,0,4076,4073,1,0,0,0,4076,4074,
  	1,0,0,0,4077,447,1,0,0,0,4078,4079,7,37,0,0,4079,449,1,0,0,0,4080,4084,
  	5,63,0,0,4081,4082,4,225,91,0,4082,4084,5,6,0,0,4083,4080,1,0,0,0,4083,
  	4081,1,0,0,0,4083,4084,1,0,0,0,4084,4085,1,0,0,0,4085,4086,3,1426,713,
  	0,4086,451,1,0,0,0,4087,4091,3,454,227,0,4088,4090,3,454,227,0,4089,4088,
  	1,0,0,0,4090,4093,1,0,0,0,4091,4089,1,0,0,0,4091,4092,1,0,0,0,4092,453,
  	1,0,0,0,4093,4091,1,0,0,0,4094,4095,3,456,228,0,4095,4097,3,458,229,0,
  	4096,4098,3,462,231,0,4097,4096,1,0,0,0,4097,4098,1,0,0,0,4098,4099,1,
  	0,0,0,4099,4100,5,32,0,0,4100,4101,3,464,232,0,4101,4102,5,33,0,0,4102,
  	4115,1,0,0,0,4103,4104,5,646,0,0,4104,4106,3,458,229,0,4105,4107,3,462,
  	231,0,4106,4105,1,0,0,0,4106,4107,1,0,0,0,4107,4108,1,0,0,0,4108,4110,
  	5,32,0,0,4109,4111,3,464,232,0,4110,4109,1,0,0,0,4110,4111,1,0,0,0,4111,
  	4112,1,0,0,0,4112,4113,5,33,0,0,4113,4115,1,0,0,0,4114,4094,1,0,0,0,4114,
  	4103,1,0,0,0,4115,455,1,0,0,0,4116,4117,7,38,0,0,4117,457,1,0,0,0,4118,
  	4119,7,39,0,0,4119,459,1,0,0,0,4120,4121,5,450,0,0,4121,4127,5,299,0,
  	0,4122,4124,5,635,0,0,4123,4125,3,458,229,0,4124,4123,1,0,0,0,4124,4125,
  	1,0,0,0,4125,4127,1,0,0,0,4126,4120,1,0,0,0,4126,4122,1,0,0,0,4127,461,
  	1,0,0,0,4128,4134,5,236,0,0,4129,4135,5,295,0,0,4130,4131,5,423,0,0,4131,
  	4135,5,90,0,0,4132,4133,5,253,0,0,4133,4135,5,90,0,0,4134,4129,1,0,0,
  	0,4134,4130,1,0,0,0,4134,4132,1,0,0,0,4135,463,1,0,0,0,4136,4141,3,466,
  	233,0,4137,4138,5,29,0,0,4138,4140,3,466,233,0,4139,4137,1,0,0,0,4140,
  	4143,1,0,0,0,4141,4139,1,0,0,0,4141,4142,1,0,0,0,4142,465,1,0,0,0,4143,
  	4141,1,0,0,0,4144,4147,3,1426,713,0,4145,4147,5,450,0,0,4146,4144,1,0,
  	0,0,4146,4145,1,0,0,0,4147,467,1,0,0,0,4148,4149,4,234,92,0,4149,4151,
  	3,370,185,0,4150,4148,1,0,0,0,4150,4151,1,0,0,0,4151,4152,1,0,0,0,4152,
  	4154,5,640,0,0,4153,4155,5,327,0,0,4154,4153,1,0,0,0,4154,4155,1,0,0,
  	0,4155,4157,1,0,0,0,4156,4158,5,268,0,0,4157,4156,1,0,0,0,4157,4158,1,
  	0,0,0,4158,4159,1,0,0,0,4159,4160,3,384,192,0,4160,4161,5,533,0,0,4161,
  	4163,3,1272,636,0,4162,4164,3,408,204,0,4163,4162,1,0,0,0,4163,4164,1,
  	0,0,0,4164,4166,1,0,0,0,4165,4167,3,378,189,0,4166,4165,1,0,0,0,4166,
  	4167,1,0,0,0,4167,4169,1,0,0,0,4168,4170,3,326,163,0,4169,4168,1,0,0,
  	0,4169,4170,1,0,0,0,4170,469,1,0,0,0,4171,4176,3,472,236,0,4172,4176,
  	3,478,239,0,4173,4176,3,480,240,0,4174,4176,3,486,243,0,4175,4171,1,0,
  	0,0,4175,4172,1,0,0,0,4175,4173,1,0,0,0,4175,4174,1,0,0,0,4176,471,1,
  	0,0,0,4177,4178,5,569,0,0,4178,4182,5,618,0,0,4179,4181,3,476,238,0,4180,
  	4179,1,0,0,0,4181,4184,1,0,0,0,4182,4180,1,0,0,0,4182,4183,1,0,0,0,4183,
  	4203,1,0,0,0,4184,4182,1,0,0,0,4185,4187,5,121,0,0,4186,4188,5,672,0,
  	0,4187,4186,1,0,0,0,4187,4188,1,0,0,0,4188,4194,1,0,0,0,4189,4191,5,61,
  	0,0,4190,4192,5,403,0,0,4191,4190,1,0,0,0,4191,4192,1,0,0,0,4192,4193,
  	1,0,0,0,4193,4195,5,99,0,0,4194,4189,1,0,0,0,4194,4195,1,0,0,0,4195,4200,
  	1,0,0,0,4196,4198,5,403,0,0,4197,4196,1,0,0,0,4197,4198,1,0,0,0,4198,
  	4199,1,0,0,0,4199,4201,5,480,0,0,4200,4197,1,0,0,0,4200,4201,1,0,0,0,
  	4201,4203,1,0,0,0,4202,4177,1,0,0,0,4202,4185,1,0,0,0,4203,473,1,0,0,
  	0,4204,4206,5,74,0,0,4205,4207,5,672,0,0,4206,4205,1,0,0,0,4206,4207,
  	1,0,0,0,4207,475,1,0,0,0,4208,4209,5,670,0,0,4209,4210,5,129,0,0,4210,
  	4214,5,544,0,0,4211,4212,5,465,0,0,4212,4214,7,40,0,0,4213,4208,1,0,0,
  	0,4213,4211,1,0,0,0,4214,477,1,0,0,0,4215,4216,5,518,0,0,4216,4245,3,
  	1426,713,0,4217,4219,5,509,0,0,4218,4220,5,672,0,0,4219,4218,1,0,0,0,
  	4219,4220,1,0,0,0,4220,4239,1,0,0,0,4221,4223,5,616,0,0,4222,4224,5,518,
  	0,0,4223,4222,1,0,0,0,4223,4224,1,0,0,0,4224,4225,1,0,0,0,4225,4240,3,
  	1426,713,0,4226,4228,5,61,0,0,4227,4229,5,403,0,0,4228,4227,1,0,0,0,4228,
  	4229,1,0,0,0,4229,4230,1,0,0,0,4230,4232,5,99,0,0,4231,4226,1,0,0,0,4231,
  	4232,1,0,0,0,4232,4237,1,0,0,0,4233,4235,5,403,0,0,4234,4233,1,0,0,0,
  	4234,4235,1,0,0,0,4235,4236,1,0,0,0,4236,4238,5,480,0,0,4237,4234,1,0,
  	0,0,4237,4238,1,0,0,0,4238,4240,1,0,0,0,4239,4221,1,0,0,0,4239,4231,1,
  	0,0,0,4240,4245,1,0,0,0,4241,4242,5,480,0,0,4242,4243,5,518,0,0,4243,
  	4245,3,1426,713,0,4244,4215,1,0,0,0,4244,4217,1,0,0,0,4244,4241,1,0,0,
  	0,4245,479,1,0,0,0,4246,4247,5,319,0,0,4247,4248,7,16,0,0,4248,4253,3,
  	482,241,0,4249,4250,5,29,0,0,4250,4252,3,482,241,0,4251,4249,1,0,0,0,
  	4252,4255,1,0,0,0,4253,4251,1,0,0,0,4253,4254,1,0,0,0,4254,4269,1,0,0,
  	0,4255,4253,1,0,0,0,4256,4257,4,240,93,0,4257,4258,5,319,0,0,4258,4259,
  	5,280,0,0,4259,4260,5,236,0,0,4260,4269,5,72,0,0,4261,4266,5,637,0,0,
  	4262,4267,5,597,0,0,4263,4267,5,600,0,0,4264,4265,4,240,94,0,4265,4267,
  	5,280,0,0,4266,4262,1,0,0,0,4266,4263,1,0,0,0,4266,4264,1,0,0,0,4267,
  	4269,1,0,0,0,4268,4246,1,0,0,0,4268,4256,1,0,0,0,4268,4261,1,0,0,0,4269,
  	481,1,0,0,0,4270,4272,3,1398,699,0,4271,4273,3,450,225,0,4272,4271,1,
  	0,0,0,4272,4273,1,0,0,0,4273,4274,1,0,0,0,4274,4275,3,484,242,0,4275,
  	483,1,0,0,0,4276,4278,5,465,0,0,4277,4279,5,316,0,0,4278,4277,1,0,0,0,
  	4278,4279,1,0,0,0,4279,4286,1,0,0,0,4280,4281,4,242,95,0,4281,4283,5,
  	327,0,0,4282,4280,1,0,0,0,4282,4283,1,0,0,0,4283,4284,1,0,0,0,4284,4286,
  	5,674,0,0,4285,4276,1,0,0,0,4285,4282,1,0,0,0,4286,485,1,0,0,0,4287,4314,
  	5,676,0,0,4288,4289,7,41,0,0,4289,4291,3,490,245,0,4290,4292,7,42,0,0,
  	4291,4290,1,0,0,0,4291,4292,1,0,0,0,4292,4315,1,0,0,0,4293,4294,5,198,
  	0,0,4294,4300,3,490,245,0,4295,4298,5,592,0,0,4296,4297,5,236,0,0,4297,
  	4299,5,371,0,0,4298,4296,1,0,0,0,4298,4299,1,0,0,0,4299,4301,1,0,0,0,
  	4300,4295,1,0,0,0,4300,4301,1,0,0,0,4301,4315,1,0,0,0,4302,4303,5,447,
  	0,0,4303,4315,3,490,245,0,4304,4305,5,121,0,0,4305,4308,3,490,245,0,4306,
  	4307,5,414,0,0,4307,4309,5,437,0,0,4308,4306,1,0,0,0,4308,4309,1,0,0,
  	0,4309,4315,1,0,0,0,4310,4311,5,509,0,0,4311,4315,3,490,245,0,4312,4313,
  	5,469,0,0,4313,4315,3,488,244,0,4314,4288,1,0,0,0,4314,4293,1,0,0,0,4314,
  	4302,1,0,0,0,4314,4304,1,0,0,0,4314,4310,1,0,0,0,4314,4312,1,0,0,0,4315,
  	487,1,0,0,0,4316,4319,4,244,96,0,4317,4318,5,137,0,0,4318,4320,5,677,
  	0,0,4319,4317,1,0,0,0,4319,4320,1,0,0,0,4320,4323,1,0,0,0,4321,4323,1,
  	0,0,0,4322,4316,1,0,0,0,4322,4321,1,0,0,0,4323,489,1,0,0,0,4324,4331,
  	3,1460,730,0,4325,4326,5,29,0,0,4326,4329,3,1460,730,0,4327,4328,5,29,
  	0,0,4328,4330,3,1438,719,0,4329,4327,1,0,0,0,4329,4330,1,0,0,0,4330,4332,
  	1,0,0,0,4331,4325,1,0,0,0,4331,4332,1,0,0,0,4332,491,1,0,0,0,4333,4334,
  	5,458,0,0,4334,4357,3,494,247,0,4335,4357,3,504,252,0,4336,4357,3,576,
  	288,0,4337,4338,5,498,0,0,4338,4343,3,496,248,0,4339,4340,5,29,0,0,4340,
  	4342,3,496,248,0,4341,4339,1,0,0,0,4342,4345,1,0,0,0,4343,4341,1,0,0,
  	0,4343,4344,1,0,0,0,4344,4357,1,0,0,0,4345,4343,1,0,0,0,4346,4347,4,246,
  	97,0,4347,4348,5,498,0,0,4348,4350,5,683,0,0,4349,4351,3,1252,626,0,4350,
  	4349,1,0,0,0,4350,4351,1,0,0,0,4351,4357,1,0,0,0,4352,4357,3,590,295,
  	0,4353,4357,3,592,296,0,4354,4355,4,246,98,0,4355,4357,3,608,304,0,4356,
  	4333,1,0,0,0,4356,4335,1,0,0,0,4356,4336,1,0,0,0,4356,4337,1,0,0,0,4356,
  	4346,1,0,0,0,4356,4352,1,0,0,0,4356,4353,1,0,0,0,4356,4354,1,0,0,0,4357,
  	493,1,0,0,0,4358,4362,5,77,0,0,4359,4360,4,247,99,0,4360,4362,5,348,0,
  	0,4361,4358,1,0,0,0,4361,4359,1,0,0,0,4362,4363,1,0,0,0,4363,4368,5,321,
  	0,0,4364,4365,5,616,0,0,4365,4369,3,1464,732,0,4366,4367,5,73,0,0,4367,
  	4369,3,924,462,0,4368,4364,1,0,0,0,4368,4366,1,0,0,0,4369,495,1,0,0,0,
  	4370,4372,3,498,249,0,4371,4373,3,500,250,0,4372,4371,1,0,0,0,4372,4373,
  	1,0,0,0,4373,4385,1,0,0,0,4374,4375,4,248,100,0,4375,4376,5,460,0,0,4376,
  	4385,5,92,0,0,4377,4379,3,620,310,0,4378,4380,5,56,0,0,4379,4378,1,0,
  	0,0,4379,4380,1,0,0,0,4380,4382,1,0,0,0,4381,4383,3,1046,523,0,4382,4381,
  	1,0,0,0,4382,4383,1,0,0,0,4383,4385,1,0,0,0,4384,4370,1,0,0,0,4384,4374,
  	1,0,0,0,4384,4377,1,0,0,0,4385,497,1,0,0,0,4386,4387,4,249,101,0,4387,
  	4394,5,348,0,0,4388,4389,4,249,102,0,4389,4390,5,77,0,0,4390,4391,5,321,
  	0,0,4391,4392,5,61,0,0,4392,4394,5,826,0,0,4393,4386,1,0,0,0,4393,4388,
  	1,0,0,0,4394,499,1,0,0,0,4395,4396,4,250,103,0,4396,4397,5,616,0,0,4397,
  	4398,3,1444,722,0,4398,501,1,0,0,0,4399,4400,4,251,104,0,4400,4405,5,
  	348,0,0,4401,4402,4,251,105,0,4402,4403,5,489,0,0,4403,4405,5,548,0,0,
  	4404,4399,1,0,0,0,4404,4401,1,0,0,0,4405,503,1,0,0,0,4406,4407,5,100,
  	0,0,4407,4408,3,502,251,0,4408,4409,5,616,0,0,4409,4411,3,506,253,0,4410,
  	4412,3,1046,523,0,4411,4410,1,0,0,0,4411,4412,1,0,0,0,4412,505,1,0,0,
  	0,4413,4418,3,508,254,0,4414,4415,5,29,0,0,4415,4417,3,508,254,0,4416,
  	4414,1,0,0,0,4417,4420,1,0,0,0,4418,4416,1,0,0,0,4418,4419,1,0,0,0,4419,
  	507,1,0,0,0,4420,4418,1,0,0,0,4421,4422,3,512,256,0,4422,4423,5,6,0,0,
  	4423,4424,3,1466,733,0,4424,4550,1,0,0,0,4425,4426,5,754,0,0,4426,4427,
  	5,6,0,0,4427,4550,3,1466,733,0,4428,4429,3,514,257,0,4429,4430,5,6,0,
  	0,4430,4431,3,1466,733,0,4431,4550,1,0,0,0,4432,4433,3,516,258,0,4433,
  	4434,5,6,0,0,4434,4435,3,1466,733,0,4435,4550,1,0,0,0,4436,4437,3,518,
  	259,0,4437,4438,5,6,0,0,4438,4439,3,1466,733,0,4439,4550,1,0,0,0,4440,
  	4441,3,520,260,0,4441,4442,5,6,0,0,4442,4443,3,1438,719,0,4443,4550,1,
  	0,0,0,4444,4445,3,522,261,0,4445,4446,5,6,0,0,4446,4447,3,1438,719,0,
  	4447,4550,1,0,0,0,4448,4449,3,524,262,0,4449,4450,5,6,0,0,4450,4451,3,
  	1438,719,0,4451,4550,1,0,0,0,4452,4453,3,526,263,0,4453,4454,5,6,0,0,
  	4454,4455,3,1438,719,0,4455,4550,1,0,0,0,4456,4457,3,528,264,0,4457,4458,
  	5,6,0,0,4458,4459,3,1438,719,0,4459,4550,1,0,0,0,4460,4461,3,530,265,
  	0,4461,4462,5,6,0,0,4462,4463,3,1466,733,0,4463,4550,1,0,0,0,4464,4465,
  	3,532,266,0,4465,4466,5,6,0,0,4466,4467,3,1466,733,0,4467,4550,1,0,0,
  	0,4468,4469,3,544,272,0,4469,4470,5,6,0,0,4470,4471,3,1466,733,0,4471,
  	4550,1,0,0,0,4472,4473,3,548,274,0,4473,4474,5,6,0,0,4474,4475,3,1466,
  	733,0,4475,4550,1,0,0,0,4476,4477,3,546,273,0,4477,4478,5,6,0,0,4478,
  	4479,3,566,283,0,4479,4550,1,0,0,0,4480,4481,3,534,267,0,4481,4482,5,
  	6,0,0,4482,4483,3,1466,733,0,4483,4550,1,0,0,0,4484,4485,3,540,270,0,
  	4485,4486,5,6,0,0,4486,4487,3,1466,733,0,4487,4550,1,0,0,0,4488,4489,
  	3,542,271,0,4489,4490,5,6,0,0,4490,4491,3,1438,719,0,4491,4550,1,0,0,
  	0,4492,4493,3,536,268,0,4493,4494,5,6,0,0,4494,4495,3,1464,732,0,4495,
  	4550,1,0,0,0,4496,4497,3,538,269,0,4497,4498,5,6,0,0,4498,4499,3,1466,
  	733,0,4499,4550,1,0,0,0,4500,4501,3,550,275,0,4501,4502,5,6,0,0,4502,
  	4503,3,1466,733,0,4503,4550,1,0,0,0,4504,4505,3,552,276,0,4505,4506,5,
  	6,0,0,4506,4507,3,1438,719,0,4507,4550,1,0,0,0,4508,4509,3,554,277,0,
  	4509,4510,5,6,0,0,4510,4511,3,1438,719,0,4511,4550,1,0,0,0,4512,4513,
  	5,269,0,0,4513,4514,5,6,0,0,4514,4550,3,574,287,0,4515,4516,3,556,278,
  	0,4516,4517,5,6,0,0,4517,4518,3,1458,729,0,4518,4550,1,0,0,0,4519,4520,
  	3,558,279,0,4520,4521,5,6,0,0,4521,4522,3,1438,719,0,4522,4550,1,0,0,
  	0,4523,4524,3,510,255,0,4524,4525,5,6,0,0,4525,4526,3,1438,719,0,4526,
  	4550,1,0,0,0,4527,4528,5,762,0,0,4528,4529,5,6,0,0,4529,4550,3,560,280,
  	0,4530,4531,5,764,0,0,4531,4532,5,6,0,0,4532,4550,3,1438,719,0,4533,4534,
  	5,767,0,0,4534,4535,5,6,0,0,4535,4550,3,562,281,0,4536,4537,4,254,106,
  	0,4537,4538,5,776,0,0,4538,4539,5,6,0,0,4539,4550,3,1440,720,0,4540,4541,
  	4,254,107,0,4541,4542,5,781,0,0,4542,4543,5,6,0,0,4543,4550,3,564,282,
  	0,4544,4545,4,254,108,0,4545,4546,5,819,0,0,4546,4547,5,6,0,0,4547,4550,
  	3,1440,720,0,4548,4550,3,568,284,0,4549,4421,1,0,0,0,4549,4425,1,0,0,
  	0,4549,4428,1,0,0,0,4549,4432,1,0,0,0,4549,4436,1,0,0,0,4549,4440,1,0,
  	0,0,4549,4444,1,0,0,0,4549,4448,1,0,0,0,4549,4452,1,0,0,0,4549,4456,1,
  	0,0,0,4549,4460,1,0,0,0,4549,4464,1,0,0,0,4549,4468,1,0,0,0,4549,4472,
  	1,0,0,0,4549,4476,1,0,0,0,4549,4480,1,0,0,0,4549,4484,1,0,0,0,4549,4488,
  	1,0,0,0,4549,4492,1,0,0,0,4549,4496,1,0,0,0,4549,4500,1,0,0,0,4549,4504,
  	1,0,0,0,4549,4508,1,0,0,0,4549,4512,1,0,0,0,4549,4515,1,0,0,0,4549,4519,
  	1,0,0,0,4549,4523,1,0,0,0,4549,4527,1,0,0,0,4549,4530,1,0,0,0,4549,4533,
  	1,0,0,0,4549,4536,1,0,0,0,4549,4540,1,0,0,0,4549,4544,1,0,0,0,4549,4548,
  	1,0,0,0,4550,509,1,0,0,0,4551,4552,7,43,0,0,4552,511,1,0,0,0,4553,4554,
  	7,44,0,0,4554,513,1,0,0,0,4555,4556,7,45,0,0,4556,515,1,0,0,0,4557,4558,
  	7,46,0,0,4558,517,1,0,0,0,4559,4560,7,47,0,0,4560,519,1,0,0,0,4561,4562,
  	7,48,0,0,4562,521,1,0,0,0,4563,4564,7,49,0,0,4564,523,1,0,0,0,4565,4566,
  	7,50,0,0,4566,525,1,0,0,0,4567,4568,7,51,0,0,4568,527,1,0,0,0,4569,4570,
  	7,52,0,0,4570,529,1,0,0,0,4571,4572,7,53,0,0,4572,531,1,0,0,0,4573,4574,
  	7,54,0,0,4574,533,1,0,0,0,4575,4576,7,55,0,0,4576,535,1,0,0,0,4577,4578,
  	7,56,0,0,4578,537,1,0,0,0,4579,4580,7,57,0,0,4580,539,1,0,0,0,4581,4582,
  	7,58,0,0,4582,541,1,0,0,0,4583,4584,7,59,0,0,4584,543,1,0,0,0,4585,4586,
  	7,60,0,0,4586,545,1,0,0,0,4587,4588,7,61,0,0,4588,547,1,0,0,0,4589,4590,
  	7,62,0,0,4590,549,1,0,0,0,4591,4592,7,63,0,0,4592,551,1,0,0,0,4593,4594,
  	7,64,0,0,4594,553,1,0,0,0,4595,4596,7,65,0,0,4596,555,1,0,0,0,4597,4598,
  	7,66,0,0,4598,557,1,0,0,0,4599,4600,7,67,0,0,4600,559,1,0,0,0,4601,4604,
  	3,1320,660,0,4602,4604,5,406,0,0,4603,4601,1,0,0,0,4603,4602,1,0,0,0,
  	4604,561,1,0,0,0,4605,4606,7,68,0,0,4606,563,1,0,0,0,4607,4611,5,769,
  	0,0,4608,4611,5,316,0,0,4609,4611,3,1458,729,0,4610,4607,1,0,0,0,4610,
  	4608,1,0,0,0,4610,4609,1,0,0,0,4611,565,1,0,0,0,4612,4615,3,1466,733,
  	0,4613,4615,5,406,0,0,4614,4612,1,0,0,0,4614,4613,1,0,0,0,4615,567,1,
  	0,0,0,4616,4617,3,570,285,0,4617,4618,5,6,0,0,4618,4619,3,1466,733,0,
  	4619,4631,1,0,0,0,4620,4621,3,572,286,0,4621,4622,5,6,0,0,4622,4623,3,
  	1442,721,0,4623,4631,1,0,0,0,4624,4625,5,477,0,0,4625,4626,5,6,0,0,4626,
  	4631,3,1466,733,0,4627,4628,5,478,0,0,4628,4629,5,6,0,0,4629,4631,3,1438,
  	719,0,4630,4616,1,0,0,0,4630,4620,1,0,0,0,4630,4624,1,0,0,0,4630,4627,
  	1,0,0,0,4631,569,1,0,0,0,4632,4633,7,69,0,0,4633,571,1,0,0,0,4634,4635,
  	7,70,0,0,4635,573,1,0,0,0,4636,4645,5,32,0,0,4637,4642,3,1438,719,0,4638,
  	4639,5,29,0,0,4639,4641,3,1438,719,0,4640,4638,1,0,0,0,4641,4644,1,0,
  	0,0,4642,4640,1,0,0,0,4642,4643,1,0,0,0,4643,4646,1,0,0,0,4644,4642,1,
  	0,0,0,4645,4637,1,0,0,0,4645,4646,1,0,0,0,4646,4647,1,0,0,0,4647,4648,
  	5,33,0,0,4648,575,1,0,0,0,4649,4650,5,100,0,0,4650,4651,5,489,0,0,4651,
  	4652,5,228,0,0,4652,4657,3,578,289,0,4653,4654,5,29,0,0,4654,4656,3,578,
  	289,0,4655,4653,1,0,0,0,4656,4659,1,0,0,0,4657,4655,1,0,0,0,4657,4658,
  	1,0,0,0,4658,4662,1,0,0,0,4659,4657,1,0,0,0,4660,4661,4,288,109,0,4661,
  	4663,3,1046,523,0,4662,4660,1,0,0,0,4662,4663,1,0,0,0,4663,577,1,0,0,
  	0,4664,4665,5,490,0,0,4665,4666,5,6,0,0,4666,4668,5,32,0,0,4667,4669,
  	3,580,290,0,4668,4667,1,0,0,0,4668,4669,1,0,0,0,4669,4670,1,0,0,0,4670,
  	4714,5,33,0,0,4671,4672,5,491,0,0,4672,4673,5,6,0,0,4673,4675,5,32,0,
  	0,4674,4676,3,580,290,0,4675,4674,1,0,0,0,4675,4676,1,0,0,0,4676,4677,
  	1,0,0,0,4677,4714,5,33,0,0,4678,4679,5,492,0,0,4679,4680,5,6,0,0,4680,
  	4682,5,32,0,0,4681,4683,3,582,291,0,4682,4681,1,0,0,0,4682,4683,1,0,0,
  	0,4683,4684,1,0,0,0,4684,4714,5,33,0,0,4685,4686,5,493,0,0,4686,4687,
  	5,6,0,0,4687,4689,5,32,0,0,4688,4690,3,582,291,0,4689,4688,1,0,0,0,4689,
  	4690,1,0,0,0,4690,4691,1,0,0,0,4691,4714,5,33,0,0,4692,4693,5,494,0,0,
  	4693,4694,5,6,0,0,4694,4696,5,32,0,0,4695,4697,3,584,292,0,4696,4695,
  	1,0,0,0,4696,4697,1,0,0,0,4697,4698,1,0,0,0,4698,4714,5,33,0,0,4699,4700,
  	5,495,0,0,4700,4701,5,6,0,0,4701,4703,5,32,0,0,4702,4704,3,584,292,0,
  	4703,4702,1,0,0,0,4703,4704,1,0,0,0,4704,4705,1,0,0,0,4705,4714,5,33,
  	0,0,4706,4707,5,496,0,0,4707,4708,5,6,0,0,4708,4710,5,32,0,0,4709,4711,
  	3,588,294,0,4710,4709,1,0,0,0,4710,4711,1,0,0,0,4711,4712,1,0,0,0,4712,
  	4714,5,33,0,0,4713,4664,1,0,0,0,4713,4671,1,0,0,0,4713,4678,1,0,0,0,4713,
  	4685,1,0,0,0,4713,4692,1,0,0,0,4713,4699,1,0,0,0,4713,4706,1,0,0,0,4714,
  	579,1,0,0,0,4715,4720,3,1354,677,0,4716,4717,5,29,0,0,4717,4719,3,1354,
  	677,0,4718,4716,1,0,0,0,4719,4722,1,0,0,0,4720,4718,1,0,0,0,4720,4721,
  	1,0,0,0,4721,581,1,0,0,0,4722,4720,1,0,0,0,4723,4728,3,1394,697,0,4724,
  	4725,5,29,0,0,4725,4727,3,1394,697,0,4726,4724,1,0,0,0,4727,4730,1,0,
  	0,0,4728,4726,1,0,0,0,4728,4729,1,0,0,0,4729,583,1,0,0,0,4730,4728,1,
  	0,0,0,4731,4736,3,586,293,0,4732,4733,5,29,0,0,4733,4735,3,586,293,0,
  	4734,4732,1,0,0,0,4735,4738,1,0,0,0,4736,4734,1,0,0,0,4736,4737,1,0,0,
  	0,4737,585,1,0,0,0,4738,4736,1,0,0,0,4739,4740,3,1466,733,0,4740,587,
  	1,0,0,0,4741,4746,3,1268,634,0,4742,4743,5,29,0,0,4743,4745,3,1268,634,
  	0,4744,4742,1,0,0,0,4745,4748,1,0,0,0,4746,4744,1,0,0,0,4746,4747,1,0,
  	0,0,4747,589,1,0,0,0,4748,4746,1,0,0,0,4749,4750,5,569,0,0,4750,4752,
  	3,620,310,0,4751,4753,3,604,302,0,4752,4751,1,0,0,0,4752,4753,1,0,0,0,
  	4753,4756,1,0,0,0,4754,4755,5,639,0,0,4755,4757,3,594,297,0,4756,4754,
  	1,0,0,0,4756,4757,1,0,0,0,4757,4759,1,0,0,0,4758,4760,3,596,298,0,4759,
  	4758,1,0,0,0,4759,4760,1,0,0,0,4760,4762,1,0,0,0,4761,4763,3,598,299,
  	0,4762,4761,1,0,0,0,4762,4763,1,0,0,0,4763,4765,1,0,0,0,4764,4766,3,600,
  	300,0,4765,4764,1,0,0,0,4765,4766,1,0,0,0,4766,4768,1,0,0,0,4767,4769,
  	3,602,301,0,4768,4767,1,0,0,0,4768,4769,1,0,0,0,4769,4771,1,0,0,0,4770,
  	4772,3,1046,523,0,4771,4770,1,0,0,0,4771,4772,1,0,0,0,4772,591,1,0,0,
  	0,4773,4774,5,578,0,0,4774,4776,3,620,310,0,4775,4777,3,604,302,0,4776,
  	4775,1,0,0,0,4776,4777,1,0,0,0,4777,4779,1,0,0,0,4778,4780,3,1046,523,
  	0,4779,4778,1,0,0,0,4779,4780,1,0,0,0,4780,593,1,0,0,0,4781,4787,3,568,
  	284,0,4782,4783,7,71,0,0,4783,4784,5,6,0,0,4784,4787,3,1460,730,0,4785,
  	4787,5,555,0,0,4786,4781,1,0,0,0,4786,4782,1,0,0,0,4786,4785,1,0,0,0,
  	4787,4792,1,0,0,0,4788,4789,5,29,0,0,4789,4791,3,568,284,0,4790,4788,
  	1,0,0,0,4791,4794,1,0,0,0,4792,4790,1,0,0,0,4792,4793,1,0,0,0,4793,595,
  	1,0,0,0,4794,4792,1,0,0,0,4795,4796,5,644,0,0,4796,4797,5,6,0,0,4797,
  	4798,3,1460,730,0,4798,597,1,0,0,0,4799,4800,5,436,0,0,4800,4801,5,6,
  	0,0,4801,4802,3,1460,730,0,4802,599,1,0,0,0,4803,4804,5,169,0,0,4804,
  	4805,5,6,0,0,4805,4806,3,1460,730,0,4806,601,1,0,0,0,4807,4808,5,439,
  	0,0,4808,4809,5,6,0,0,4809,4810,3,1460,730,0,4810,603,1,0,0,0,4811,4816,
  	3,606,303,0,4812,4813,5,29,0,0,4813,4815,3,606,303,0,4814,4812,1,0,0,
  	0,4815,4818,1,0,0,0,4816,4814,1,0,0,0,4816,4817,1,0,0,0,4817,605,1,0,
  	0,0,4818,4816,1,0,0,0,4819,4820,7,72,0,0,4820,607,1,0,0,0,4821,4822,5,
  	569,0,0,4822,4825,5,246,0,0,4823,4824,4,304,110,0,4824,4826,3,610,305,
  	0,4825,4823,1,0,0,0,4825,4826,1,0,0,0,4826,4830,1,0,0,0,4827,4828,5,578,
  	0,0,4828,4830,5,246,0,0,4829,4821,1,0,0,0,4829,4827,1,0,0,0,4830,609,
  	1,0,0,0,4831,4836,3,612,306,0,4832,4833,5,29,0,0,4833,4835,3,612,306,
  	0,4834,4832,1,0,0,0,4835,4838,1,0,0,0,4836,4834,1,0,0,0,4836,4837,1,0,
  	0,0,4837,611,1,0,0,0,4838,4836,1,0,0,0,4839,4843,3,614,307,0,4840,4843,
  	3,616,308,0,4841,4843,3,618,309,0,4842,4839,1,0,0,0,4842,4840,1,0,0,0,
  	4842,4841,1,0,0,0,4843,613,1,0,0,0,4844,4845,5,644,0,0,4845,4846,5,6,
  	0,0,4846,4847,3,1466,733,0,4847,615,1,0,0,0,4848,4849,5,436,0,0,4849,
  	4850,5,6,0,0,4850,4851,3,1466,733,0,4851,617,1,0,0,0,4852,4853,5,169,
  	0,0,4853,4854,5,6,0,0,4854,4855,3,1466,733,0,4855,619,1,0,0,0,4856,4860,
  	5,541,0,0,4857,4858,4,310,111,0,4858,4860,5,779,0,0,4859,4856,1,0,0,0,
  	4859,4857,1,0,0,0,4860,621,1,0,0,0,4861,4862,5,447,0,0,4862,4863,3,1426,
  	713,0,4863,4866,5,239,0,0,4864,4867,3,1464,732,0,4865,4867,3,1000,500,
  	0,4866,4864,1,0,0,0,4866,4865,1,0,0,0,4867,4873,1,0,0,0,4868,4873,3,624,
  	312,0,4869,4870,7,73,0,0,4870,4871,5,447,0,0,4871,4873,3,1426,713,0,4872,
  	4861,1,0,0,0,4872,4868,1,0,0,0,4872,4869,1,0,0,0,4873,623,1,0,0,0,4874,
  	4875,5,212,0,0,4875,4878,3,1426,713,0,4876,4877,5,647,0,0,4877,4879,3,
  	626,313,0,4878,4876,1,0,0,0,4878,4879,1,0,0,0,4879,625,1,0,0,0,4880,4885,
  	3,1000,500,0,4881,4882,5,29,0,0,4882,4884,3,1000,500,0,4883,4881,1,0,
  	0,0,4884,4887,1,0,0,0,4885,4883,1,0,0,0,4885,4886,1,0,0,0,4886,627,1,
  	0,0,0,4887,4885,1,0,0,0,4888,4913,5,702,0,0,4889,4890,5,316,0,0,4890,
  	4891,5,154,0,0,4891,4893,5,179,0,0,4892,4894,3,1496,748,0,4893,4892,1,
  	0,0,0,4893,4894,1,0,0,0,4894,4895,1,0,0,0,4895,4914,3,1458,729,0,4896,
  	4899,5,701,0,0,4897,4898,5,236,0,0,4898,4900,5,489,0,0,4899,4897,1,0,
  	0,0,4899,4900,1,0,0,0,4900,4914,1,0,0,0,4901,4902,4,314,112,0,4902,4903,
  	5,280,0,0,4903,4904,5,239,0,0,4904,4905,3,1322,661,0,4905,4906,5,31,0,
  	0,4906,4907,3,1438,719,0,4907,4908,5,266,0,0,4908,4909,5,90,0,0,4909,
  	4911,3,1458,729,0,4910,4912,3,630,315,0,4911,4910,1,0,0,0,4911,4912,1,
  	0,0,0,4912,4914,1,0,0,0,4913,4889,1,0,0,0,4913,4896,1,0,0,0,4913,4901,
  	1,0,0,0,4914,629,1,0,0,0,4915,4926,3,632,316,0,4916,4917,5,154,0,0,4917,
  	4919,5,179,0,0,4918,4920,3,1496,748,0,4919,4918,1,0,0,0,4919,4920,1,0,
  	0,0,4920,4921,1,0,0,0,4921,4923,3,1458,729,0,4922,4924,3,632,316,0,4923,
  	4922,1,0,0,0,4923,4924,1,0,0,0,4924,4926,1,0,0,0,4925,4915,1,0,0,0,4925,
  	4916,1,0,0,0,4926,631,1,0,0,0,4927,4929,5,497,0,0,4928,4930,5,403,0,0,
  	4929,4928,1,0,0,0,4929,4930,1,0,0,0,4930,4931,1,0,0,0,4931,4932,5,565,
  	0,0,4932,633,1,0,0,0,4933,4942,3,636,318,0,4934,4942,3,646,323,0,4935,
  	4942,3,660,330,0,4936,4942,3,662,331,0,4937,4942,3,676,338,0,4938,4942,
  	3,678,339,0,4939,4940,4,317,113,0,4940,4942,3,694,347,0,4941,4933,1,0,
  	0,0,4941,4934,1,0,0,0,4941,4935,1,0,0,0,4941,4936,1,0,0,0,4941,4937,1,
  	0,0,0,4941,4938,1,0,0,0,4941,4939,1,0,0,0,4942,635,1,0,0,0,4943,4944,
  	5,57,0,0,4944,4947,5,644,0,0,4945,4946,4,318,114,0,4946,4948,3,1250,625,
  	0,4947,4945,1,0,0,0,4947,4948,1,0,0,0,4948,4998,1,0,0,0,4949,4950,4,318,
  	115,0,4950,4954,3,1288,644,0,4951,4952,4,318,116,0,4952,4954,3,638,319,
  	0,4953,4949,1,0,0,0,4953,4951,1,0,0,0,4954,4955,1,0,0,0,4955,4956,3,648,
  	324,0,4956,4999,1,0,0,0,4957,4958,4,318,117,0,4958,4977,3,644,322,0,4959,
  	4962,3,1298,649,0,4960,4962,3,1296,648,0,4961,4959,1,0,0,0,4961,4960,
  	1,0,0,0,4962,4965,1,0,0,0,4963,4964,4,318,118,0,4964,4966,3,1318,659,
  	0,4965,4963,1,0,0,0,4965,4966,1,0,0,0,4966,4969,1,0,0,0,4967,4968,4,318,
  	119,0,4968,4970,3,1310,655,0,4969,4967,1,0,0,0,4969,4970,1,0,0,0,4970,
  	4978,1,0,0,0,4971,4972,4,318,120,0,4972,4978,3,1312,656,0,4973,4975,4,
  	318,121,0,4974,4976,3,1314,657,0,4975,4974,1,0,0,0,4975,4976,1,0,0,0,
  	4976,4978,1,0,0,0,4977,4961,1,0,0,0,4977,4971,1,0,0,0,4977,4973,1,0,0,
  	0,4978,4999,1,0,0,0,4979,4980,4,318,122,0,4980,4981,3,644,322,0,4981,
  	4982,3,1296,648,0,4982,4999,1,0,0,0,4983,4984,4,318,123,0,4984,4996,3,
  	1322,661,0,4985,4986,5,168,0,0,4986,4990,5,684,0,0,4987,4991,5,56,0,0,
  	4988,4991,5,399,0,0,4989,4991,3,696,348,0,4990,4987,1,0,0,0,4990,4988,
  	1,0,0,0,4990,4989,1,0,0,0,4991,4997,1,0,0,0,4992,4994,4,318,124,0,4993,
  	4995,3,1314,657,0,4994,4993,1,0,0,0,4994,4995,1,0,0,0,4995,4997,1,0,0,
  	0,4996,4985,1,0,0,0,4996,4992,1,0,0,0,4997,4999,1,0,0,0,4998,4953,1,0,
  	0,0,4998,4957,1,0,0,0,4998,4979,1,0,0,0,4998,4983,1,0,0,0,4999,637,1,
  	0,0,0,5000,5005,3,640,320,0,5001,5002,5,29,0,0,5002,5004,3,640,320,0,
  	5003,5001,1,0,0,0,5004,5007,1,0,0,0,5005,5003,1,0,0,0,5005,5006,1,0,0,
  	0,5006,639,1,0,0,0,5007,5005,1,0,0,0,5008,5009,4,320,125,0,5009,5087,
  	3,642,321,0,5010,5011,4,320,126,0,5011,5084,3,1322,661,0,5012,5021,3,
  	1296,648,0,5013,5014,5,488,0,0,5014,5016,3,1458,729,0,5015,5017,3,1310,
  	655,0,5016,5015,1,0,0,0,5016,5017,1,0,0,0,5017,5022,1,0,0,0,5018,5020,
  	3,1310,655,0,5019,5018,1,0,0,0,5019,5020,1,0,0,0,5020,5022,1,0,0,0,5021,
  	5013,1,0,0,0,5021,5019,1,0,0,0,5022,5085,1,0,0,0,5023,5032,3,1298,649,
  	0,5024,5026,3,1310,655,0,5025,5024,1,0,0,0,5025,5026,1,0,0,0,5026,5033,
  	1,0,0,0,5027,5028,5,488,0,0,5028,5030,3,1458,729,0,5029,5031,3,1310,655,
  	0,5030,5029,1,0,0,0,5030,5031,1,0,0,0,5031,5033,1,0,0,0,5032,5025,1,0,
  	0,0,5032,5027,1,0,0,0,5033,5085,1,0,0,0,5034,5085,3,1300,650,0,5035,5037,
  	3,1302,651,0,5036,5038,3,1310,655,0,5037,5036,1,0,0,0,5037,5038,1,0,0,
  	0,5038,5085,1,0,0,0,5039,5048,3,1304,652,0,5040,5041,5,488,0,0,5041,5043,
  	3,1458,729,0,5042,5044,3,1310,655,0,5043,5042,1,0,0,0,5043,5044,1,0,0,
  	0,5044,5049,1,0,0,0,5045,5047,3,1310,655,0,5046,5045,1,0,0,0,5046,5047,
  	1,0,0,0,5047,5049,1,0,0,0,5048,5040,1,0,0,0,5048,5046,1,0,0,0,5049,5085,
  	1,0,0,0,5050,5052,3,1306,653,0,5051,5053,3,1310,655,0,5052,5051,1,0,0,
  	0,5052,5053,1,0,0,0,5053,5085,1,0,0,0,5054,5056,3,1312,656,0,5055,5054,
  	1,0,0,0,5055,5056,1,0,0,0,5056,5085,1,0,0,0,5057,5058,4,320,127,0,5058,
  	5059,5,50,0,0,5059,5060,3,1316,658,0,5060,5065,3,1294,647,0,5061,5062,
  	5,50,0,0,5062,5063,3,1316,658,0,5063,5064,3,1294,647,0,5064,5066,1,0,
  	0,0,5065,5061,1,0,0,0,5065,5066,1,0,0,0,5066,5085,1,0,0,0,5067,5068,4,
  	320,128,0,5068,5069,5,379,0,0,5069,5070,3,1316,658,0,5070,5075,3,1294,
  	647,0,5071,5072,5,379,0,0,5072,5073,3,1316,658,0,5073,5074,3,1294,647,
  	0,5074,5076,1,0,0,0,5075,5071,1,0,0,0,5075,5076,1,0,0,0,5076,5085,1,0,
  	0,0,5077,5078,4,320,129,0,5078,5079,5,187,0,0,5079,5082,3,1316,658,0,
  	5080,5081,5,187,0,0,5081,5083,3,1316,658,0,5082,5080,1,0,0,0,5082,5083,
  	1,0,0,0,5083,5085,1,0,0,0,5084,5012,1,0,0,0,5084,5023,1,0,0,0,5084,5034,
  	1,0,0,0,5084,5035,1,0,0,0,5084,5039,1,0,0,0,5084,5050,1,0,0,0,5084,5055,
  	1,0,0,0,5084,5057,1,0,0,0,5084,5067,1,0,0,0,5084,5077,1,0,0,0,5085,5087,
  	1,0,0,0,5086,5008,1,0,0,0,5086,5010,1,0,0,0,5087,641,1,0,0,0,5088,5089,
  	3,1322,661,0,5089,5090,5,266,0,0,5090,5109,5,90,0,0,5091,5094,3,1460,
  	730,0,5092,5093,4,321,130,0,5093,5095,3,1318,659,0,5094,5092,1,0,0,0,
  	5094,5095,1,0,0,0,5095,5098,1,0,0,0,5096,5097,4,321,131,0,5097,5099,3,
  	1310,655,0,5098,5096,1,0,0,0,5098,5099,1,0,0,0,5099,5110,1,0,0,0,5100,
  	5101,4,321,132,0,5101,5102,5,759,0,0,5102,5104,5,436,0,0,5103,5105,3,
  	1318,659,0,5104,5103,1,0,0,0,5104,5105,1,0,0,0,5105,5107,1,0,0,0,5106,
  	5108,3,1310,655,0,5107,5106,1,0,0,0,5107,5108,1,0,0,0,5108,5110,1,0,0,
  	0,5109,5091,1,0,0,0,5109,5100,1,0,0,0,5110,5146,1,0,0,0,5111,5112,3,1322,
  	661,0,5112,5113,5,266,0,0,5113,5114,5,670,0,0,5114,5138,3,1486,743,0,
  	5115,5116,5,90,0,0,5116,5119,3,1460,730,0,5117,5118,4,321,133,0,5118,
  	5120,3,1318,659,0,5119,5117,1,0,0,0,5119,5120,1,0,0,0,5120,5123,1,0,0,
  	0,5121,5122,4,321,134,0,5122,5124,3,1310,655,0,5123,5121,1,0,0,0,5123,
  	5124,1,0,0,0,5124,5139,1,0,0,0,5125,5126,5,63,0,0,5126,5129,3,1462,731,
  	0,5127,5128,4,321,135,0,5128,5130,3,1310,655,0,5129,5127,1,0,0,0,5129,
  	5130,1,0,0,0,5130,5139,1,0,0,0,5131,5132,4,321,136,0,5132,5133,5,90,0,
  	0,5133,5134,5,759,0,0,5134,5136,5,436,0,0,5135,5137,3,1310,655,0,5136,
  	5135,1,0,0,0,5136,5137,1,0,0,0,5137,5139,1,0,0,0,5138,5115,1,0,0,0,5138,
  	5125,1,0,0,0,5138,5131,1,0,0,0,5138,5139,1,0,0,0,5139,5146,1,0,0,0,5140,
  	5141,4,321,137,0,5141,5143,3,1322,661,0,5142,5144,3,1312,656,0,5143,5142,
  	1,0,0,0,5143,5144,1,0,0,0,5144,5146,1,0,0,0,5145,5088,1,0,0,0,5145,5111,
  	1,0,0,0,5145,5140,1,0,0,0,5146,643,1,0,0,0,5147,5148,5,644,0,0,5148,5149,
  	3,1494,747,0,5149,645,1,0,0,0,5150,5151,5,140,0,0,5151,5154,5,644,0,0,
  	5152,5153,4,323,138,0,5153,5155,3,1256,628,0,5154,5152,1,0,0,0,5154,5155,
  	1,0,0,0,5155,5156,1,0,0,0,5156,5157,3,1288,644,0,5157,5158,3,652,326,
  	0,5158,5159,3,648,324,0,5159,647,1,0,0,0,5160,5162,4,324,139,0,5161,5163,
  	3,654,327,0,5162,5161,1,0,0,0,5162,5163,1,0,0,0,5163,5165,1,0,0,0,5164,
  	5166,3,656,328,0,5165,5164,1,0,0,0,5165,5166,1,0,0,0,5166,5170,1,0,0,
  	0,5167,5169,3,658,329,0,5168,5167,1,0,0,0,5169,5172,1,0,0,0,5170,5168,
  	1,0,0,0,5170,5171,1,0,0,0,5171,5175,1,0,0,0,5172,5170,1,0,0,0,5173,5174,
  	4,324,140,0,5174,5176,3,650,325,0,5175,5173,1,0,0,0,5175,5176,1,0,0,0,
  	5176,5179,1,0,0,0,5177,5179,1,0,0,0,5178,5160,1,0,0,0,5178,5177,1,0,0,
  	0,5179,649,1,0,0,0,5180,5181,5,773,0,0,5181,5185,3,1458,729,0,5182,5183,
  	5,119,0,0,5183,5185,3,1458,729,0,5184,5180,1,0,0,0,5184,5182,1,0,0,0,
  	5185,651,1,0,0,0,5186,5190,4,326,141,0,5187,5188,5,168,0,0,5188,5189,
  	5,684,0,0,5189,5191,3,696,348,0,5190,5187,1,0,0,0,5190,5191,1,0,0,0,5191,
  	5194,1,0,0,0,5192,5194,1,0,0,0,5193,5186,1,0,0,0,5193,5192,1,0,0,0,5194,
  	653,1,0,0,0,5195,5198,5,497,0,0,5196,5199,3,688,344,0,5197,5199,7,74,
  	0,0,5198,5196,1,0,0,0,5198,5197,1,0,0,0,5199,655,1,0,0,0,5200,5209,5,
  	670,0,0,5201,5202,5,354,0,0,5202,5210,3,1438,719,0,5203,5204,5,359,0,
  	0,5204,5210,3,1438,719,0,5205,5206,5,353,0,0,5206,5210,3,1438,719,0,5207,
  	5208,5,360,0,0,5208,5210,3,1438,719,0,5209,5201,1,0,0,0,5209,5203,1,0,
  	0,0,5209,5205,1,0,0,0,5209,5207,1,0,0,0,5210,5211,1,0,0,0,5211,5209,1,
  	0,0,0,5211,5212,1,0,0,0,5212,657,1,0,0,0,5213,5214,5,48,0,0,5214,5256,
  	7,75,0,0,5215,5244,5,436,0,0,5216,5223,5,216,0,0,5217,5218,5,282,0,0,
  	5218,5219,3,1440,720,0,5219,5220,5,163,0,0,5220,5224,1,0,0,0,5221,5224,
  	5,395,0,0,5222,5224,5,168,0,0,5223,5217,1,0,0,0,5223,5221,1,0,0,0,5223,
  	5222,1,0,0,0,5223,5224,1,0,0,0,5224,5245,1,0,0,0,5225,5228,5,730,0,0,
  	5226,5229,3,1440,720,0,5227,5229,5,168,0,0,5228,5226,1,0,0,0,5228,5227,
  	1,0,0,0,5229,5245,1,0,0,0,5230,5231,5,731,0,0,5231,5236,5,282,0,0,5232,
  	5233,3,1440,720,0,5233,5234,5,163,0,0,5234,5237,1,0,0,0,5235,5237,5,168,
  	0,0,5236,5232,1,0,0,0,5236,5235,1,0,0,0,5237,5245,1,0,0,0,5238,5239,4,
  	329,142,0,5239,5240,5,497,0,0,5240,5242,5,144,0,0,5241,5243,7,76,0,0,
  	5242,5241,1,0,0,0,5242,5243,1,0,0,0,5243,5245,1,0,0,0,5244,5216,1,0,0,
  	0,5244,5225,1,0,0,0,5244,5230,1,0,0,0,5244,5238,1,0,0,0,5245,5256,1,0,
  	0,0,5246,5247,4,329,143,0,5247,5248,5,766,0,0,5248,5256,3,1440,720,0,
  	5249,5250,4,329,144,0,5250,5253,5,765,0,0,5251,5254,3,1440,720,0,5252,
  	5254,5,723,0,0,5253,5251,1,0,0,0,5253,5252,1,0,0,0,5254,5256,1,0,0,0,
  	5255,5213,1,0,0,0,5255,5215,1,0,0,0,5255,5246,1,0,0,0,5255,5249,1,0,0,
  	0,5256,659,1,0,0,0,5257,5258,5,187,0,0,5258,5261,5,644,0,0,5259,5260,
  	4,330,145,0,5260,5262,3,1250,625,0,5261,5259,1,0,0,0,5261,5262,1,0,0,
  	0,5262,5263,1,0,0,0,5263,5264,3,1286,643,0,5264,661,1,0,0,0,5265,5308,
  	5,251,0,0,5266,5267,4,331,146,0,5267,5268,3,682,341,0,5268,5269,5,616,
  	0,0,5269,5273,3,1286,643,0,5270,5271,5,670,0,0,5271,5272,5,685,0,0,5272,
  	5274,5,421,0,0,5273,5270,1,0,0,0,5273,5274,1,0,0,0,5274,5309,1,0,0,0,
  	5275,5281,3,682,341,0,5276,5278,5,56,0,0,5277,5279,5,451,0,0,5278,5277,
  	1,0,0,0,5278,5279,1,0,0,0,5279,5281,1,0,0,0,5280,5275,1,0,0,0,5280,5276,
  	1,0,0,0,5281,5282,1,0,0,0,5282,5284,5,413,0,0,5283,5285,3,680,340,0,5284,
  	5283,1,0,0,0,5284,5285,1,0,0,0,5285,5286,1,0,0,0,5286,5287,3,686,343,
  	0,5287,5288,5,616,0,0,5288,5290,3,664,332,0,5289,5291,3,674,337,0,5290,
  	5289,1,0,0,0,5290,5291,1,0,0,0,5291,5293,1,0,0,0,5292,5294,3,666,333,
  	0,5293,5292,1,0,0,0,5293,5294,1,0,0,0,5294,5296,1,0,0,0,5295,5297,3,672,
  	336,0,5296,5295,1,0,0,0,5296,5297,1,0,0,0,5297,5309,1,0,0,0,5298,5299,
  	5,457,0,0,5299,5300,5,413,0,0,5300,5301,3,1322,661,0,5301,5302,5,616,
  	0,0,5302,5306,3,664,332,0,5303,5304,5,670,0,0,5304,5305,5,251,0,0,5305,
  	5307,5,421,0,0,5306,5303,1,0,0,0,5306,5307,1,0,0,0,5307,5309,1,0,0,0,
  	5308,5266,1,0,0,0,5308,5280,1,0,0,0,5308,5298,1,0,0,0,5309,663,1,0,0,
  	0,5310,5311,4,332,147,0,5311,5315,3,1288,644,0,5312,5313,4,332,148,0,
  	5313,5315,3,1286,643,0,5314,5310,1,0,0,0,5314,5312,1,0,0,0,5315,665,1,
  	0,0,0,5316,5317,5,670,0,0,5317,5318,3,692,346,0,5318,667,1,0,0,0,5319,
  	5320,5,688,0,0,5320,5321,3,696,348,0,5321,669,1,0,0,0,5322,5323,5,670,
  	0,0,5323,5331,5,684,0,0,5324,5332,3,696,348,0,5325,5327,5,56,0,0,5326,
  	5328,3,668,334,0,5327,5326,1,0,0,0,5327,5328,1,0,0,0,5328,5332,1,0,0,
  	0,5329,5332,5,399,0,0,5330,5332,5,168,0,0,5331,5324,1,0,0,0,5331,5325,
  	1,0,0,0,5331,5329,1,0,0,0,5331,5330,1,0,0,0,5332,671,1,0,0,0,5333,5334,
  	5,63,0,0,5334,5336,5,644,0,0,5335,5337,3,670,335,0,5336,5335,1,0,0,0,
  	5336,5337,1,0,0,0,5337,673,1,0,0,0,5338,5339,4,337,149,0,5339,5340,3,
  	654,327,0,5340,675,1,0,0,0,5341,5342,5,483,0,0,5342,5343,5,644,0,0,5343,
  	5344,3,1322,661,0,5344,5345,5,616,0,0,5345,5353,3,1322,661,0,5346,5347,
  	5,29,0,0,5347,5348,3,1322,661,0,5348,5349,5,616,0,0,5349,5350,3,1322,
  	661,0,5350,5352,1,0,0,0,5351,5346,1,0,0,0,5352,5355,1,0,0,0,5353,5351,
  	1,0,0,0,5353,5354,1,0,0,0,5354,677,1,0,0,0,5355,5353,1,0,0,0,5356,5359,
  	5,507,0,0,5357,5358,4,339,150,0,5358,5360,3,1250,625,0,5359,5357,1,0,
  	0,0,5359,5360,1,0,0,0,5360,5398,1,0,0,0,5361,5362,4,339,151,0,5362,5363,
  	3,682,341,0,5363,5364,5,239,0,0,5364,5365,3,1286,643,0,5365,5399,1,0,
  	0,0,5366,5367,3,682,341,0,5367,5369,5,413,0,0,5368,5370,3,680,340,0,5369,
  	5368,1,0,0,0,5369,5370,1,0,0,0,5370,5371,1,0,0,0,5371,5372,3,686,343,
  	0,5372,5373,5,239,0,0,5373,5374,3,1286,643,0,5374,5399,1,0,0,0,5375,5377,
  	5,56,0,0,5376,5378,5,451,0,0,5377,5376,1,0,0,0,5377,5378,1,0,0,0,5378,
  	5388,1,0,0,0,5379,5380,4,339,152,0,5380,5382,5,413,0,0,5381,5383,3,680,
  	340,0,5382,5381,1,0,0,0,5382,5383,1,0,0,0,5383,5384,1,0,0,0,5384,5389,
  	3,686,343,0,5385,5386,5,29,0,0,5386,5387,5,251,0,0,5387,5389,5,421,0,
  	0,5388,5379,1,0,0,0,5388,5385,1,0,0,0,5389,5390,1,0,0,0,5390,5391,5,239,
  	0,0,5391,5399,3,1286,643,0,5392,5393,5,457,0,0,5393,5394,5,413,0,0,5394,
  	5395,3,1322,661,0,5395,5396,5,239,0,0,5396,5397,3,1286,643,0,5397,5399,
  	1,0,0,0,5398,5361,1,0,0,0,5398,5366,1,0,0,0,5398,5375,1,0,0,0,5398,5392,
  	1,0,0,0,5399,5402,1,0,0,0,5400,5401,4,339,153,0,5401,5403,3,1258,629,
  	0,5402,5400,1,0,0,0,5402,5403,1,0,0,0,5403,679,1,0,0,0,5404,5405,7,77,
  	0,0,5405,681,1,0,0,0,5406,5411,3,684,342,0,5407,5408,5,29,0,0,5408,5410,
  	3,684,342,0,5409,5407,1,0,0,0,5410,5413,1,0,0,0,5411,5409,1,0,0,0,5411,
  	5412,1,0,0,0,5412,683,1,0,0,0,5413,5411,1,0,0,0,5414,5425,4,342,154,0,
  	5415,5417,3,1490,745,0,5416,5418,3,1340,670,0,5417,5416,1,0,0,0,5417,
  	5418,1,0,0,0,5418,5426,1,0,0,0,5419,5420,3,1490,745,0,5420,5423,5,39,
  	0,0,5421,5424,3,1486,743,0,5422,5424,5,854,0,0,5423,5421,1,0,0,0,5423,
  	5422,1,0,0,0,5424,5426,1,0,0,0,5425,5415,1,0,0,0,5425,5419,1,0,0,0,5426,
  	5459,1,0,0,0,5427,5429,7,78,0,0,5428,5430,3,1340,670,0,5429,5428,1,0,
  	0,0,5429,5430,1,0,0,0,5430,5459,1,0,0,0,5431,5459,7,79,0,0,5432,5433,
  	5,251,0,0,5433,5459,5,421,0,0,5434,5435,5,536,0,0,5435,5459,5,152,0,0,
  	5436,5440,5,140,0,0,5437,5438,5,603,0,0,5438,5441,5,597,0,0,5439,5441,
  	7,80,0,0,5440,5437,1,0,0,0,5440,5439,1,0,0,0,5440,5441,1,0,0,0,5441,5459,
  	1,0,0,0,5442,5443,5,319,0,0,5443,5459,5,597,0,0,5444,5447,5,489,0,0,5445,
  	5448,5,109,0,0,5446,5448,3,620,310,0,5447,5445,1,0,0,0,5447,5446,1,0,
  	0,0,5448,5459,1,0,0,0,5449,5450,5,536,0,0,5450,5459,5,661,0,0,5451,5453,
  	5,57,0,0,5452,5454,5,512,0,0,5453,5452,1,0,0,0,5453,5454,1,0,0,0,5454,
  	5459,1,0,0,0,5455,5456,4,342,155,0,5456,5457,7,81,0,0,5457,5459,5,684,
  	0,0,5458,5414,1,0,0,0,5458,5427,1,0,0,0,5458,5431,1,0,0,0,5458,5432,1,
  	0,0,0,5458,5434,1,0,0,0,5458,5436,1,0,0,0,5458,5442,1,0,0,0,5458,5444,
  	1,0,0,0,5458,5449,1,0,0,0,5458,5451,1,0,0,0,5458,5455,1,0,0,0,5459,685,
  	1,0,0,0,5460,5463,5,16,0,0,5461,5462,5,28,0,0,5462,5464,5,16,0,0,5463,
  	5461,1,0,0,0,5463,5464,1,0,0,0,5464,5477,1,0,0,0,5465,5468,3,1354,677,
  	0,5466,5467,5,28,0,0,5467,5469,5,16,0,0,5468,5466,1,0,0,0,5468,5469,1,
  	0,0,0,5469,5477,1,0,0,0,5470,5477,3,1398,699,0,5471,5472,4,343,156,0,
  	5472,5473,3,1354,677,0,5473,5474,5,28,0,0,5474,5475,3,1398,699,0,5475,
  	5477,1,0,0,0,5476,5460,1,0,0,0,5476,5465,1,0,0,0,5476,5470,1,0,0,0,5476,
  	5471,1,0,0,0,5477,687,1,0,0,0,5478,5485,3,690,345,0,5479,5481,5,61,0,
  	0,5480,5479,1,0,0,0,5480,5481,1,0,0,0,5481,5482,1,0,0,0,5482,5484,3,690,
  	345,0,5483,5480,1,0,0,0,5484,5487,1,0,0,0,5485,5483,1,0,0,0,5485,5486,
  	1,0,0,0,5486,689,1,0,0,0,5487,5485,1,0,0,0,5488,5489,5,107,0,0,5489,5495,
  	3,1460,730,0,5490,5491,5,293,0,0,5491,5495,3,1460,730,0,5492,5493,5,585,
  	0,0,5493,5495,3,1460,730,0,5494,5488,1,0,0,0,5494,5490,1,0,0,0,5494,5492,
  	1,0,0,0,5495,691,1,0,0,0,5496,5497,5,251,0,0,5497,5510,5,421,0,0,5498,
  	5507,4,346,157,0,5499,5500,5,354,0,0,5500,5508,3,1438,719,0,5501,5502,
  	5,359,0,0,5502,5508,3,1438,719,0,5503,5504,5,353,0,0,5504,5508,3,1438,
  	719,0,5505,5506,5,360,0,0,5506,5508,3,1438,719,0,5507,5499,1,0,0,0,5507,
  	5501,1,0,0,0,5507,5503,1,0,0,0,5507,5505,1,0,0,0,5508,5510,1,0,0,0,5509,
  	5496,1,0,0,0,5509,5498,1,0,0,0,5510,693,1,0,0,0,5511,5512,5,533,0,0,5512,
  	5513,5,684,0,0,5513,5535,3,696,348,0,5514,5515,5,533,0,0,5515,5516,5,
  	684,0,0,5516,5535,7,82,0,0,5517,5518,5,533,0,0,5518,5519,5,168,0,0,5519,
  	5523,5,684,0,0,5520,5524,3,696,348,0,5521,5524,5,399,0,0,5522,5524,5,
  	56,0,0,5523,5520,1,0,0,0,5523,5521,1,0,0,0,5523,5522,1,0,0,0,5524,5525,
  	1,0,0,0,5525,5526,5,616,0,0,5526,5535,3,696,348,0,5527,5528,5,533,0,0,
  	5528,5529,5,684,0,0,5529,5532,5,56,0,0,5530,5531,5,688,0,0,5531,5533,
  	3,696,348,0,5532,5530,1,0,0,0,5532,5533,1,0,0,0,5533,5535,1,0,0,0,5534,
  	5511,1,0,0,0,5534,5514,1,0,0,0,5534,5517,1,0,0,0,5534,5527,1,0,0,0,5535,
  	695,1,0,0,0,5536,5541,3,698,349,0,5537,5538,5,29,0,0,5538,5540,3,698,
  	349,0,5539,5537,1,0,0,0,5540,5543,1,0,0,0,5541,5539,1,0,0,0,5541,5542,
  	1,0,0,0,5542,697,1,0,0,0,5543,5541,1,0,0,0,5544,5550,3,1490,745,0,5545,
  	5548,5,39,0,0,5546,5549,3,1486,743,0,5547,5549,5,854,0,0,5548,5546,1,
  	0,0,0,5548,5547,1,0,0,0,5549,5551,1,0,0,0,5550,5545,1,0,0,0,5550,5551,
  	1,0,0,0,5551,699,1,0,0,0,5552,5554,5,60,0,0,5553,5555,3,1330,665,0,5554,
  	5553,1,0,0,0,5554,5555,1,0,0,0,5555,5556,1,0,0,0,5556,5557,5,600,0,0,
  	5557,5560,3,1400,700,0,5558,5559,4,350,158,0,5559,5561,3,708,354,0,5560,
  	5558,1,0,0,0,5560,5561,1,0,0,0,5561,5596,1,0,0,0,5562,5563,5,106,0,0,
  	5563,5564,5,600,0,0,5564,5568,3,1400,700,0,5565,5567,3,710,355,0,5566,
  	5565,1,0,0,0,5567,5570,1,0,0,0,5568,5566,1,0,0,0,5568,5569,1,0,0,0,5569,
  	5596,1,0,0,0,5570,5568,1,0,0,0,5571,5572,5,105,0,0,5572,5573,5,600,0,
  	0,5573,5575,3,1400,700,0,5574,5576,7,83,0,0,5575,5574,1,0,0,0,5575,5576,
  	1,0,0,0,5576,5596,1,0,0,0,5577,5579,5,418,0,0,5578,5580,3,1330,665,0,
  	5579,5578,1,0,0,0,5579,5580,1,0,0,0,5580,5581,1,0,0,0,5581,5582,5,600,
  	0,0,5582,5596,3,1400,700,0,5583,5585,5,485,0,0,5584,5586,3,1330,665,0,
  	5585,5584,1,0,0,0,5585,5586,1,0,0,0,5586,5587,1,0,0,0,5587,5588,5,600,
  	0,0,5588,5592,3,1400,700,0,5589,5591,3,712,356,0,5590,5589,1,0,0,0,5591,
  	5594,1,0,0,0,5592,5590,1,0,0,0,5592,5593,1,0,0,0,5593,5596,1,0,0,0,5594,
  	5592,1,0,0,0,5595,5552,1,0,0,0,5595,5562,1,0,0,0,5595,5571,1,0,0,0,5595,
  	5577,1,0,0,0,5595,5583,1,0,0,0,5596,701,1,0,0,0,5597,5598,4,351,159,0,
  	5598,5599,7,84,0,0,5599,5600,5,640,0,0,5600,703,1,0,0,0,5601,5603,3,706,
  	353,0,5602,5601,1,0,0,0,5602,5603,1,0,0,0,5603,5605,1,0,0,0,5604,5606,
  	3,702,351,0,5605,5604,1,0,0,0,5605,5606,1,0,0,0,5606,5612,1,0,0,0,5607,
  	5608,4,352,160,0,5608,5609,5,647,0,0,5609,5610,5,154,0,0,5610,5612,3,
  	1458,729,0,5611,5602,1,0,0,0,5611,5607,1,0,0,0,5612,705,1,0,0,0,5613,
  	5614,5,670,0,0,5614,5615,5,3,0,0,5615,5616,5,700,0,0,5616,707,1,0,0,0,
  	5617,5618,5,640,0,0,5618,5619,5,699,0,0,5619,5620,5,413,0,0,5620,5621,
  	3,1428,714,0,5621,5622,3,704,352,0,5622,5628,1,0,0,0,5623,5624,5,187,
  	0,0,5624,5625,5,699,0,0,5625,5626,5,413,0,0,5626,5628,3,1428,714,0,5627,
  	5617,1,0,0,0,5627,5623,1,0,0,0,5628,709,1,0,0,0,5629,5630,5,236,0,0,5630,
  	5633,5,641,0,0,5631,5633,7,85,0,0,5632,5629,1,0,0,0,5632,5631,1,0,0,0,
  	5633,711,1,0,0,0,5634,5635,7,86,0,0,5635,713,1,0,0,0,5636,5648,5,633,
  	0,0,5637,5638,5,440,0,0,5638,5649,3,1412,706,0,5639,5640,5,689,0,0,5640,
  	5645,3,1414,707,0,5641,5642,5,29,0,0,5642,5644,3,1414,707,0,5643,5641,
  	1,0,0,0,5644,5647,1,0,0,0,5645,5643,1,0,0,0,5645,5646,1,0,0,0,5646,5649,
  	1,0,0,0,5647,5645,1,0,0,0,5648,5637,1,0,0,0,5648,5639,1,0,0,0,5649,715,
  	1,0,0,0,5650,5661,5,281,0,0,5651,5652,5,440,0,0,5652,5653,3,1426,713,
  	0,5653,5654,5,546,0,0,5654,5655,3,1458,729,0,5655,5662,1,0,0,0,5656,5657,
  	5,689,0,0,5657,5659,3,1468,734,0,5658,5660,3,724,362,0,5659,5658,1,0,
  	0,0,5659,5660,1,0,0,0,5660,5662,1,0,0,0,5661,5651,1,0,0,0,5661,5656,1,
  	0,0,0,5662,717,1,0,0,0,5663,5664,7,87,0,0,5664,719,1,0,0,0,5665,5668,
  	3,924,462,0,5666,5668,5,413,0,0,5667,5665,1,0,0,0,5667,5666,1,0,0,0,5668,
  	721,1,0,0,0,5669,5670,3,718,359,0,5670,5671,3,1008,504,0,5671,5672,3,
  	1496,748,0,5672,5673,3,720,360,0,5673,723,1,0,0,0,5674,5675,4,362,161,
  	0,5675,5676,5,533,0,0,5676,5681,3,722,361,0,5677,5678,5,29,0,0,5678,5680,
  	3,722,361,0,5679,5677,1,0,0,0,5680,5683,1,0,0,0,5681,5679,1,0,0,0,5681,
  	5682,1,0,0,0,5682,725,1,0,0,0,5683,5681,1,0,0,0,5684,5685,5,533,0,0,5685,
  	5686,3,728,364,0,5686,727,1,0,0,0,5687,5688,3,738,369,0,5688,5689,3,736,
  	368,0,5689,5744,1,0,0,0,5690,5691,5,618,0,0,5691,5744,3,730,365,0,5692,
  	5693,3,1498,749,0,5693,5694,3,742,371,0,5694,5744,1,0,0,0,5695,5698,5,
  	436,0,0,5696,5697,5,236,0,0,5697,5699,3,1322,661,0,5698,5696,1,0,0,0,
  	5698,5699,1,0,0,0,5699,5700,1,0,0,0,5700,5727,3,1496,748,0,5701,5703,
  	3,1460,730,0,5702,5704,3,1318,659,0,5703,5702,1,0,0,0,5703,5704,1,0,0,
  	0,5704,5706,1,0,0,0,5705,5707,3,1310,655,0,5706,5705,1,0,0,0,5706,5707,
  	1,0,0,0,5707,5728,1,0,0,0,5708,5710,3,1460,730,0,5709,5711,3,1318,659,
  	0,5710,5709,1,0,0,0,5710,5711,1,0,0,0,5711,5713,1,0,0,0,5712,5714,3,1310,
  	655,0,5713,5712,1,0,0,0,5713,5714,1,0,0,0,5714,5728,1,0,0,0,5715,5716,
  	4,364,162,0,5716,5717,5,412,0,0,5717,5718,5,32,0,0,5718,5719,3,1460,730,
  	0,5719,5720,5,33,0,0,5720,5728,1,0,0,0,5721,5722,4,364,163,0,5722,5723,
  	5,436,0,0,5723,5724,5,32,0,0,5724,5725,3,1460,730,0,5725,5726,5,33,0,
  	0,5726,5728,1,0,0,0,5727,5701,1,0,0,0,5727,5708,1,0,0,0,5727,5715,1,0,
  	0,0,5727,5721,1,0,0,0,5728,5744,1,0,0,0,5729,5730,4,364,164,0,5730,5733,
  	5,436,0,0,5731,5732,5,236,0,0,5732,5734,3,1322,661,0,5733,5731,1,0,0,
  	0,5733,5734,1,0,0,0,5734,5735,1,0,0,0,5735,5736,5,616,0,0,5736,5738,5,
  	759,0,0,5737,5739,3,1318,659,0,5738,5737,1,0,0,0,5738,5739,1,0,0,0,5739,
  	5741,1,0,0,0,5740,5742,3,1310,655,0,5741,5740,1,0,0,0,5741,5742,1,0,0,
  	0,5742,5744,1,0,0,0,5743,5687,1,0,0,0,5743,5690,1,0,0,0,5743,5692,1,0,
  	0,0,5743,5695,1,0,0,0,5743,5729,1,0,0,0,5744,729,1,0,0,0,5745,5747,3,
  	732,366,0,5746,5748,3,734,367,0,5747,5746,1,0,0,0,5747,5748,1,0,0,0,5748,
  	5755,1,0,0,0,5749,5752,3,734,367,0,5750,5751,5,29,0,0,5751,5753,3,732,
  	366,0,5752,5750,1,0,0,0,5752,5753,1,0,0,0,5753,5755,1,0,0,0,5754,5745,
  	1,0,0,0,5754,5749,1,0,0,0,5755,731,1,0,0,0,5756,5757,5,465,0,0,5757,5758,
  	7,40,0,0,5758,733,1,0,0,0,5759,5760,5,292,0,0,5760,5766,5,308,0,0,5761,
  	5762,5,486,0,0,5762,5767,5,465,0,0,5763,5764,5,465,0,0,5764,5767,7,88,
  	0,0,5765,5767,5,527,0,0,5766,5761,1,0,0,0,5766,5763,1,0,0,0,5766,5765,
  	1,0,0,0,5767,735,1,0,0,0,5768,5769,5,29,0,0,5769,5771,3,740,370,0,5770,
  	5768,1,0,0,0,5771,5774,1,0,0,0,5772,5770,1,0,0,0,5772,5773,1,0,0,0,5773,
  	737,1,0,0,0,5774,5772,1,0,0,0,5775,5776,3,1008,504,0,5776,5777,3,1496,
  	748,0,5777,5778,3,746,373,0,5778,5806,1,0,0,0,5779,5806,3,1276,638,0,
  	5780,5781,3,1000,500,0,5781,5782,3,1496,748,0,5782,5783,3,924,462,0,5783,
  	5806,1,0,0,0,5784,5785,5,39,0,0,5785,5787,5,39,0,0,5786,5788,3,1502,751,
  	0,5787,5786,1,0,0,0,5787,5788,1,0,0,0,5788,5789,1,0,0,0,5789,5790,3,1008,
  	504,0,5790,5791,3,1496,748,0,5791,5792,3,746,373,0,5792,5806,1,0,0,0,
  	5793,5803,5,387,0,0,5794,5795,3,1496,748,0,5795,5796,3,924,462,0,5796,
  	5804,1,0,0,0,5797,5799,3,1204,602,0,5798,5800,3,1264,632,0,5799,5798,
  	1,0,0,0,5799,5800,1,0,0,0,5800,5804,1,0,0,0,5801,5802,4,369,165,0,5802,
  	5804,5,168,0,0,5803,5794,1,0,0,0,5803,5797,1,0,0,0,5803,5801,1,0,0,0,
  	5804,5806,1,0,0,0,5805,5775,1,0,0,0,5805,5779,1,0,0,0,5805,5780,1,0,0,
  	0,5805,5784,1,0,0,0,5805,5793,1,0,0,0,5806,739,1,0,0,0,5807,5808,3,1498,
  	749,0,5808,5809,3,1008,504,0,5809,5810,3,1496,748,0,5810,5811,3,746,373,
  	0,5811,5814,1,0,0,0,5812,5814,3,738,369,0,5813,5807,1,0,0,0,5813,5812,
  	1,0,0,0,5814,741,1,0,0,0,5815,5816,3,744,372,0,5816,5817,3,736,368,0,
  	5817,5821,1,0,0,0,5818,5819,5,618,0,0,5819,5821,3,730,365,0,5820,5815,
  	1,0,0,0,5820,5818,1,0,0,0,5821,743,1,0,0,0,5822,5823,3,1008,504,0,5823,
  	5824,3,1496,748,0,5824,5825,3,746,373,0,5825,745,1,0,0,0,5826,5836,3,
  	924,462,0,5827,5836,5,168,0,0,5828,5836,5,413,0,0,5829,5836,5,56,0,0,
  	5830,5836,5,77,0,0,5831,5832,4,373,166,0,5832,5836,5,516,0,0,5833,5834,
  	4,373,167,0,5834,5836,5,735,0,0,5835,5826,1,0,0,0,5835,5827,1,0,0,0,5835,
  	5828,1,0,0,0,5835,5829,1,0,0,0,5835,5830,1,0,0,0,5835,5831,1,0,0,0,5835,
  	5833,1,0,0,0,5836,747,1,0,0,0,5837,5838,5,536,0,0,5838,5840,5,152,0,0,
  	5839,5841,3,1326,663,0,5840,5839,1,0,0,0,5840,5841,1,0,0,0,5841,749,1,
  	0,0,0,5842,5844,5,536,0,0,5843,5845,3,842,421,0,5844,5843,1,0,0,0,5844,
  	5845,1,0,0,0,5845,5846,1,0,0,0,5846,5848,5,597,0,0,5847,5849,3,848,424,
  	0,5848,5847,1,0,0,0,5848,5849,1,0,0,0,5849,5851,1,0,0,0,5850,5852,3,1326,
  	663,0,5851,5850,1,0,0,0,5851,5852,1,0,0,0,5852,751,1,0,0,0,5853,5855,
  	5,536,0,0,5854,5856,5,240,0,0,5855,5854,1,0,0,0,5855,5856,1,0,0,0,5856,
  	5857,1,0,0,0,5857,5859,5,619,0,0,5858,5860,3,848,424,0,5859,5858,1,0,
  	0,0,5859,5860,1,0,0,0,5860,5862,1,0,0,0,5861,5863,3,1326,663,0,5862,5861,
  	1,0,0,0,5862,5863,1,0,0,0,5863,753,1,0,0,0,5864,5865,5,536,0,0,5865,5867,
  	5,208,0,0,5866,5868,3,848,424,0,5867,5866,1,0,0,0,5867,5868,1,0,0,0,5868,
  	5870,1,0,0,0,5869,5871,3,1326,663,0,5870,5869,1,0,0,0,5870,5871,1,0,0,
  	0,5871,755,1,0,0,0,5872,5873,5,536,0,0,5873,5874,5,600,0,0,5874,5876,
  	5,573,0,0,5875,5877,3,848,424,0,5876,5875,1,0,0,0,5876,5877,1,0,0,0,5877,
  	5879,1,0,0,0,5878,5880,3,1326,663,0,5879,5878,1,0,0,0,5879,5880,1,0,0,
  	0,5880,757,1,0,0,0,5881,5882,5,536,0,0,5882,5883,5,417,0,0,5883,5885,
  	5,597,0,0,5884,5886,3,848,424,0,5885,5884,1,0,0,0,5885,5886,1,0,0,0,5886,
  	5888,1,0,0,0,5887,5889,3,1326,663,0,5888,5887,1,0,0,0,5888,5889,1,0,0,
  	0,5889,759,1,0,0,0,5890,5891,4,380,168,0,5891,5892,5,536,0,0,5892,5893,
  	5,824,0,0,5893,5894,3,2,1,0,5894,761,1,0,0,0,5895,5896,5,536,0,0,5896,
  	5897,5,438,0,0,5897,763,1,0,0,0,5898,5899,5,536,0,0,5899,5900,5,202,0,
  	0,5900,5901,3,844,422,0,5901,5902,5,321,0,0,5902,765,1,0,0,0,5903,5904,
  	5,536,0,0,5904,5905,5,202,0,0,5905,5906,3,844,422,0,5906,5907,5,385,0,
  	0,5907,767,1,0,0,0,5908,5909,5,536,0,0,5909,5910,5,202,0,0,5910,5911,
  	3,844,422,0,5911,5912,5,573,0,0,5912,769,1,0,0,0,5913,5915,5,536,0,0,
  	5914,5916,3,842,421,0,5915,5914,1,0,0,0,5915,5916,1,0,0,0,5916,5917,1,
  	0,0,0,5917,5918,5,115,0,0,5918,5919,7,89,0,0,5919,5921,3,1398,699,0,5920,
  	5922,3,848,424,0,5921,5920,1,0,0,0,5921,5922,1,0,0,0,5922,5924,1,0,0,
  	0,5923,5925,3,1326,663,0,5924,5923,1,0,0,0,5924,5925,1,0,0,0,5925,771,
  	1,0,0,0,5926,5930,5,536,0,0,5927,5931,5,77,0,0,5928,5929,4,386,169,0,
  	5929,5931,5,348,0,0,5930,5927,1,0,0,0,5930,5928,1,0,0,0,5931,5932,1,0,
  	0,0,5932,5933,5,321,0,0,5933,773,1,0,0,0,5934,5935,5,536,0,0,5935,5936,
  	5,77,0,0,5936,5937,5,825,0,0,5937,5938,5,573,0,0,5938,775,1,0,0,0,5939,
  	5943,5,536,0,0,5940,5941,5,541,0,0,5941,5944,5,261,0,0,5942,5944,5,780,
  	0,0,5943,5940,1,0,0,0,5943,5942,1,0,0,0,5944,777,1,0,0,0,5945,5946,5,
  	536,0,0,5946,5947,5,78,0,0,5947,5950,5,208,0,0,5948,5949,5,286,0,0,5949,
  	5951,3,1460,730,0,5950,5948,1,0,0,0,5950,5951,1,0,0,0,5951,5954,1,0,0,
  	0,5952,5953,5,239,0,0,5953,5955,3,1442,721,0,5954,5952,1,0,0,0,5954,5955,
  	1,0,0,0,5955,5957,1,0,0,0,5956,5958,3,324,162,0,5957,5956,1,0,0,0,5957,
  	5958,1,0,0,0,5958,5960,1,0,0,0,5959,5961,3,1046,523,0,5960,5959,1,0,0,
  	0,5960,5961,1,0,0,0,5961,779,1,0,0,0,5962,5963,5,536,0,0,5963,5964,5,
  	476,0,0,5964,5967,5,208,0,0,5965,5966,5,286,0,0,5966,5968,3,1460,730,
  	0,5967,5965,1,0,0,0,5967,5968,1,0,0,0,5968,5971,1,0,0,0,5969,5970,5,239,
  	0,0,5970,5972,3,1442,721,0,5971,5969,1,0,0,0,5971,5972,1,0,0,0,5972,5974,
  	1,0,0,0,5973,5975,3,324,162,0,5974,5973,1,0,0,0,5974,5975,1,0,0,0,5975,
  	5977,1,0,0,0,5976,5978,3,1046,523,0,5977,5976,1,0,0,0,5977,5978,1,0,0,
  	0,5978,781,1,0,0,0,5979,5982,5,536,0,0,5980,5981,4,391,170,0,5981,5983,
  	5,219,0,0,5982,5980,1,0,0,0,5982,5983,1,0,0,0,5983,5984,1,0,0,0,5984,
  	5985,7,90,0,0,5985,5986,3,846,423,0,5986,5988,3,1398,699,0,5987,5989,
  	3,848,424,0,5988,5987,1,0,0,0,5988,5989,1,0,0,0,5989,5991,1,0,0,0,5990,
  	5992,3,408,204,0,5991,5990,1,0,0,0,5991,5992,1,0,0,0,5992,783,1,0,0,0,
  	5993,5995,5,536,0,0,5994,5996,5,579,0,0,5995,5994,1,0,0,0,5995,5996,1,
  	0,0,0,5996,5997,1,0,0,0,5997,5998,5,201,0,0,5998,785,1,0,0,0,5999,6000,
  	5,536,0,0,6000,6001,5,138,0,0,6001,6002,5,32,0,0,6002,6003,5,16,0,0,6003,
  	6004,5,33,0,0,6004,6005,5,664,0,0,6005,787,1,0,0,0,6006,6007,5,536,0,
  	0,6007,6008,5,138,0,0,6008,6009,5,32,0,0,6009,6010,5,16,0,0,6010,6011,
  	5,33,0,0,6011,6012,5,205,0,0,6012,789,1,0,0,0,6013,6014,5,536,0,0,6014,
  	6016,5,664,0,0,6015,6017,3,324,162,0,6016,6015,1,0,0,0,6016,6017,1,0,
  	0,0,6017,791,1,0,0,0,6018,6019,5,536,0,0,6019,6021,5,205,0,0,6020,6022,
  	3,324,162,0,6021,6020,1,0,0,0,6021,6022,1,0,0,0,6022,793,1,0,0,0,6023,
  	6024,5,536,0,0,6024,6025,5,456,0,0,6025,795,1,0,0,0,6026,6027,5,536,0,
  	0,6027,6029,5,455,0,0,6028,6030,3,850,425,0,6029,6028,1,0,0,0,6029,6030,
  	1,0,0,0,6030,6034,1,0,0,0,6031,6032,5,236,0,0,6032,6033,5,460,0,0,6033,
  	6035,5,3,0,0,6034,6031,1,0,0,0,6034,6035,1,0,0,0,6035,6037,1,0,0,0,6036,
  	6038,3,324,162,0,6037,6036,1,0,0,0,6037,6038,1,0,0,0,6038,797,1,0,0,0,
  	6039,6041,5,536,0,0,6040,6042,3,1498,749,0,6041,6040,1,0,0,0,6041,6042,
  	1,0,0,0,6042,6043,1,0,0,0,6043,6045,5,573,0,0,6044,6046,3,1326,663,0,
  	6045,6044,1,0,0,0,6045,6046,1,0,0,0,6046,799,1,0,0,0,6047,6049,5,536,
  	0,0,6048,6050,5,240,0,0,6049,6048,1,0,0,0,6049,6050,1,0,0,0,6050,6051,
  	1,0,0,0,6051,6052,5,454,0,0,6052,801,1,0,0,0,6053,6055,5,536,0,0,6054,
  	6056,3,1498,749,0,6055,6054,1,0,0,0,6055,6056,1,0,0,0,6056,6057,1,0,0,
  	0,6057,6059,5,656,0,0,6058,6060,3,1326,663,0,6059,6058,1,0,0,0,6059,6060,
  	1,0,0,0,6060,803,1,0,0,0,6061,6062,5,536,0,0,6062,6064,3,1022,511,0,6063,
  	6065,3,1326,663,0,6064,6063,1,0,0,0,6064,6065,1,0,0,0,6065,805,1,0,0,
  	0,6066,6067,5,536,0,0,6067,6069,5,114,0,0,6068,6070,3,1326,663,0,6069,
  	6068,1,0,0,0,6069,6070,1,0,0,0,6070,807,1,0,0,0,6071,6072,5,536,0,0,6072,
  	6073,5,451,0,0,6073,809,1,0,0,0,6074,6075,5,536,0,0,6075,6082,5,252,0,
  	0,6076,6077,5,236,0,0,6077,6080,3,1322,661,0,6078,6079,5,647,0,0,6079,
  	6081,3,1286,643,0,6080,6078,1,0,0,0,6080,6081,1,0,0,0,6081,6083,1,0,0,
  	0,6082,6076,1,0,0,0,6082,6083,1,0,0,0,6083,811,1,0,0,0,6084,6085,5,536,
  	0,0,6085,6086,5,140,0,0,6086,6088,5,151,0,0,6087,6089,3,1256,628,0,6088,
  	6087,1,0,0,0,6088,6089,1,0,0,0,6089,6090,1,0,0,0,6090,6091,3,1354,677,
  	0,6091,813,1,0,0,0,6092,6093,5,536,0,0,6093,6094,5,140,0,0,6094,6095,
  	5,600,0,0,6095,6096,3,1398,699,0,6096,815,1,0,0,0,6097,6098,5,536,0,0,
  	6098,6099,5,140,0,0,6099,6100,5,661,0,0,6100,6101,3,1370,685,0,6101,817,
  	1,0,0,0,6102,6103,5,536,0,0,6103,6104,5,348,0,0,6104,6105,5,573,0,0,6105,
  	819,1,0,0,0,6106,6107,5,536,0,0,6107,6108,3,620,310,0,6108,6111,5,573,
  	0,0,6109,6110,4,410,171,0,6110,6112,5,400,0,0,6111,6109,1,0,0,0,6111,
  	6112,1,0,0,0,6112,6114,1,0,0,0,6113,6115,3,1046,523,0,6114,6113,1,0,0,
  	0,6114,6115,1,0,0,0,6115,821,1,0,0,0,6116,6117,5,536,0,0,6117,6118,5,
  	140,0,0,6118,6119,5,452,0,0,6119,6120,3,1358,679,0,6120,823,1,0,0,0,6121,
  	6122,5,536,0,0,6122,6123,5,140,0,0,6123,6124,5,242,0,0,6124,6125,3,1362,
  	681,0,6125,825,1,0,0,0,6126,6127,5,536,0,0,6127,6128,5,140,0,0,6128,6129,
  	5,837,0,0,6129,6130,3,1422,711,0,6130,827,1,0,0,0,6131,6132,5,536,0,0,
  	6132,6133,5,140,0,0,6133,6134,5,620,0,0,6134,6135,3,1366,683,0,6135,829,
  	1,0,0,0,6136,6137,5,536,0,0,6137,6138,5,452,0,0,6138,6140,5,573,0,0,6139,
  	6141,3,1326,663,0,6140,6139,1,0,0,0,6140,6141,1,0,0,0,6141,831,1,0,0,
  	0,6142,6143,5,536,0,0,6143,6144,5,242,0,0,6144,6146,5,573,0,0,6145,6147,
  	3,1326,663,0,6146,6145,1,0,0,0,6146,6147,1,0,0,0,6147,833,1,0,0,0,6148,
  	6149,5,536,0,0,6149,6150,5,452,0,0,6150,6151,5,112,0,0,6151,6152,3,1358,
  	679,0,6152,835,1,0,0,0,6153,6154,5,536,0,0,6154,6155,5,242,0,0,6155,6156,
  	5,112,0,0,6156,6157,3,1362,681,0,6157,837,1,0,0,0,6158,6159,5,536,0,0,
  	6159,6160,5,140,0,0,6160,6161,5,209,0,0,6161,6162,3,1382,691,0,6162,839,
  	1,0,0,0,6163,6164,5,536,0,0,6164,6165,5,140,0,0,6165,6166,5,644,0,0,6166,
  	6167,3,1322,661,0,6167,841,1,0,0,0,6168,6175,5,240,0,0,6169,6170,4,421,
  	172,0,6170,6172,5,219,0,0,6171,6173,5,240,0,0,6172,6171,1,0,0,0,6172,
  	6173,1,0,0,0,6173,6175,1,0,0,0,6174,6168,1,0,0,0,6174,6169,1,0,0,0,6175,
  	843,1,0,0,0,6176,6179,3,1390,695,0,6177,6179,5,56,0,0,6178,6176,1,0,0,
  	0,6178,6177,1,0,0,0,6179,845,1,0,0,0,6180,6181,7,89,0,0,6181,847,1,0,
  	0,0,6182,6183,3,846,423,0,6183,6184,3,1426,713,0,6184,849,1,0,0,0,6185,
  	6190,3,852,426,0,6186,6187,5,29,0,0,6187,6189,3,852,426,0,6188,6186,1,
  	0,0,0,6189,6192,1,0,0,0,6190,6188,1,0,0,0,6190,6191,1,0,0,0,6191,851,
  	1,0,0,0,6192,6190,1,0,0,0,6193,6194,5,85,0,0,6194,6201,5,289,0,0,6195,
  	6196,5,135,0,0,6196,6201,5,594,0,0,6197,6198,5,430,0,0,6198,6201,5,224,
  	0,0,6199,6201,7,91,0,0,6200,6193,1,0,0,0,6200,6195,1,0,0,0,6200,6197,
  	1,0,0,0,6200,6199,1,0,0,0,6201,853,1,0,0,0,6202,6203,5,78,0,0,6203,6240,
  	3,1464,732,0,6204,6205,5,92,0,0,6205,6206,5,272,0,0,6206,6207,3,856,428,
  	0,6207,6210,5,286,0,0,6208,6211,3,1426,713,0,6209,6211,5,168,0,0,6210,
  	6208,1,0,0,0,6210,6209,1,0,0,0,6211,6240,1,0,0,0,6212,6214,5,232,0,0,
  	6213,6215,3,1330,665,0,6214,6213,1,0,0,0,6214,6215,1,0,0,0,6215,6225,
  	1,0,0,0,6216,6226,3,874,437,0,6217,6222,3,870,435,0,6218,6219,5,29,0,
  	0,6219,6221,3,870,435,0,6220,6218,1,0,0,0,6221,6224,1,0,0,0,6222,6220,
  	1,0,0,0,6222,6223,1,0,0,0,6223,6226,1,0,0,0,6224,6222,1,0,0,0,6225,6216,
  	1,0,0,0,6225,6217,1,0,0,0,6226,6240,1,0,0,0,6227,6229,5,300,0,0,6228,
  	6230,7,92,0,0,6229,6228,1,0,0,0,6229,6230,1,0,0,0,6230,6231,1,0,0,0,6231,
  	6240,3,924,462,0,6232,6233,5,315,0,0,6233,6234,5,272,0,0,6234,6235,5,
  	283,0,0,6235,6236,5,92,0,0,6236,6240,3,878,439,0,6237,6238,4,427,173,
  	0,6238,6240,5,537,0,0,6239,6202,1,0,0,0,6239,6204,1,0,0,0,6239,6212,1,
  	0,0,0,6239,6227,1,0,0,0,6239,6232,1,0,0,0,6239,6237,1,0,0,0,6240,855,
  	1,0,0,0,6241,6244,3,858,429,0,6242,6244,3,862,431,0,6243,6241,1,0,0,0,
  	6243,6242,1,0,0,0,6244,857,1,0,0,0,6245,6250,3,860,430,0,6246,6247,5,
  	29,0,0,6247,6249,3,860,430,0,6248,6246,1,0,0,0,6249,6252,1,0,0,0,6250,
  	6248,1,0,0,0,6250,6251,1,0,0,0,6251,859,1,0,0,0,6252,6250,1,0,0,0,6253,
  	6255,3,1398,699,0,6254,6256,3,864,432,0,6255,6254,1,0,0,0,6255,6256,1,
  	0,0,0,6256,861,1,0,0,0,6257,6258,3,1398,699,0,6258,6259,5,435,0,0,6259,
  	6260,5,32,0,0,6260,6261,3,54,27,0,6261,6263,5,33,0,0,6262,6264,3,864,
  	432,0,6263,6262,1,0,0,0,6263,6264,1,0,0,0,6264,863,1,0,0,0,6265,6266,
  	3,458,229,0,6266,6268,5,32,0,0,6267,6269,3,868,434,0,6268,6267,1,0,0,
  	0,6268,6269,1,0,0,0,6269,6270,1,0,0,0,6270,6271,5,33,0,0,6271,865,1,0,
  	0,0,6272,6275,3,1426,713,0,6273,6275,5,450,0,0,6274,6272,1,0,0,0,6274,
  	6273,1,0,0,0,6275,867,1,0,0,0,6276,6281,3,866,433,0,6277,6278,5,29,0,
  	0,6278,6280,3,866,433,0,6279,6277,1,0,0,0,6280,6283,1,0,0,0,6281,6279,
  	1,0,0,0,6281,6282,1,0,0,0,6282,869,1,0,0,0,6283,6281,1,0,0,0,6284,6302,
  	7,93,0,0,6285,6286,4,435,174,0,6286,6302,5,261,0,0,6287,6289,3,872,436,
  	0,6288,6287,1,0,0,0,6288,6289,1,0,0,0,6289,6290,1,0,0,0,6290,6302,5,321,
  	0,0,6291,6292,5,475,0,0,6292,6294,5,321,0,0,6293,6295,3,1046,523,0,6294,
  	6293,1,0,0,0,6294,6295,1,0,0,0,6295,6302,1,0,0,0,6296,6297,4,435,175,
  	0,6297,6298,5,460,0,0,6298,6302,5,92,0,0,6299,6300,4,435,176,0,6300,6302,
  	5,419,0,0,6301,6284,1,0,0,0,6301,6285,1,0,0,0,6301,6288,1,0,0,0,6301,
  	6291,1,0,0,0,6301,6296,1,0,0,0,6301,6299,1,0,0,0,6302,871,1,0,0,0,6303,
  	6304,7,94,0,0,6304,873,1,0,0,0,6305,6313,7,16,0,0,6306,6307,5,670,0,0,
  	6307,6308,5,465,0,0,6308,6314,5,319,0,0,6309,6311,3,1428,714,0,6310,6312,
  	3,876,438,0,6311,6310,1,0,0,0,6311,6312,1,0,0,0,6312,6314,1,0,0,0,6313,
  	6306,1,0,0,0,6313,6309,1,0,0,0,6313,6314,1,0,0,0,6314,875,1,0,0,0,6315,
  	6316,5,236,0,0,6316,6321,5,218,0,0,6317,6318,5,670,0,0,6318,6319,5,465,
  	0,0,6319,6321,5,319,0,0,6320,6315,1,0,0,0,6320,6317,1,0,0,0,6321,877,
  	1,0,0,0,6322,6323,3,1398,699,0,6323,6325,3,884,442,0,6324,6326,3,864,
  	432,0,6325,6324,1,0,0,0,6325,6326,1,0,0,0,6326,6329,1,0,0,0,6327,6328,
  	5,268,0,0,6328,6330,5,304,0,0,6329,6327,1,0,0,0,6329,6330,1,0,0,0,6330,
  	6333,1,0,0,0,6331,6333,3,880,440,0,6332,6322,1,0,0,0,6332,6331,1,0,0,
  	0,6333,879,1,0,0,0,6334,6339,3,882,441,0,6335,6336,5,29,0,0,6336,6338,
  	3,882,441,0,6337,6335,1,0,0,0,6338,6341,1,0,0,0,6339,6337,1,0,0,0,6339,
  	6340,1,0,0,0,6340,881,1,0,0,0,6341,6339,1,0,0,0,6342,6344,3,1398,699,
  	0,6343,6345,3,864,432,0,6344,6343,1,0,0,0,6344,6345,1,0,0,0,6345,6348,
  	1,0,0,0,6346,6347,5,268,0,0,6347,6349,5,304,0,0,6348,6346,1,0,0,0,6348,
  	6349,1,0,0,0,6349,883,1,0,0,0,6350,6351,5,435,0,0,6351,6352,5,32,0,0,
  	6352,6353,3,54,27,0,6353,6354,5,33,0,0,6354,885,1,0,0,0,6355,6360,3,888,
  	444,0,6356,6360,3,898,449,0,6357,6360,3,900,450,0,6358,6360,3,904,452,
  	0,6359,6355,1,0,0,0,6359,6356,1,0,0,0,6359,6357,1,0,0,0,6359,6358,1,0,
  	0,0,6360,887,1,0,0,0,6361,6362,5,140,0,0,6362,6363,5,734,0,0,6363,6364,
  	5,253,0,0,6364,6365,3,1426,713,0,6365,6367,5,625,0,0,6366,6368,3,1496,
  	748,0,6367,6366,1,0,0,0,6367,6368,1,0,0,0,6368,6369,1,0,0,0,6369,6371,
  	7,95,0,0,6370,6372,3,890,445,0,6371,6370,1,0,0,0,6371,6372,1,0,0,0,6372,
  	6374,1,0,0,0,6373,6375,3,894,447,0,6374,6373,1,0,0,0,6374,6375,1,0,0,
  	0,6375,6377,1,0,0,0,6376,6378,3,896,448,0,6377,6376,1,0,0,0,6377,6378,
  	1,0,0,0,6378,889,1,0,0,0,6379,6381,5,736,0,0,6380,6382,3,1496,748,0,6381,
  	6380,1,0,0,0,6381,6382,1,0,0,0,6382,6383,1,0,0,0,6383,6390,3,892,446,
  	0,6384,6386,5,29,0,0,6385,6384,1,0,0,0,6385,6386,1,0,0,0,6386,6387,1,
  	0,0,0,6387,6389,3,892,446,0,6388,6385,1,0,0,0,6389,6392,1,0,0,0,6390,
  	6388,1,0,0,0,6390,6391,1,0,0,0,6391,891,1,0,0,0,6392,6390,1,0,0,0,6393,
  	6396,5,3,0,0,6394,6395,5,15,0,0,6395,6397,5,3,0,0,6396,6394,1,0,0,0,6396,
  	6397,1,0,0,0,6397,893,1,0,0,0,6398,6400,5,733,0,0,6399,6401,3,1496,748,
  	0,6400,6399,1,0,0,0,6400,6401,1,0,0,0,6401,6402,1,0,0,0,6402,6403,5,3,
  	0,0,6403,895,1,0,0,0,6404,6405,7,6,0,0,6405,897,1,0,0,0,6406,6407,5,57,
  	0,0,6407,6408,5,734,0,0,6408,6409,5,253,0,0,6409,6411,3,1416,708,0,6410,
  	6412,3,890,445,0,6411,6410,1,0,0,0,6411,6412,1,0,0,0,6412,6414,1,0,0,
  	0,6413,6415,3,894,447,0,6414,6413,1,0,0,0,6414,6415,1,0,0,0,6415,6417,
  	1,0,0,0,6416,6418,3,896,448,0,6417,6416,1,0,0,0,6417,6418,1,0,0,0,6418,
  	6420,1,0,0,0,6419,6421,5,234,0,0,6420,6419,1,0,0,0,6420,6421,1,0,0,0,
  	6421,899,1,0,0,0,6422,6423,5,533,0,0,6423,6424,5,734,0,0,6424,6425,5,
  	253,0,0,6425,6428,3,1426,713,0,6426,6427,5,236,0,0,6427,6429,3,902,451,
  	0,6428,6426,1,0,0,0,6428,6429,1,0,0,0,6429,901,1,0,0,0,6430,6437,3,1440,
  	720,0,6431,6433,5,29,0,0,6432,6431,1,0,0,0,6432,6433,1,0,0,0,6433,6434,
  	1,0,0,0,6434,6436,3,1440,720,0,6435,6432,1,0,0,0,6436,6439,1,0,0,0,6437,
  	6435,1,0,0,0,6437,6438,1,0,0,0,6438,903,1,0,0,0,6439,6437,1,0,0,0,6440,
  	6441,5,187,0,0,6441,6442,5,734,0,0,6442,6443,5,253,0,0,6443,6445,3,1416,
  	708,0,6444,6446,5,234,0,0,6445,6444,1,0,0,0,6445,6446,1,0,0,0,6446,905,
  	1,0,0,0,6447,6454,3,908,454,0,6448,6454,3,910,455,0,6449,6454,3,918,459,
  	0,6450,6454,3,920,460,0,6451,6452,4,453,177,0,6452,6454,3,922,461,0,6453,
  	6447,1,0,0,0,6453,6448,1,0,0,0,6453,6449,1,0,0,0,6453,6450,1,0,0,0,6453,
  	6451,1,0,0,0,6454,907,1,0,0,0,6455,6456,7,96,0,0,6456,6459,3,1398,699,
  	0,6457,6460,3,1460,730,0,6458,6460,3,1342,671,0,6459,6457,1,0,0,0,6459,
  	6458,1,0,0,0,6459,6460,1,0,0,0,6460,909,1,0,0,0,6461,6463,7,96,0,0,6462,
  	6464,3,912,456,0,6463,6462,1,0,0,0,6463,6464,1,0,0,0,6464,6469,1,0,0,
  	0,6465,6466,4,455,178,0,6466,6467,5,236,0,0,6467,6468,5,151,0,0,6468,
  	6470,3,1486,743,0,6469,6465,1,0,0,0,6469,6470,1,0,0,0,6470,6471,1,0,0,
  	0,6471,6472,3,914,457,0,6472,911,1,0,0,0,6473,6474,5,237,0,0,6474,6475,
  	5,6,0,0,6475,6478,3,1486,743,0,6476,6477,4,456,179,0,6477,6479,3,916,
  	458,0,6478,6476,1,0,0,0,6478,6479,1,0,0,0,6479,6492,1,0,0,0,6480,6481,
  	4,456,180,0,6481,6492,5,219,0,0,6482,6483,4,456,181,0,6483,6492,5,434,
  	0,0,6484,6485,4,456,182,0,6485,6492,5,60,0,0,6486,6487,4,456,183,0,6487,
  	6488,5,60,0,0,6488,6489,5,237,0,0,6489,6490,5,6,0,0,6490,6492,3,1486,
  	743,0,6491,6473,1,0,0,0,6491,6480,1,0,0,0,6491,6482,1,0,0,0,6491,6484,
  	1,0,0,0,6491,6486,1,0,0,0,6492,913,1,0,0,0,6493,6502,3,306,153,0,6494,
  	6502,3,242,121,0,6495,6502,3,254,127,0,6496,6502,3,304,152,0,6497,6502,
  	3,468,234,0,6498,6499,5,236,0,0,6499,6500,5,128,0,0,6500,6502,3,1440,
  	720,0,6501,6493,1,0,0,0,6501,6494,1,0,0,0,6501,6495,1,0,0,0,6501,6496,
  	1,0,0,0,6501,6497,1,0,0,0,6501,6498,1,0,0,0,6502,915,1,0,0,0,6503,6504,
  	5,283,0,0,6504,6505,5,39,0,0,6505,6506,3,1486,743,0,6506,917,1,0,0,0,
  	6507,6508,5,258,0,0,6508,6509,3,1486,743,0,6509,919,1,0,0,0,6510,6511,
  	5,646,0,0,6511,6512,3,1354,677,0,6512,921,1,0,0,0,6513,6514,5,739,0,0,
  	6514,923,1,0,0,0,6515,6516,6,462,-1,0,6516,6522,3,926,463,0,6517,6519,
  	5,291,0,0,6518,6520,3,1024,512,0,6519,6518,1,0,0,0,6519,6520,1,0,0,0,
  	6520,6521,1,0,0,0,6521,6523,7,97,0,0,6522,6517,1,0,0,0,6522,6523,1,0,
  	0,0,6523,6527,1,0,0,0,6524,6525,5,401,0,0,6525,6527,3,924,462,4,6526,
  	6515,1,0,0,0,6526,6524,1,0,0,0,6527,6539,1,0,0,0,6528,6529,10,3,0,0,6529,
  	6530,7,98,0,0,6530,6538,3,924,462,4,6531,6532,10,2,0,0,6532,6533,5,679,
  	0,0,6533,6538,3,924,462,3,6534,6535,10,1,0,0,6535,6536,7,99,0,0,6536,
  	6538,3,924,462,2,6537,6528,1,0,0,0,6537,6531,1,0,0,0,6537,6534,1,0,0,
  	0,6538,6541,1,0,0,0,6539,6537,1,0,0,0,6539,6540,1,0,0,0,6540,925,1,0,
  	0,0,6541,6539,1,0,0,0,6542,6543,6,463,-1,0,6543,6544,3,930,465,0,6544,
  	6562,1,0,0,0,6545,6546,10,3,0,0,6546,6548,5,291,0,0,6547,6549,3,1024,
  	512,0,6548,6547,1,0,0,0,6548,6549,1,0,0,0,6549,6550,1,0,0,0,6550,6561,
  	5,406,0,0,6551,6552,10,2,0,0,6552,6553,3,928,464,0,6553,6554,3,930,465,
  	0,6554,6561,1,0,0,0,6555,6556,10,1,0,0,6556,6557,3,928,464,0,6557,6558,
  	7,100,0,0,6558,6559,3,320,160,0,6559,6561,1,0,0,0,6560,6545,1,0,0,0,6560,
  	6551,1,0,0,0,6560,6555,1,0,0,0,6561,6564,1,0,0,0,6562,6560,1,0,0,0,6562,
  	6563,1,0,0,0,6563,927,1,0,0,0,6564,6562,1,0,0,0,6565,6566,7,101,0,0,6566,
  	929,1,0,0,0,6567,6581,3,934,467,0,6568,6570,3,1024,512,0,6569,6568,1,
  	0,0,0,6569,6570,1,0,0,0,6570,6571,1,0,0,0,6571,6582,3,932,466,0,6572,
  	6573,4,465,190,0,6573,6575,5,758,0,0,6574,6576,5,693,0,0,6575,6574,1,
  	0,0,0,6575,6576,1,0,0,0,6576,6577,1,0,0,0,6577,6582,3,1036,518,0,6578,
  	6579,5,547,0,0,6579,6580,5,309,0,0,6580,6582,3,934,467,0,6581,6569,1,
  	0,0,0,6581,6572,1,0,0,0,6581,6578,1,0,0,0,6581,6582,1,0,0,0,6582,931,
  	1,0,0,0,6583,6589,5,286,0,0,6584,6590,3,320,160,0,6585,6586,5,32,0,0,
  	6586,6587,3,1020,510,0,6587,6588,5,33,0,0,6588,6590,1,0,0,0,6589,6584,
  	1,0,0,0,6589,6585,1,0,0,0,6590,6605,1,0,0,0,6591,6592,5,75,0,0,6592,6593,
  	3,934,467,0,6593,6594,5,61,0,0,6594,6595,3,930,465,0,6595,6605,1,0,0,
  	0,6596,6597,5,309,0,0,6597,6600,3,936,468,0,6598,6599,5,207,0,0,6599,
  	6601,3,936,468,0,6600,6598,1,0,0,0,6600,6601,1,0,0,0,6601,6605,1,0,0,
  	0,6602,6603,5,474,0,0,6603,6605,3,934,467,0,6604,6583,1,0,0,0,6604,6591,
  	1,0,0,0,6604,6596,1,0,0,0,6604,6602,1,0,0,0,6605,933,1,0,0,0,6606,6607,
  	6,467,-1,0,6607,6608,3,936,468,0,6608,6635,1,0,0,0,6609,6610,10,7,0,0,
  	6610,6611,5,25,0,0,6611,6634,3,934,467,8,6612,6613,10,6,0,0,6613,6614,
  	7,102,0,0,6614,6634,3,934,467,7,6615,6616,10,5,0,0,6616,6617,7,103,0,
  	0,6617,6634,3,934,467,6,6618,6619,10,3,0,0,6619,6620,7,104,0,0,6620,6634,
  	3,934,467,4,6621,6622,10,2,0,0,6622,6623,5,24,0,0,6623,6634,3,934,467,
  	3,6624,6625,10,1,0,0,6625,6626,5,27,0,0,6626,6634,3,934,467,2,6627,6628,
  	10,4,0,0,6628,6629,7,103,0,0,6629,6630,5,282,0,0,6630,6631,3,924,462,
  	0,6631,6632,3,1028,514,0,6632,6634,1,0,0,0,6633,6609,1,0,0,0,6633,6612,
  	1,0,0,0,6633,6615,1,0,0,0,6633,6618,1,0,0,0,6633,6621,1,0,0,0,6633,6624,
  	1,0,0,0,6633,6627,1,0,0,0,6634,6637,1,0,0,0,6635,6633,1,0,0,0,6635,6636,
  	1,0,0,0,6636,935,1,0,0,0,6637,6635,1,0,0,0,6638,6639,6,468,-1,0,6639,
  	6641,3,1342,671,0,6640,6642,3,940,470,0,6641,6640,1,0,0,0,6641,6642,1,
  	0,0,0,6642,6764,1,0,0,0,6643,6764,3,974,487,0,6644,6764,3,994,497,0,6645,
  	6764,3,1452,726,0,6646,6764,5,42,0,0,6647,6764,3,1006,503,0,6648,6764,
  	3,1004,502,0,6649,6764,3,942,471,0,6650,6651,4,468,198,0,6651,6764,3,
  	944,472,0,6652,6653,4,468,199,0,6653,6764,3,946,473,0,6654,6655,7,105,
  	0,0,6655,6764,3,936,468,15,6656,6657,3,1026,513,0,6657,6658,3,936,468,
  	14,6658,6764,1,0,0,0,6659,6661,5,516,0,0,6660,6659,1,0,0,0,6660,6661,
  	1,0,0,0,6661,6662,1,0,0,0,6662,6663,5,32,0,0,6663,6664,3,1020,510,0,6664,
  	6665,5,33,0,0,6665,6764,1,0,0,0,6666,6668,5,213,0,0,6667,6666,1,0,0,0,
  	6667,6668,1,0,0,0,6668,6669,1,0,0,0,6669,6764,3,320,160,0,6670,6671,5,
  	34,0,0,6671,6672,3,1426,713,0,6672,6673,3,924,462,0,6673,6674,5,35,0,
  	0,6674,6764,1,0,0,0,6675,6676,5,352,0,0,6676,6677,3,968,484,0,6677,6678,
  	5,53,0,0,6678,6679,5,32,0,0,6679,6681,3,934,467,0,6680,6682,3,972,486,
  	0,6681,6680,1,0,0,0,6681,6682,1,0,0,0,6682,6683,1,0,0,0,6683,6684,5,33,
  	0,0,6684,6764,1,0,0,0,6685,6686,5,77,0,0,6686,6764,3,936,468,9,6687,6688,
  	5,97,0,0,6688,6689,5,32,0,0,6689,6692,3,924,462,0,6690,6691,5,67,0,0,
  	6691,6693,5,316,0,0,6692,6690,1,0,0,0,6692,6693,1,0,0,0,6693,6694,1,0,
  	0,0,6694,6695,5,63,0,0,6695,6697,3,1018,509,0,6696,6698,3,938,469,0,6697,
  	6696,1,0,0,0,6697,6698,1,0,0,0,6698,6699,1,0,0,0,6699,6700,5,33,0,0,6700,
  	6764,1,0,0,0,6701,6702,4,468,200,0,6702,6703,5,97,0,0,6703,6704,5,32,
  	0,0,6704,6705,3,924,462,0,6705,6706,5,67,0,0,6706,6707,5,612,0,0,6707,
  	6709,5,777,0,0,6708,6710,5,282,0,0,6709,6708,1,0,0,0,6709,6710,1,0,0,
  	0,6710,6711,1,0,0,0,6711,6712,3,1458,729,0,6712,6713,5,63,0,0,6713,6714,
  	5,155,0,0,6714,6715,3,1200,600,0,6715,6716,5,33,0,0,6716,6764,1,0,0,0,
  	6717,6719,5,96,0,0,6718,6720,3,924,462,0,6719,6718,1,0,0,0,6719,6720,
  	1,0,0,0,6720,6724,1,0,0,0,6721,6722,3,1012,506,0,6722,6723,3,1014,507,
  	0,6723,6725,1,0,0,0,6724,6721,1,0,0,0,6725,6726,1,0,0,0,6726,6724,1,0,
  	0,0,6726,6727,1,0,0,0,6727,6729,1,0,0,0,6728,6730,3,1016,508,0,6729,6728,
  	1,0,0,0,6729,6730,1,0,0,0,6730,6731,1,0,0,0,6731,6732,5,198,0,0,6732,
  	6764,1,0,0,0,6733,6734,5,137,0,0,6734,6735,5,32,0,0,6735,6736,3,924,462,
  	0,6736,6737,5,29,0,0,6737,6738,3,1018,509,0,6738,6739,5,33,0,0,6739,6764,
  	1,0,0,0,6740,6741,5,137,0,0,6741,6742,5,32,0,0,6742,6743,3,924,462,0,
  	6743,6744,5,647,0,0,6744,6745,3,1204,602,0,6745,6746,5,33,0,0,6746,6764,
  	1,0,0,0,6747,6748,5,168,0,0,6748,6749,5,32,0,0,6749,6750,3,1434,717,0,
  	6750,6751,5,33,0,0,6751,6764,1,0,0,0,6752,6753,5,652,0,0,6753,6754,5,
  	32,0,0,6754,6755,3,1434,717,0,6755,6756,5,33,0,0,6756,6764,1,0,0,0,6757,
  	6758,5,282,0,0,6758,6759,3,924,462,0,6759,6760,3,1028,514,0,6760,6761,
  	5,14,0,0,6761,6762,3,924,462,0,6762,6764,1,0,0,0,6763,6638,1,0,0,0,6763,
  	6643,1,0,0,0,6763,6644,1,0,0,0,6763,6645,1,0,0,0,6763,6646,1,0,0,0,6763,
  	6647,1,0,0,0,6763,6648,1,0,0,0,6763,6649,1,0,0,0,6763,6650,1,0,0,0,6763,
  	6652,1,0,0,0,6763,6654,1,0,0,0,6763,6656,1,0,0,0,6763,6660,1,0,0,0,6763,
  	6667,1,0,0,0,6763,6670,1,0,0,0,6763,6675,1,0,0,0,6763,6685,1,0,0,0,6763,
  	6687,1,0,0,0,6763,6701,1,0,0,0,6763,6717,1,0,0,0,6763,6733,1,0,0,0,6763,
  	6740,1,0,0,0,6763,6747,1,0,0,0,6763,6752,1,0,0,0,6763,6757,1,0,0,0,6764,
  	6773,1,0,0,0,6765,6766,10,16,0,0,6766,6767,5,2,0,0,6767,6772,3,936,468,
  	17,6768,6769,10,24,0,0,6769,6770,5,113,0,0,6770,6772,3,1486,743,0,6771,
  	6765,1,0,0,0,6771,6768,1,0,0,0,6772,6775,1,0,0,0,6773,6771,1,0,0,0,6773,
  	6774,1,0,0,0,6774,937,1,0,0,0,6775,6773,1,0,0,0,6776,6777,4,469,203,0,
  	6777,6778,5,756,0,0,6778,939,1,0,0,0,6779,6780,4,470,204,0,6780,6781,
  	5,37,0,0,6781,6786,3,1458,729,0,6782,6783,4,470,205,0,6783,6784,5,38,
  	0,0,6784,6786,3,1458,729,0,6785,6779,1,0,0,0,6785,6782,1,0,0,0,6786,941,
  	1,0,0,0,6787,6788,5,71,0,0,6788,6790,5,32,0,0,6789,6791,5,183,0,0,6790,
  	6789,1,0,0,0,6790,6791,1,0,0,0,6791,6792,1,0,0,0,6792,6793,3,966,483,
  	0,6793,6796,5,33,0,0,6794,6795,4,471,206,0,6795,6797,3,954,477,0,6796,
  	6794,1,0,0,0,6796,6797,1,0,0,0,6797,6882,1,0,0,0,6798,6799,7,106,0,0,
  	6799,6800,5,32,0,0,6800,6801,3,966,483,0,6801,6804,5,33,0,0,6802,6803,
  	4,471,207,0,6803,6805,3,954,477,0,6804,6802,1,0,0,0,6804,6805,1,0,0,0,
  	6805,6882,1,0,0,0,6806,6807,4,471,208,0,6807,6882,3,964,482,0,6808,6809,
  	4,471,209,0,6809,6810,5,809,0,0,6810,6812,5,32,0,0,6811,6813,5,183,0,
  	0,6812,6811,1,0,0,0,6812,6813,1,0,0,0,6813,6814,1,0,0,0,6814,6815,3,966,
  	483,0,6815,6817,5,33,0,0,6816,6818,3,954,477,0,6817,6816,1,0,0,0,6817,
  	6818,1,0,0,0,6818,6882,1,0,0,0,6819,6820,5,138,0,0,6820,6828,5,32,0,0,
  	6821,6823,5,56,0,0,6822,6821,1,0,0,0,6822,6823,1,0,0,0,6823,6824,1,0,
  	0,0,6824,6829,5,16,0,0,6825,6829,3,966,483,0,6826,6827,5,183,0,0,6827,
  	6829,3,1020,510,0,6828,6822,1,0,0,0,6828,6825,1,0,0,0,6828,6826,1,0,0,
  	0,6829,6830,1,0,0,0,6830,6833,5,33,0,0,6831,6832,4,471,210,0,6832,6834,
  	3,954,477,0,6833,6831,1,0,0,0,6833,6834,1,0,0,0,6834,6882,1,0,0,0,6835,
  	6836,7,107,0,0,6836,6838,5,32,0,0,6837,6839,5,183,0,0,6838,6837,1,0,0,
  	0,6838,6839,1,0,0,0,6839,6840,1,0,0,0,6840,6841,3,966,483,0,6841,6844,
  	5,33,0,0,6842,6843,4,471,211,0,6843,6845,3,954,477,0,6844,6842,1,0,0,
  	0,6844,6845,1,0,0,0,6845,6882,1,0,0,0,6846,6847,7,108,0,0,6847,6848,5,
  	32,0,0,6848,6849,3,966,483,0,6849,6852,5,33,0,0,6850,6851,4,471,212,0,
  	6851,6853,3,954,477,0,6852,6850,1,0,0,0,6852,6853,1,0,0,0,6853,6882,1,
  	0,0,0,6854,6855,5,590,0,0,6855,6856,5,32,0,0,6856,6857,5,183,0,0,6857,
  	6858,3,966,483,0,6858,6861,5,33,0,0,6859,6860,4,471,213,0,6860,6862,3,
  	954,477,0,6861,6859,1,0,0,0,6861,6862,1,0,0,0,6862,6882,1,0,0,0,6863,
  	6864,5,254,0,0,6864,6866,5,32,0,0,6865,6867,5,183,0,0,6866,6865,1,0,0,
  	0,6866,6867,1,0,0,0,6867,6868,1,0,0,0,6868,6870,3,1020,510,0,6869,6871,
  	3,378,189,0,6870,6869,1,0,0,0,6870,6871,1,0,0,0,6871,6874,1,0,0,0,6872,
  	6873,5,526,0,0,6873,6875,3,1460,730,0,6874,6872,1,0,0,0,6874,6875,1,0,
  	0,0,6875,6876,1,0,0,0,6876,6879,5,33,0,0,6877,6878,4,471,214,0,6878,6880,
  	3,954,477,0,6879,6877,1,0,0,0,6879,6880,1,0,0,0,6880,6882,1,0,0,0,6881,
  	6787,1,0,0,0,6881,6798,1,0,0,0,6881,6806,1,0,0,0,6881,6808,1,0,0,0,6881,
  	6819,1,0,0,0,6881,6835,1,0,0,0,6881,6846,1,0,0,0,6881,6854,1,0,0,0,6881,
  	6863,1,0,0,0,6882,943,1,0,0,0,6883,6884,5,697,0,0,6884,6885,5,32,0,0,
  	6885,6886,3,1020,510,0,6886,6887,5,33,0,0,6887,945,1,0,0,0,6888,6889,
  	7,109,0,0,6889,6890,3,1494,747,0,6890,6891,3,954,477,0,6891,6938,1,0,
  	0,0,6892,6899,5,713,0,0,6893,6894,5,32,0,0,6894,6895,3,958,479,0,6895,
  	6896,5,33,0,0,6896,6900,1,0,0,0,6897,6898,4,473,215,0,6898,6900,3,1036,
  	518,0,6899,6893,1,0,0,0,6899,6897,1,0,0,0,6900,6901,1,0,0,0,6901,6902,
  	3,954,477,0,6902,6938,1,0,0,0,6903,6904,7,110,0,0,6904,6905,5,32,0,0,
  	6905,6907,3,924,462,0,6906,6908,3,956,478,0,6907,6906,1,0,0,0,6907,6908,
  	1,0,0,0,6908,6909,1,0,0,0,6909,6911,5,33,0,0,6910,6912,3,962,481,0,6911,
  	6910,1,0,0,0,6911,6912,1,0,0,0,6912,6913,1,0,0,0,6913,6914,3,954,477,
  	0,6914,6938,1,0,0,0,6915,6916,7,111,0,0,6916,6918,3,1034,517,0,6917,6919,
  	3,962,481,0,6918,6917,1,0,0,0,6918,6919,1,0,0,0,6919,6920,1,0,0,0,6920,
  	6921,3,954,477,0,6921,6938,1,0,0,0,6922,6923,5,712,0,0,6923,6924,5,32,
  	0,0,6924,6925,3,924,462,0,6925,6926,5,29,0,0,6926,6927,3,936,468,0,6927,
  	6930,5,33,0,0,6928,6929,5,239,0,0,6929,6931,7,112,0,0,6930,6928,1,0,0,
  	0,6930,6931,1,0,0,0,6931,6933,1,0,0,0,6932,6934,3,962,481,0,6933,6932,
  	1,0,0,0,6933,6934,1,0,0,0,6934,6935,1,0,0,0,6935,6936,3,954,477,0,6936,
  	6938,1,0,0,0,6937,6888,1,0,0,0,6937,6892,1,0,0,0,6937,6903,1,0,0,0,6937,
  	6915,1,0,0,0,6937,6922,1,0,0,0,6938,947,1,0,0,0,6939,6940,7,113,0,0,6940,
  	949,1,0,0,0,6941,6946,3,1442,721,0,6942,6943,5,39,0,0,6943,6946,3,1486,
  	743,0,6944,6946,5,42,0,0,6945,6941,1,0,0,0,6945,6942,1,0,0,0,6945,6944,
  	1,0,0,0,6946,951,1,0,0,0,6947,6948,4,476,216,0,6948,6949,5,833,0,0,6949,
  	6950,3,948,474,0,6950,6951,5,32,0,0,6951,6952,3,950,475,0,6952,6953,5,
  	33,0,0,6953,953,1,0,0,0,6954,6957,5,716,0,0,6955,6958,3,1418,709,0,6956,
  	6958,3,352,176,0,6957,6955,1,0,0,0,6957,6956,1,0,0,0,6958,955,1,0,0,0,
  	6959,6964,5,29,0,0,6960,6965,3,1442,721,0,6961,6965,5,42,0,0,6962,6963,
  	4,478,217,0,6963,6965,3,958,479,0,6964,6960,1,0,0,0,6964,6961,1,0,0,0,
  	6964,6962,1,0,0,0,6965,6968,1,0,0,0,6966,6967,5,29,0,0,6967,6969,3,924,
  	462,0,6968,6966,1,0,0,0,6968,6969,1,0,0,0,6969,957,1,0,0,0,6970,6973,
  	3,1476,738,0,6971,6973,3,960,480,0,6972,6970,1,0,0,0,6972,6971,1,0,0,
  	0,6973,959,1,0,0,0,6974,6978,5,42,0,0,6975,6978,3,1426,713,0,6976,6978,
  	3,1000,500,0,6977,6974,1,0,0,0,6977,6975,1,0,0,0,6977,6976,1,0,0,0,6978,
  	961,1,0,0,0,6979,6980,7,114,0,0,6980,6981,5,714,0,0,6981,963,1,0,0,0,
  	6982,6983,5,692,0,0,6983,6984,5,32,0,0,6984,6985,3,966,483,0,6985,6987,
  	5,33,0,0,6986,6988,3,954,477,0,6987,6986,1,0,0,0,6987,6988,1,0,0,0,6988,
  	6999,1,0,0,0,6989,6990,5,691,0,0,6990,6991,5,32,0,0,6991,6992,3,966,483,
  	0,6992,6993,5,29,0,0,6993,6994,3,966,483,0,6994,6996,5,33,0,0,6995,6997,
  	3,954,477,0,6996,6995,1,0,0,0,6996,6997,1,0,0,0,6997,6999,1,0,0,0,6998,
  	6982,1,0,0,0,6998,6989,1,0,0,0,6999,965,1,0,0,0,7000,7002,5,56,0,0,7001,
  	7000,1,0,0,0,7001,7002,1,0,0,0,7002,7003,1,0,0,0,7003,7004,3,924,462,
  	0,7004,967,1,0,0,0,7005,7011,3,970,485,0,7006,7007,5,32,0,0,7007,7008,
  	3,970,485,0,7008,7009,5,33,0,0,7009,7011,1,0,0,0,7010,7005,1,0,0,0,7010,
  	7006,1,0,0,0,7011,969,1,0,0,0,7012,7017,3,1434,717,0,7013,7014,5,29,0,
  	0,7014,7016,3,1434,717,0,7015,7013,1,0,0,0,7016,7019,1,0,0,0,7017,7015,
  	1,0,0,0,7017,7018,1,0,0,0,7018,971,1,0,0,0,7019,7017,1,0,0,0,7020,7021,
  	5,286,0,0,7021,7022,5,86,0,0,7022,7036,5,377,0,0,7023,7024,5,286,0,0,
  	7024,7025,5,390,0,0,7025,7026,5,301,0,0,7026,7030,5,377,0,0,7027,7028,
  	5,670,0,0,7028,7029,5,460,0,0,7029,7031,5,215,0,0,7030,7027,1,0,0,0,7030,
  	7031,1,0,0,0,7031,7036,1,0,0,0,7032,7033,5,670,0,0,7033,7034,5,460,0,
  	0,7034,7036,5,215,0,0,7035,7020,1,0,0,0,7035,7023,1,0,0,0,7035,7032,1,
  	0,0,0,7036,973,1,0,0,0,7037,7038,5,104,0,0,7038,7039,5,32,0,0,7039,7042,
  	3,1020,510,0,7040,7041,5,647,0,0,7041,7043,3,1204,602,0,7042,7040,1,0,
  	0,0,7042,7043,1,0,0,0,7043,7044,1,0,0,0,7044,7045,5,33,0,0,7045,7326,
  	1,0,0,0,7046,7048,5,147,0,0,7047,7049,3,1494,747,0,7048,7047,1,0,0,0,
  	7048,7049,1,0,0,0,7049,7326,1,0,0,0,7050,7051,5,158,0,0,7051,7326,3,1034,
  	517,0,7052,7053,5,163,0,0,7053,7326,3,1034,517,0,7054,7055,5,265,0,0,
  	7055,7326,3,1034,517,0,7056,7057,5,278,0,0,7057,7058,5,32,0,0,7058,7059,
  	3,924,462,0,7059,7060,5,29,0,0,7060,7061,3,924,462,0,7061,7062,5,29,0,
  	0,7062,7063,3,924,462,0,7063,7064,5,29,0,0,7064,7065,3,924,462,0,7065,
  	7066,5,33,0,0,7066,7326,1,0,0,0,7067,7068,5,282,0,0,7068,7069,5,32,0,
  	0,7069,7072,3,924,462,0,7070,7071,5,29,0,0,7071,7073,3,924,462,0,7072,
  	7070,1,0,0,0,7073,7074,1,0,0,0,7074,7072,1,0,0,0,7074,7075,1,0,0,0,7075,
  	7076,1,0,0,0,7076,7077,5,33,0,0,7077,7326,1,0,0,0,7078,7079,4,487,218,
  	0,7079,7080,5,771,0,0,7080,7081,5,32,0,0,7081,7082,3,936,468,0,7082,7083,
  	5,29,0,0,7083,7085,3,1464,732,0,7084,7086,3,976,488,0,7085,7084,1,0,0,
  	0,7085,7086,1,0,0,0,7086,7087,1,0,0,0,7087,7088,3,438,219,0,7088,7089,
  	5,33,0,0,7089,7326,1,0,0,0,7090,7091,5,306,0,0,7091,7092,5,32,0,0,7092,
  	7093,3,924,462,0,7093,7094,5,29,0,0,7094,7095,3,924,462,0,7095,7096,5,
  	33,0,0,7096,7326,1,0,0,0,7097,7098,5,374,0,0,7098,7326,3,1034,517,0,7099,
  	7100,5,381,0,0,7100,7326,3,1034,517,0,7101,7102,5,508,0,0,7102,7103,5,
  	32,0,0,7103,7104,3,924,462,0,7104,7105,5,29,0,0,7105,7106,3,924,462,0,
  	7106,7107,5,33,0,0,7107,7326,1,0,0,0,7108,7109,5,522,0,0,7109,7326,3,
  	1034,517,0,7110,7111,5,612,0,0,7111,7326,3,1034,517,0,7112,7113,5,609,
  	0,0,7113,7114,5,32,0,0,7114,7117,3,924,462,0,7115,7116,5,29,0,0,7116,
  	7118,3,924,462,0,7117,7115,1,0,0,0,7117,7118,1,0,0,0,7118,7119,1,0,0,
  	0,7119,7120,5,33,0,0,7120,7326,1,0,0,0,7121,7326,3,990,495,0,7122,7326,
  	3,644,322,0,7123,7124,5,652,0,0,7124,7326,3,1034,517,0,7125,7126,5,681,
  	0,0,7126,7326,3,1034,517,0,7127,7128,7,115,0,0,7128,7129,5,32,0,0,7129,
  	7130,3,924,462,0,7130,7136,5,29,0,0,7131,7137,3,924,462,0,7132,7133,5,
  	282,0,0,7133,7134,3,924,462,0,7134,7135,3,1028,514,0,7135,7137,1,0,0,
  	0,7136,7131,1,0,0,0,7136,7132,1,0,0,0,7137,7138,1,0,0,0,7138,7139,5,33,
  	0,0,7139,7326,1,0,0,0,7140,7142,5,143,0,0,7141,7143,3,1494,747,0,7142,
  	7141,1,0,0,0,7142,7143,1,0,0,0,7143,7326,1,0,0,0,7144,7146,5,150,0,0,
  	7145,7147,3,980,490,0,7146,7145,1,0,0,0,7146,7147,1,0,0,0,7147,7326,1,
  	0,0,0,7148,7149,7,116,0,0,7149,7150,5,32,0,0,7150,7151,3,924,462,0,7151,
  	7152,5,29,0,0,7152,7153,5,282,0,0,7153,7154,3,924,462,0,7154,7155,3,1028,
  	514,0,7155,7156,5,33,0,0,7156,7326,1,0,0,0,7157,7158,5,221,0,0,7158,7159,
  	5,32,0,0,7159,7160,3,1028,514,0,7160,7161,5,239,0,0,7161,7162,3,924,462,
  	0,7162,7163,5,33,0,0,7163,7326,1,0,0,0,7164,7165,5,249,0,0,7165,7166,
  	5,32,0,0,7166,7167,3,988,494,0,7167,7168,5,29,0,0,7168,7169,3,924,462,
  	0,7169,7170,5,33,0,0,7170,7326,1,0,0,0,7171,7172,4,487,219,0,7172,7173,
  	5,825,0,0,7173,7174,5,32,0,0,7174,7177,3,924,462,0,7175,7176,5,29,0,0,
  	7176,7178,3,924,462,0,7177,7175,1,0,0,0,7177,7178,1,0,0,0,7178,7179,1,
  	0,0,0,7179,7180,5,33,0,0,7180,7326,1,0,0,0,7181,7183,5,402,0,0,7182,7184,
  	3,980,490,0,7183,7182,1,0,0,0,7183,7184,1,0,0,0,7184,7326,1,0,0,0,7185,
  	7186,5,444,0,0,7186,7187,5,32,0,0,7187,7188,3,934,467,0,7188,7189,5,286,
  	0,0,7189,7190,3,924,462,0,7190,7191,5,33,0,0,7191,7326,1,0,0,0,7192,7326,
  	3,992,496,0,7193,7195,5,595,0,0,7194,7196,3,980,490,0,7195,7194,1,0,0,
  	0,7195,7196,1,0,0,0,7196,7326,1,0,0,0,7197,7198,7,117,0,0,7198,7199,5,
  	32,0,0,7199,7200,3,1030,515,0,7200,7201,5,29,0,0,7201,7202,3,924,462,
  	0,7202,7203,5,29,0,0,7203,7204,3,924,462,0,7204,7205,5,33,0,0,7205,7326,
  	1,0,0,0,7206,7208,5,648,0,0,7207,7209,3,1494,747,0,7208,7207,1,0,0,0,
  	7208,7209,1,0,0,0,7209,7326,1,0,0,0,7210,7212,5,650,0,0,7211,7213,3,980,
  	490,0,7212,7211,1,0,0,0,7212,7213,1,0,0,0,7213,7326,1,0,0,0,7214,7216,
  	5,649,0,0,7215,7217,3,980,490,0,7216,7215,1,0,0,0,7216,7217,1,0,0,0,7217,
  	7326,1,0,0,0,7218,7219,5,65,0,0,7219,7326,3,1034,517,0,7220,7221,5,103,
  	0,0,7221,7326,3,1034,517,0,7222,7223,5,111,0,0,7223,7326,3,1032,516,0,
  	7224,7225,5,114,0,0,7225,7326,3,1034,517,0,7226,7227,5,151,0,0,7227,7326,
  	3,1494,747,0,7228,7229,5,267,0,0,7229,7230,5,32,0,0,7230,7231,3,924,462,
  	0,7231,7232,5,29,0,0,7232,7233,3,924,462,0,7233,7234,5,29,0,0,7234,7235,
  	3,924,462,0,7235,7236,5,33,0,0,7236,7326,1,0,0,0,7237,7238,5,237,0,0,
  	7238,7239,5,32,0,0,7239,7240,3,924,462,0,7240,7241,5,29,0,0,7241,7244,
  	3,924,462,0,7242,7243,5,29,0,0,7243,7245,3,924,462,0,7244,7242,1,0,0,
  	0,7244,7245,1,0,0,0,7245,7246,1,0,0,0,7246,7247,5,33,0,0,7247,7326,1,
  	0,0,0,7248,7249,5,369,0,0,7249,7326,3,1034,517,0,7250,7251,5,380,0,0,
  	7251,7252,5,32,0,0,7252,7253,3,924,462,0,7253,7254,5,29,0,0,7254,7255,
  	3,924,462,0,7255,7256,5,33,0,0,7256,7326,1,0,0,0,7257,7258,4,487,220,
  	0,7258,7259,5,436,0,0,7259,7326,3,1034,517,0,7260,7261,5,459,0,0,7261,
  	7326,3,1034,517,0,7262,7263,5,487,0,0,7263,7264,5,32,0,0,7264,7265,3,
  	924,462,0,7265,7266,5,29,0,0,7266,7267,3,924,462,0,7267,7268,5,33,0,0,
  	7268,7326,1,0,0,0,7269,7270,5,488,0,0,7270,7271,5,32,0,0,7271,7272,3,
  	924,462,0,7272,7273,5,29,0,0,7273,7274,3,924,462,0,7274,7275,5,29,0,0,
  	7275,7276,3,924,462,0,7276,7277,5,33,0,0,7277,7326,1,0,0,0,7278,7279,
  	5,506,0,0,7279,7326,3,1034,517,0,7280,7281,5,514,0,0,7281,7326,3,1494,
  	747,0,7282,7283,5,623,0,0,7283,7284,5,32,0,0,7284,7285,3,924,462,0,7285,
  	7286,5,29,0,0,7286,7287,3,924,462,0,7287,7288,5,33,0,0,7288,7326,1,0,
  	0,0,7289,7290,5,665,0,0,7290,7291,5,32,0,0,7291,7294,3,924,462,0,7292,
  	7293,5,29,0,0,7293,7295,3,924,462,0,7294,7292,1,0,0,0,7294,7295,1,0,0,
  	0,7295,7296,1,0,0,0,7296,7297,5,33,0,0,7297,7326,1,0,0,0,7298,7299,5,
  	666,0,0,7299,7300,5,32,0,0,7300,7320,3,924,462,0,7301,7302,5,63,0,0,7302,
  	7303,5,104,0,0,7303,7305,3,1198,599,0,7304,7301,1,0,0,0,7304,7305,1,0,
  	0,0,7305,7308,1,0,0,0,7306,7307,4,487,221,0,7307,7309,3,984,492,0,7308,
  	7306,1,0,0,0,7308,7309,1,0,0,0,7309,7321,1,0,0,0,7310,7311,5,63,0,0,7311,
  	7312,5,77,0,0,7312,7321,3,1198,599,0,7313,7314,5,29,0,0,7314,7315,3,1438,
  	719,0,7315,7316,5,29,0,0,7316,7317,3,1438,719,0,7317,7318,5,29,0,0,7318,
  	7319,3,1438,719,0,7319,7321,1,0,0,0,7320,7304,1,0,0,0,7320,7310,1,0,0,
  	0,7320,7313,1,0,0,0,7321,7322,1,0,0,0,7322,7323,5,33,0,0,7323,7326,1,
  	0,0,0,7324,7326,3,978,489,0,7325,7037,1,0,0,0,7325,7046,1,0,0,0,7325,
  	7050,1,0,0,0,7325,7052,1,0,0,0,7325,7054,1,0,0,0,7325,7056,1,0,0,0,7325,
  	7067,1,0,0,0,7325,7078,1,0,0,0,7325,7090,1,0,0,0,7325,7097,1,0,0,0,7325,
  	7099,1,0,0,0,7325,7101,1,0,0,0,7325,7108,1,0,0,0,7325,7110,1,0,0,0,7325,
  	7112,1,0,0,0,7325,7121,1,0,0,0,7325,7122,1,0,0,0,7325,7123,1,0,0,0,7325,
  	7125,1,0,0,0,7325,7127,1,0,0,0,7325,7140,1,0,0,0,7325,7144,1,0,0,0,7325,
  	7148,1,0,0,0,7325,7157,1,0,0,0,7325,7164,1,0,0,0,7325,7171,1,0,0,0,7325,
  	7181,1,0,0,0,7325,7185,1,0,0,0,7325,7192,1,0,0,0,7325,7193,1,0,0,0,7325,
  	7197,1,0,0,0,7325,7206,1,0,0,0,7325,7210,1,0,0,0,7325,7214,1,0,0,0,7325,
  	7218,1,0,0,0,7325,7220,1,0,0,0,7325,7222,1,0,0,0,7325,7224,1,0,0,0,7325,
  	7226,1,0,0,0,7325,7228,1,0,0,0,7325,7237,1,0,0,0,7325,7248,1,0,0,0,7325,
  	7250,1,0,0,0,7325,7257,1,0,0,0,7325,7260,1,0,0,0,7325,7262,1,0,0,0,7325,
  	7269,1,0,0,0,7325,7278,1,0,0,0,7325,7280,1,0,0,0,7325,7282,1,0,0,0,7325,
  	7289,1,0,0,0,7325,7298,1,0,0,0,7325,7324,1,0,0,0,7326,975,1,0,0,0,7327,
  	7328,5,770,0,0,7328,7329,3,1018,509,0,7329,977,1,0,0,0,7330,7331,4,489,
  	222,0,7331,7332,5,134,0,0,7332,7333,5,32,0,0,7333,7334,3,924,462,0,7334,
  	7335,5,29,0,0,7335,7336,3,924,462,0,7336,7337,5,33,0,0,7337,7362,1,0,
  	0,0,7338,7339,5,247,0,0,7339,7341,5,32,0,0,7340,7342,3,1020,510,0,7341,
  	7340,1,0,0,0,7341,7342,1,0,0,0,7342,7343,1,0,0,0,7343,7362,5,33,0,0,7344,
  	7345,5,313,0,0,7345,7362,3,1032,516,0,7346,7347,5,382,0,0,7347,7362,3,
  	1032,516,0,7348,7349,5,383,0,0,7349,7362,3,1032,516,0,7350,7351,5,384,
  	0,0,7351,7362,3,1032,516,0,7352,7353,5,441,0,0,7353,7354,5,32,0,0,7354,
  	7355,3,924,462,0,7355,7356,5,29,0,0,7356,7357,3,924,462,0,7357,7358,5,
  	33,0,0,7358,7362,1,0,0,0,7359,7360,5,442,0,0,7360,7362,3,1032,516,0,7361,
  	7330,1,0,0,0,7361,7338,1,0,0,0,7361,7344,1,0,0,0,7361,7346,1,0,0,0,7361,
  	7348,1,0,0,0,7361,7350,1,0,0,0,7361,7352,1,0,0,0,7361,7359,1,0,0,0,7362,
  	979,1,0,0,0,7363,7365,5,32,0,0,7364,7366,3,982,491,0,7365,7364,1,0,0,
  	0,7365,7366,1,0,0,0,7366,7367,1,0,0,0,7367,7368,5,33,0,0,7368,981,1,0,
  	0,0,7369,7370,5,3,0,0,7370,983,1,0,0,0,7371,7384,5,308,0,0,7372,7373,
  	3,1440,720,0,7373,7374,5,15,0,0,7374,7375,3,1440,720,0,7375,7385,1,0,
  	0,0,7376,7381,3,986,493,0,7377,7378,5,29,0,0,7378,7380,3,986,493,0,7379,
  	7377,1,0,0,0,7380,7383,1,0,0,0,7381,7379,1,0,0,0,7381,7382,1,0,0,0,7382,
  	7385,1,0,0,0,7383,7381,1,0,0,0,7384,7372,1,0,0,0,7384,7376,1,0,0,0,7385,
  	985,1,0,0,0,7386,7392,3,1440,720,0,7387,7389,7,34,0,0,7388,7390,5,506,
  	0,0,7389,7388,1,0,0,0,7389,7390,1,0,0,0,7390,7393,1,0,0,0,7391,7393,5,
  	506,0,0,7392,7387,1,0,0,0,7392,7391,1,0,0,0,7392,7393,1,0,0,0,7393,987,
  	1,0,0,0,7394,7395,7,118,0,0,7395,989,1,0,0,0,7396,7397,5,621,0,0,7397,
  	7421,5,32,0,0,7398,7401,3,924,462,0,7399,7400,5,239,0,0,7400,7402,3,924,
  	462,0,7401,7399,1,0,0,0,7401,7402,1,0,0,0,7402,7422,1,0,0,0,7403,7405,
  	5,303,0,0,7404,7406,3,924,462,0,7405,7404,1,0,0,0,7405,7406,1,0,0,0,7406,
  	7407,1,0,0,0,7407,7408,5,239,0,0,7408,7422,3,924,462,0,7409,7411,5,617,
  	0,0,7410,7412,3,924,462,0,7411,7410,1,0,0,0,7411,7412,1,0,0,0,7412,7413,
  	1,0,0,0,7413,7414,5,239,0,0,7414,7422,3,924,462,0,7415,7417,5,88,0,0,
  	7416,7418,3,924,462,0,7417,7416,1,0,0,0,7417,7418,1,0,0,0,7418,7419,1,
  	0,0,0,7419,7420,5,239,0,0,7420,7422,3,924,462,0,7421,7398,1,0,0,0,7421,
  	7403,1,0,0,0,7421,7409,1,0,0,0,7421,7415,1,0,0,0,7422,7423,1,0,0,0,7423,
  	7424,5,33,0,0,7424,991,1,0,0,0,7425,7426,5,589,0,0,7426,7427,5,32,0,0,
  	7427,7440,3,924,462,0,7428,7429,5,29,0,0,7429,7432,3,924,462,0,7430,7431,
  	5,29,0,0,7431,7433,3,924,462,0,7432,7430,1,0,0,0,7432,7433,1,0,0,0,7433,
  	7441,1,0,0,0,7434,7435,5,239,0,0,7435,7438,3,924,462,0,7436,7437,5,236,
  	0,0,7437,7439,3,924,462,0,7438,7436,1,0,0,0,7438,7439,1,0,0,0,7439,7441,
  	1,0,0,0,7440,7428,1,0,0,0,7440,7434,1,0,0,0,7441,7442,1,0,0,0,7442,7443,
  	5,33,0,0,7443,993,1,0,0,0,7444,7445,3,1424,712,0,7445,7447,5,32,0,0,7446,
  	7448,3,996,498,0,7447,7446,1,0,0,0,7447,7448,1,0,0,0,7448,7449,1,0,0,
  	0,7449,7450,5,33,0,0,7450,7459,1,0,0,0,7451,7452,3,1432,716,0,7452,7454,
  	5,32,0,0,7453,7455,3,1020,510,0,7454,7453,1,0,0,0,7454,7455,1,0,0,0,7455,
  	7456,1,0,0,0,7456,7457,5,33,0,0,7457,7459,1,0,0,0,7458,7444,1,0,0,0,7458,
  	7451,1,0,0,0,7459,995,1,0,0,0,7460,7465,3,998,499,0,7461,7462,5,29,0,
  	0,7462,7464,3,998,499,0,7463,7461,1,0,0,0,7464,7467,1,0,0,0,7465,7463,
  	1,0,0,0,7465,7466,1,0,0,0,7466,997,1,0,0,0,7467,7465,1,0,0,0,7468,7470,
  	3,924,462,0,7469,7471,3,406,203,0,7470,7469,1,0,0,0,7470,7471,1,0,0,0,
  	7471,999,1,0,0,0,7472,7473,5,39,0,0,7473,7474,3,1002,501,0,7474,1001,
  	1,0,0,0,7475,7478,3,1486,743,0,7476,7478,5,854,0,0,7477,7475,1,0,0,0,
  	7477,7476,1,0,0,0,7478,1003,1,0,0,0,7479,7480,3,1000,500,0,7480,7481,
  	5,7,0,0,7481,7482,3,924,462,0,7482,1005,1,0,0,0,7483,7491,3,1000,500,
  	0,7484,7485,5,39,0,0,7485,7487,5,39,0,0,7486,7488,3,1500,750,0,7487,7486,
  	1,0,0,0,7487,7488,1,0,0,0,7488,7489,1,0,0,0,7489,7491,3,1010,505,0,7490,
  	7483,1,0,0,0,7490,7484,1,0,0,0,7491,1007,1,0,0,0,7492,7494,3,1426,713,
  	0,7493,7495,3,1436,718,0,7494,7493,1,0,0,0,7494,7495,1,0,0,0,7495,7502,
  	1,0,0,0,7496,7497,4,504,223,0,7497,7499,3,1488,744,0,7498,7500,3,1436,
  	718,0,7499,7498,1,0,0,0,7499,7500,1,0,0,0,7500,7502,1,0,0,0,7501,7492,
  	1,0,0,0,7501,7496,1,0,0,0,7502,7506,1,0,0,0,7503,7504,5,168,0,0,7504,
  	7506,3,1436,718,0,7505,7501,1,0,0,0,7505,7503,1,0,0,0,7506,1009,1,0,0,
  	0,7507,7509,3,1486,743,0,7508,7510,3,1436,718,0,7509,7508,1,0,0,0,7509,
  	7510,1,0,0,0,7510,1011,1,0,0,0,7511,7512,5,667,0,0,7512,7513,3,924,462,
  	0,7513,1013,1,0,0,0,7514,7515,5,608,0,0,7515,7516,3,924,462,0,7516,1015,
  	1,0,0,0,7517,7518,5,193,0,0,7518,7519,3,924,462,0,7519,1017,1,0,0,0,7520,
  	7522,5,77,0,0,7521,7523,3,1188,594,0,7522,7521,1,0,0,0,7522,7523,1,0,
  	0,0,7523,7570,1,0,0,0,7524,7526,5,104,0,0,7525,7527,3,1188,594,0,7526,
  	7525,1,0,0,0,7526,7527,1,0,0,0,7527,7529,1,0,0,0,7528,7530,3,1192,596,
  	0,7529,7528,1,0,0,0,7529,7530,1,0,0,0,7530,7570,1,0,0,0,7531,7533,3,1184,
  	592,0,7532,7534,3,1188,594,0,7533,7532,1,0,0,0,7533,7534,1,0,0,0,7534,
  	7570,1,0,0,0,7535,7537,5,539,0,0,7536,7538,5,284,0,0,7537,7536,1,0,0,
  	0,7537,7538,1,0,0,0,7538,7570,1,0,0,0,7539,7541,5,638,0,0,7540,7542,5,
  	284,0,0,7541,7540,1,0,0,0,7541,7542,1,0,0,0,7542,7570,1,0,0,0,7543,7570,
  	5,158,0,0,7544,7545,4,509,224,0,7545,7570,5,681,0,0,7546,7548,5,612,0,
  	0,7547,7549,3,1200,600,0,7548,7547,1,0,0,0,7548,7549,1,0,0,0,7549,7570,
  	1,0,0,0,7550,7552,5,155,0,0,7551,7553,3,1200,600,0,7552,7551,1,0,0,0,
  	7552,7553,1,0,0,0,7553,7570,1,0,0,0,7554,7556,5,166,0,0,7555,7557,3,1480,
  	740,0,7556,7555,1,0,0,0,7556,7557,1,0,0,0,7557,7570,1,0,0,0,7558,7559,
  	4,509,225,0,7559,7570,5,296,0,0,7560,7561,4,509,226,0,7561,7570,3,1186,
  	593,0,7562,7563,4,509,227,0,7563,7565,5,231,0,0,7564,7566,3,1482,741,
  	0,7565,7564,1,0,0,0,7565,7566,1,0,0,0,7566,7570,1,0,0,0,7567,7568,4,509,
  	228,0,7568,7570,7,119,0,0,7569,7520,1,0,0,0,7569,7524,1,0,0,0,7569,7531,
  	1,0,0,0,7569,7535,1,0,0,0,7569,7539,1,0,0,0,7569,7543,1,0,0,0,7569,7544,
  	1,0,0,0,7569,7546,1,0,0,0,7569,7550,1,0,0,0,7569,7554,1,0,0,0,7569,7558,
  	1,0,0,0,7569,7560,1,0,0,0,7569,7562,1,0,0,0,7569,7567,1,0,0,0,7570,1019,
  	1,0,0,0,7571,7576,3,924,462,0,7572,7573,5,29,0,0,7573,7575,3,924,462,
  	0,7574,7572,1,0,0,0,7575,7578,1,0,0,0,7576,7574,1,0,0,0,7576,7577,1,0,
  	0,0,7577,1021,1,0,0,0,7578,7576,1,0,0,0,7579,7580,5,104,0,0,7580,7583,
  	5,533,0,0,7581,7583,5,103,0,0,7582,7579,1,0,0,0,7582,7581,1,0,0,0,7583,
  	1023,1,0,0,0,7584,7585,7,120,0,0,7585,1025,1,0,0,0,7586,7587,7,121,0,
  	0,7587,1027,1,0,0,0,7588,7591,3,1030,515,0,7589,7591,7,122,0,0,7590,7588,
  	1,0,0,0,7590,7589,1,0,0,0,7591,1029,1,0,0,0,7592,7593,7,123,0,0,7593,
  	1031,1,0,0,0,7594,7595,5,32,0,0,7595,7596,3,1020,510,0,7596,7597,5,33,
  	0,0,7597,1033,1,0,0,0,7598,7599,5,32,0,0,7599,7600,3,924,462,0,7600,7601,
  	5,33,0,0,7601,1035,1,0,0,0,7602,7603,5,32,0,0,7603,7604,3,936,468,0,7604,
  	7605,5,33,0,0,7605,1037,1,0,0,0,7606,7611,3,1040,520,0,7607,7608,5,29,
  	0,0,7608,7610,3,1040,520,0,7609,7607,1,0,0,0,7610,7613,1,0,0,0,7611,7609,
  	1,0,0,0,7611,7612,1,0,0,0,7612,1039,1,0,0,0,7613,7611,1,0,0,0,7614,7616,
  	3,924,462,0,7615,7617,3,380,190,0,7616,7615,1,0,0,0,7616,7617,1,0,0,0,
  	7617,1041,1,0,0,0,7618,7623,3,1044,522,0,7619,7620,5,29,0,0,7620,7622,
  	3,1044,522,0,7621,7619,1,0,0,0,7622,7625,1,0,0,0,7623,7621,1,0,0,0,7623,
  	7624,1,0,0,0,7624,1043,1,0,0,0,7625,7623,1,0,0,0,7626,7627,3,924,462,
  	0,7627,1045,1,0,0,0,7628,7629,4,523,229,0,7629,7630,5,236,0,0,7630,7631,
  	5,102,0,0,7631,7632,3,1466,733,0,7632,1047,1,0,0,0,7633,7647,3,2,1,0,
  	7634,7647,3,1050,525,0,7635,7647,3,1052,526,0,7636,7647,3,1060,530,0,
  	7637,7647,3,1064,532,0,7638,7647,3,1066,533,0,7639,7647,3,1072,536,0,
  	7640,7647,3,1074,537,0,7641,7647,3,1102,551,0,7642,7647,3,1100,550,0,
  	7643,7647,3,1120,560,0,7644,7647,3,1124,562,0,7645,7647,3,1122,561,0,
  	7646,7633,1,0,0,0,7646,7634,1,0,0,0,7646,7635,1,0,0,0,7646,7636,1,0,0,
  	0,7646,7637,1,0,0,0,7646,7638,1,0,0,0,7646,7639,1,0,0,0,7646,7640,1,0,
  	0,0,7646,7641,1,0,0,0,7646,7642,1,0,0,0,7646,7643,1,0,0,0,7646,7644,1,
  	0,0,0,7646,7645,1,0,0,0,7647,1049,1,0,0,0,7648,7649,5,505,0,0,7649,7650,
  	3,924,462,0,7650,1051,1,0,0,0,7651,7652,5,267,0,0,7652,7653,3,1054,527,
  	0,7653,7654,5,198,0,0,7654,7655,5,267,0,0,7655,1053,1,0,0,0,7656,7657,
  	3,924,462,0,7657,7662,3,1056,528,0,7658,7659,5,194,0,0,7659,7663,3,1054,
  	527,0,7660,7661,5,193,0,0,7661,7663,3,1058,529,0,7662,7658,1,0,0,0,7662,
  	7660,1,0,0,0,7662,7663,1,0,0,0,7663,1055,1,0,0,0,7664,7665,5,608,0,0,
  	7665,7666,3,1058,529,0,7666,1057,1,0,0,0,7667,7668,3,1048,524,0,7668,
  	7669,5,30,0,0,7669,7671,1,0,0,0,7670,7667,1,0,0,0,7671,7672,1,0,0,0,7672,
  	7670,1,0,0,0,7672,7673,1,0,0,0,7673,1059,1,0,0,0,7674,7676,5,96,0,0,7675,
  	7677,3,924,462,0,7676,7675,1,0,0,0,7676,7677,1,0,0,0,7677,7681,1,0,0,
  	0,7678,7679,3,1012,506,0,7679,7680,3,1056,528,0,7680,7682,1,0,0,0,7681,
  	7678,1,0,0,0,7682,7683,1,0,0,0,7683,7681,1,0,0,0,7683,7684,1,0,0,0,7684,
  	7686,1,0,0,0,7685,7687,3,1062,531,0,7686,7685,1,0,0,0,7686,7687,1,0,0,
  	0,7687,7688,1,0,0,0,7688,7689,5,198,0,0,7689,7690,5,96,0,0,7690,1061,
  	1,0,0,0,7691,7692,5,193,0,0,7692,7693,3,1058,529,0,7693,1063,1,0,0,0,
  	7694,7695,3,1068,534,0,7695,7697,3,1070,535,0,7696,7698,3,1408,704,0,
  	7697,7696,1,0,0,0,7697,7698,1,0,0,0,7698,1065,1,0,0,0,7699,7700,3,1070,
  	535,0,7700,1067,1,0,0,0,7701,7702,3,1406,703,0,7702,7703,5,31,0,0,7703,
  	1069,1,0,0,0,7704,7706,5,74,0,0,7705,7707,3,1082,541,0,7706,7705,1,0,
  	0,0,7706,7707,1,0,0,0,7707,7709,1,0,0,0,7708,7710,3,1058,529,0,7709,7708,
  	1,0,0,0,7709,7710,1,0,0,0,7710,7711,1,0,0,0,7711,7712,5,198,0,0,7712,
  	1071,1,0,0,0,7713,7714,3,1068,534,0,7714,7716,3,1074,537,0,7715,7717,
  	3,1408,704,0,7716,7715,1,0,0,0,7716,7717,1,0,0,0,7717,1073,1,0,0,0,7718,
  	7722,3,1076,538,0,7719,7722,3,1078,539,0,7720,7722,3,1080,540,0,7721,
  	7718,1,0,0,0,7721,7719,1,0,0,0,7721,7720,1,0,0,0,7722,1075,1,0,0,0,7723,
  	7724,5,326,0,0,7724,7725,3,1058,529,0,7725,7726,5,198,0,0,7726,7727,5,
  	326,0,0,7727,1077,1,0,0,0,7728,7729,5,669,0,0,7729,7730,3,924,462,0,7730,
  	7731,5,186,0,0,7731,7732,3,1058,529,0,7732,7733,5,198,0,0,7733,7734,5,
  	669,0,0,7734,1079,1,0,0,0,7735,7736,5,487,0,0,7736,7737,3,1058,529,0,
  	7737,7738,5,639,0,0,7738,7739,3,924,462,0,7739,7740,5,198,0,0,7740,7741,
  	5,487,0,0,7741,1081,1,0,0,0,7742,7743,3,1084,542,0,7743,7744,5,30,0,0,
  	7744,7746,1,0,0,0,7745,7742,1,0,0,0,7746,7747,1,0,0,0,7747,7745,1,0,0,
  	0,7747,7748,1,0,0,0,7748,1083,1,0,0,0,7749,7754,3,1086,543,0,7750,7754,
  	3,1088,544,0,7751,7754,3,1094,547,0,7752,7754,3,1098,549,0,7753,7749,
  	1,0,0,0,7753,7750,1,0,0,0,7753,7751,1,0,0,0,7753,7752,1,0,0,0,7754,1085,
  	1,0,0,0,7755,7756,5,167,0,0,7756,7757,3,1428,714,0,7757,7759,3,1182,591,
  	0,7758,7760,3,1264,632,0,7759,7758,1,0,0,0,7759,7760,1,0,0,0,7760,7763,
  	1,0,0,0,7761,7762,5,168,0,0,7762,7764,3,924,462,0,7763,7761,1,0,0,0,7763,
  	7764,1,0,0,0,7764,1087,1,0,0,0,7765,7766,5,167,0,0,7766,7767,3,1426,713,
  	0,7767,7768,5,127,0,0,7768,7769,5,236,0,0,7769,7770,3,1090,545,0,7770,
  	1089,1,0,0,0,7771,7774,3,1438,719,0,7772,7774,3,1092,546,0,7773,7771,
  	1,0,0,0,7773,7772,1,0,0,0,7774,1091,1,0,0,0,7775,7777,5,552,0,0,7776,
  	7778,5,653,0,0,7777,7776,1,0,0,0,7777,7778,1,0,0,0,7778,7779,1,0,0,0,
  	7779,7780,3,1464,732,0,7780,1093,1,0,0,0,7781,7782,5,167,0,0,7782,7783,
  	7,124,0,0,7783,7784,5,255,0,0,7784,7785,5,236,0,0,7785,7790,3,1096,548,
  	0,7786,7787,5,29,0,0,7787,7789,3,1096,548,0,7788,7786,1,0,0,0,7789,7792,
  	1,0,0,0,7790,7788,1,0,0,0,7790,7791,1,0,0,0,7791,7793,1,0,0,0,7792,7790,
  	1,0,0,0,7793,7794,3,1048,524,0,7794,1095,1,0,0,0,7795,7803,3,1090,545,
  	0,7796,7803,3,1426,713,0,7797,7803,5,553,0,0,7798,7799,3,1024,512,0,7799,
  	7800,5,238,0,0,7800,7803,1,0,0,0,7801,7803,5,551,0,0,7802,7795,1,0,0,
  	0,7802,7796,1,0,0,0,7802,7797,1,0,0,0,7802,7798,1,0,0,0,7802,7801,1,0,
  	0,0,7803,1097,1,0,0,0,7804,7805,5,167,0,0,7805,7806,3,1426,713,0,7806,
  	7807,5,148,0,0,7807,7808,5,236,0,0,7808,7809,3,306,153,0,7809,1099,1,
  	0,0,0,7810,7811,5,294,0,0,7811,7812,3,1408,704,0,7812,1101,1,0,0,0,7813,
  	7814,5,305,0,0,7814,7815,3,1408,704,0,7815,1103,1,0,0,0,7816,7818,5,243,
  	0,0,7817,7819,7,125,0,0,7818,7817,1,0,0,0,7818,7819,1,0,0,0,7819,7820,
  	1,0,0,0,7820,7839,5,178,0,0,7821,7826,3,1108,554,0,7822,7823,5,29,0,0,
  	7823,7825,3,1108,554,0,7824,7822,1,0,0,0,7825,7828,1,0,0,0,7826,7824,
  	1,0,0,0,7826,7827,1,0,0,0,7827,7840,1,0,0,0,7828,7826,1,0,0,0,7829,7830,
  	5,127,0,0,7830,7831,3,1106,553,0,7831,7836,3,1110,555,0,7832,7833,5,29,
  	0,0,7833,7835,3,1110,555,0,7834,7832,1,0,0,0,7835,7838,1,0,0,0,7836,7834,
  	1,0,0,0,7836,7837,1,0,0,0,7837,7840,1,0,0,0,7838,7836,1,0,0,0,7839,7821,
  	1,0,0,0,7839,7829,1,0,0,0,7840,1105,1,0,0,0,7841,7845,3,1450,725,0,7842,
  	7845,3,1006,503,0,7843,7845,3,1432,716,0,7844,7841,1,0,0,0,7844,7842,
  	1,0,0,0,7844,7843,1,0,0,0,7845,1107,1,0,0,0,7846,7849,3,1000,500,0,7847,
  	7849,3,1426,713,0,7848,7846,1,0,0,0,7848,7847,1,0,0,0,7849,7850,1,0,0,
  	0,7850,7851,5,6,0,0,7851,7852,7,126,0,0,7852,1109,1,0,0,0,7853,7856,3,
  	1000,500,0,7854,7856,3,1426,713,0,7855,7853,1,0,0,0,7855,7854,1,0,0,0,
  	7856,7857,1,0,0,0,7857,7860,5,6,0,0,7858,7861,3,1112,556,0,7859,7861,
  	5,503,0,0,7860,7858,1,0,0,0,7860,7859,1,0,0,0,7861,1111,1,0,0,0,7862,
  	7863,7,127,0,0,7863,1113,1,0,0,0,7864,7867,5,538,0,0,7865,7868,3,1426,
  	713,0,7866,7868,3,1092,546,0,7867,7865,1,0,0,0,7867,7866,1,0,0,0,7868,
  	7878,1,0,0,0,7869,7870,5,533,0,0,7870,7875,3,1118,559,0,7871,7872,5,29,
  	0,0,7872,7874,3,1118,559,0,7873,7871,1,0,0,0,7874,7877,1,0,0,0,7875,7873,
  	1,0,0,0,7875,7876,1,0,0,0,7876,7879,1,0,0,0,7877,7875,1,0,0,0,7878,7869,
  	1,0,0,0,7878,7879,1,0,0,0,7879,1115,1,0,0,0,7880,7883,5,499,0,0,7881,
  	7884,3,1426,713,0,7882,7884,3,1092,546,0,7883,7881,1,0,0,0,7883,7882,
  	1,0,0,0,7883,7884,1,0,0,0,7884,7894,1,0,0,0,7885,7886,5,533,0,0,7886,
  	7891,3,1118,559,0,7887,7888,5,29,0,0,7888,7890,3,1118,559,0,7889,7887,
  	1,0,0,0,7890,7893,1,0,0,0,7891,7889,1,0,0,0,7891,7892,1,0,0,0,7892,7895,
  	1,0,0,0,7893,7891,1,0,0,0,7894,7885,1,0,0,0,7894,7895,1,0,0,0,7895,1117,
  	1,0,0,0,7896,7897,3,1112,556,0,7897,7898,5,6,0,0,7898,7899,3,1106,553,
  	0,7899,1119,1,0,0,0,7900,7901,5,417,0,0,7901,7902,3,1426,713,0,7902,1121,
  	1,0,0,0,7903,7904,5,110,0,0,7904,7905,3,1426,713,0,7905,1123,1,0,0,0,
  	7906,7911,5,225,0,0,7907,7909,5,397,0,0,7908,7907,1,0,0,0,7908,7909,1,
  	0,0,0,7909,7910,1,0,0,0,7910,7912,5,239,0,0,7911,7908,1,0,0,0,7911,7912,
  	1,0,0,0,7912,7913,1,0,0,0,7913,7914,3,1426,713,0,7914,7915,5,283,0,0,
  	7915,7916,3,1428,714,0,7916,1125,1,0,0,0,7917,7918,5,67,0,0,7918,7931,
  	3,924,462,0,7919,7920,5,210,0,0,7920,7921,3,924,462,0,7921,7924,3,1028,
  	514,0,7922,7923,5,568,0,0,7923,7925,3,924,462,0,7924,7922,1,0,0,0,7924,
  	7925,1,0,0,0,7925,7928,1,0,0,0,7926,7927,5,199,0,0,7927,7929,3,924,462,
  	0,7928,7926,1,0,0,0,7928,7929,1,0,0,0,7929,7931,1,0,0,0,7930,7917,1,0,
  	0,0,7930,7919,1,0,0,0,7931,1127,1,0,0,0,7932,7933,3,1336,668,0,7933,7935,
  	3,1140,570,0,7934,7936,3,1130,565,0,7935,7934,1,0,0,0,7935,7936,1,0,0,
  	0,7936,1129,1,0,0,0,7937,7938,4,565,230,0,7938,7941,3,1132,566,0,7939,
  	7941,3,1154,577,0,7940,7937,1,0,0,0,7940,7939,1,0,0,0,7941,1131,1,0,0,
  	0,7942,7943,5,106,0,0,7943,7944,3,1034,517,0,7944,1133,1,0,0,0,7945,7947,
  	4,567,231,0,7946,7948,5,401,0,0,7947,7946,1,0,0,0,7947,7948,1,0,0,0,7948,
  	7949,1,0,0,0,7949,7950,5,755,0,0,7950,1135,1,0,0,0,7951,7953,7,39,0,0,
  	7952,7954,3,124,62,0,7953,7952,1,0,0,0,7953,7954,1,0,0,0,7954,7955,1,
  	0,0,0,7955,7959,3,1162,581,0,7956,7958,3,1168,584,0,7957,7956,1,0,0,0,
  	7958,7961,1,0,0,0,7959,7957,1,0,0,0,7959,7960,1,0,0,0,7960,8026,1,0,0,
  	0,7961,7959,1,0,0,0,7962,7964,5,241,0,0,7963,7965,3,458,229,0,7964,7963,
  	1,0,0,0,7964,7965,1,0,0,0,7965,7967,1,0,0,0,7966,7968,3,1346,673,0,7967,
  	7966,1,0,0,0,7967,7968,1,0,0,0,7968,7969,1,0,0,0,7969,7973,3,1162,581,
  	0,7970,7972,3,1176,588,0,7971,7970,1,0,0,0,7972,7975,1,0,0,0,7973,7971,
  	1,0,0,0,7973,7974,1,0,0,0,7974,8026,1,0,0,0,7975,7973,1,0,0,0,7976,7978,
  	5,549,0,0,7977,7979,3,458,229,0,7978,7977,1,0,0,0,7978,7979,1,0,0,0,7979,
  	7981,1,0,0,0,7980,7982,3,1346,673,0,7981,7980,1,0,0,0,7981,7982,1,0,0,
  	0,7982,7983,1,0,0,0,7983,7987,3,1162,581,0,7984,7986,3,1178,589,0,7985,
  	7984,1,0,0,0,7986,7989,1,0,0,0,7987,7985,1,0,0,0,7987,7988,1,0,0,0,7988,
  	8026,1,0,0,0,7989,7987,1,0,0,0,7990,7992,3,1138,569,0,7991,7990,1,0,0,
  	0,7991,7992,1,0,0,0,7992,8023,1,0,0,0,7993,7994,5,450,0,0,7994,8000,5,
  	299,0,0,7995,7997,5,635,0,0,7996,7998,3,458,229,0,7997,7996,1,0,0,0,7997,
  	7998,1,0,0,0,7998,8000,1,0,0,0,7999,7993,1,0,0,0,7999,7995,1,0,0,0,8000,
  	8002,1,0,0,0,8001,8003,3,124,62,0,8002,8001,1,0,0,0,8002,8003,1,0,0,0,
  	8003,8004,1,0,0,0,8004,8008,3,1162,581,0,8005,8007,3,1168,584,0,8006,
  	8005,1,0,0,0,8007,8010,1,0,0,0,8008,8006,1,0,0,0,8008,8009,1,0,0,0,8009,
  	8024,1,0,0,0,8010,8008,1,0,0,0,8011,8012,5,235,0,0,8012,8014,5,299,0,
  	0,8013,8015,3,1346,673,0,8014,8013,1,0,0,0,8014,8015,1,0,0,0,8015,8016,
  	1,0,0,0,8016,8017,3,1158,579,0,8017,8018,3,1154,577,0,8018,8024,1,0,0,
  	0,8019,8021,3,1132,566,0,8020,8022,3,1134,567,0,8021,8020,1,0,0,0,8021,
  	8022,1,0,0,0,8022,8024,1,0,0,0,8023,7999,1,0,0,0,8023,8011,1,0,0,0,8023,
  	8019,1,0,0,0,8024,8026,1,0,0,0,8025,7951,1,0,0,0,8025,7962,1,0,0,0,8025,
  	7976,1,0,0,0,8025,7991,1,0,0,0,8026,1137,1,0,0,0,8027,8029,5,130,0,0,
  	8028,8030,3,1426,713,0,8029,8028,1,0,0,0,8029,8030,1,0,0,0,8030,1139,
  	1,0,0,0,8031,8067,3,1182,591,0,8032,8034,3,1142,571,0,8033,8032,1,0,0,
  	0,8034,8037,1,0,0,0,8035,8033,1,0,0,0,8035,8036,1,0,0,0,8036,8068,1,0,
  	0,0,8037,8035,1,0,0,0,8038,8040,4,570,232,0,8039,8041,3,1264,632,0,8040,
  	8039,1,0,0,0,8040,8041,1,0,0,0,8041,8044,1,0,0,0,8042,8043,5,245,0,0,
  	8043,8045,5,58,0,0,8044,8042,1,0,0,0,8044,8045,1,0,0,0,8045,8046,1,0,
  	0,0,8046,8047,5,63,0,0,8047,8049,3,1034,517,0,8048,8050,7,128,0,0,8049,
  	8048,1,0,0,0,8049,8050,1,0,0,0,8050,8065,1,0,0,0,8051,8055,4,570,233,
  	0,8052,8054,3,1152,576,0,8053,8052,1,0,0,0,8054,8057,1,0,0,0,8055,8053,
  	1,0,0,0,8055,8056,1,0,0,0,8056,8066,1,0,0,0,8057,8055,1,0,0,0,8058,8062,
  	4,570,234,0,8059,8061,3,1142,571,0,8060,8059,1,0,0,0,8061,8064,1,0,0,
  	0,8062,8060,1,0,0,0,8062,8063,1,0,0,0,8063,8066,1,0,0,0,8064,8062,1,0,
  	0,0,8065,8051,1,0,0,0,8065,8058,1,0,0,0,8066,8068,1,0,0,0,8067,8035,1,
  	0,0,0,8067,8038,1,0,0,0,8068,1141,1,0,0,0,8069,8071,5,401,0,0,8070,8069,
  	1,0,0,0,8070,8071,1,0,0,0,8071,8072,1,0,0,0,8072,8132,3,1474,737,0,8073,
  	8074,4,571,235,0,8074,8075,5,401,0,0,8075,8132,5,745,0,0,8076,8080,5,
  	168,0,0,8077,8081,3,1150,575,0,8078,8079,4,571,236,0,8079,8081,3,1034,
  	517,0,8080,8077,1,0,0,0,8080,8078,1,0,0,0,8081,8132,1,0,0,0,8082,8083,
  	5,413,0,0,8083,8084,5,640,0,0,8084,8086,5,402,0,0,8085,8087,3,980,490,
  	0,8086,8085,1,0,0,0,8086,8087,1,0,0,0,8087,8132,1,0,0,0,8088,8132,5,69,
  	0,0,8089,8090,5,528,0,0,8090,8091,5,168,0,0,8091,8132,5,653,0,0,8092,
  	8094,5,450,0,0,8093,8092,1,0,0,0,8093,8094,1,0,0,0,8094,8095,1,0,0,0,
  	8095,8132,5,299,0,0,8096,8098,5,635,0,0,8097,8099,5,299,0,0,8098,8097,
  	1,0,0,0,8098,8099,1,0,0,0,8099,8132,1,0,0,0,8100,8101,5,119,0,0,8101,
  	8132,3,1464,732,0,8102,8132,3,1264,632,0,8103,8104,5,118,0,0,8104,8132,
  	3,1144,572,0,8105,8106,5,579,0,0,8106,8132,3,1146,573,0,8107,8108,4,571,
  	237,0,8108,8109,5,732,0,0,8109,8132,3,1444,722,0,8110,8112,4,571,238,
  	0,8111,8113,3,1138,569,0,8112,8111,1,0,0,0,8112,8113,1,0,0,0,8113,8114,
  	1,0,0,0,8114,8132,3,1132,566,0,8115,8116,4,571,239,0,8116,8132,3,1134,
  	567,0,8117,8118,4,571,240,0,8118,8120,5,774,0,0,8119,8121,5,6,0,0,8120,
  	8119,1,0,0,0,8120,8121,1,0,0,0,8121,8122,1,0,0,0,8122,8132,3,1504,752,
  	0,8123,8124,4,571,241,0,8124,8126,5,775,0,0,8125,8127,5,6,0,0,8126,8125,
  	1,0,0,0,8126,8127,1,0,0,0,8127,8128,1,0,0,0,8128,8132,3,1504,752,0,8129,
  	8130,4,571,242,0,8130,8132,3,1172,586,0,8131,8070,1,0,0,0,8131,8073,1,
  	0,0,0,8131,8076,1,0,0,0,8131,8082,1,0,0,0,8131,8088,1,0,0,0,8131,8089,
  	1,0,0,0,8131,8093,1,0,0,0,8131,8096,1,0,0,0,8131,8100,1,0,0,0,8131,8102,
  	1,0,0,0,8131,8103,1,0,0,0,8131,8105,1,0,0,0,8131,8107,1,0,0,0,8131,8110,
  	1,0,0,0,8131,8115,1,0,0,0,8131,8117,1,0,0,0,8131,8123,1,0,0,0,8131,8129,
  	1,0,0,0,8132,1143,1,0,0,0,8133,8134,7,129,0,0,8134,1145,1,0,0,0,8135,
  	8136,7,130,0,0,8136,1147,1,0,0,0,8137,8138,5,402,0,0,8138,8139,3,1202,
  	601,0,8139,1149,1,0,0,0,8140,8143,3,1148,574,0,8141,8143,3,1448,724,0,
  	8142,8140,1,0,0,0,8142,8141,1,0,0,0,8143,1151,1,0,0,0,8144,8146,5,635,
  	0,0,8145,8147,5,299,0,0,8146,8145,1,0,0,0,8146,8147,1,0,0,0,8147,8159,
  	1,0,0,0,8148,8149,5,119,0,0,8149,8159,3,1460,730,0,8150,8152,3,1024,512,
  	0,8151,8150,1,0,0,0,8151,8152,1,0,0,0,8152,8153,1,0,0,0,8153,8159,5,406,
  	0,0,8154,8156,5,450,0,0,8155,8154,1,0,0,0,8155,8156,1,0,0,0,8156,8157,
  	1,0,0,0,8157,8159,5,299,0,0,8158,8144,1,0,0,0,8158,8148,1,0,0,0,8158,
  	8151,1,0,0,0,8158,8155,1,0,0,0,8159,1153,1,0,0,0,8160,8161,5,473,0,0,
  	8161,8163,3,1398,699,0,8162,8164,3,1430,715,0,8163,8162,1,0,0,0,8163,
  	8164,1,0,0,0,8164,8167,1,0,0,0,8165,8166,5,352,0,0,8166,8168,7,131,0,
  	0,8167,8165,1,0,0,0,8167,8168,1,0,0,0,8168,8185,1,0,0,0,8169,8170,5,413,
  	0,0,8170,8171,5,640,0,0,8171,8175,3,1156,578,0,8172,8173,5,413,0,0,8173,
  	8174,5,173,0,0,8174,8176,3,1156,578,0,8175,8172,1,0,0,0,8175,8176,1,0,
  	0,0,8176,8186,1,0,0,0,8177,8178,5,413,0,0,8178,8179,5,173,0,0,8179,8183,
  	3,1156,578,0,8180,8181,5,413,0,0,8181,8182,5,640,0,0,8182,8184,3,1156,
  	578,0,8183,8180,1,0,0,0,8183,8184,1,0,0,0,8184,8186,1,0,0,0,8185,8169,
  	1,0,0,0,8185,8177,1,0,0,0,8185,8186,1,0,0,0,8186,1155,1,0,0,0,8187,8195,
  	7,1,0,0,8188,8189,5,533,0,0,8189,8195,3,1474,737,0,8190,8191,5,533,0,
  	0,8191,8195,5,168,0,0,8192,8193,5,403,0,0,8193,8195,5,49,0,0,8194,8187,
  	1,0,0,0,8194,8188,1,0,0,0,8194,8190,1,0,0,0,8194,8192,1,0,0,0,8195,1157,
  	1,0,0,0,8196,8197,5,32,0,0,8197,8202,3,1160,580,0,8198,8199,5,29,0,0,
  	8199,8201,3,1160,580,0,8200,8198,1,0,0,0,8201,8204,1,0,0,0,8202,8200,
  	1,0,0,0,8202,8203,1,0,0,0,8203,8205,1,0,0,0,8204,8202,1,0,0,0,8205,8206,
  	5,33,0,0,8206,1159,1,0,0,0,8207,8209,3,1426,713,0,8208,8210,3,1188,594,
  	0,8209,8208,1,0,0,0,8209,8210,1,0,0,0,8210,8212,1,0,0,0,8211,8213,3,380,
  	190,0,8212,8211,1,0,0,0,8212,8213,1,0,0,0,8213,1161,1,0,0,0,8214,8215,
  	5,32,0,0,8215,8220,3,1164,582,0,8216,8217,5,29,0,0,8217,8219,3,1164,582,
  	0,8218,8216,1,0,0,0,8219,8222,1,0,0,0,8220,8218,1,0,0,0,8220,8221,1,0,
  	0,0,8221,8223,1,0,0,0,8222,8220,1,0,0,0,8223,8224,5,33,0,0,8224,1163,
  	1,0,0,0,8225,8232,3,1160,580,0,8226,8227,4,582,243,0,8227,8229,3,1034,
  	517,0,8228,8230,3,380,190,0,8229,8228,1,0,0,0,8229,8230,1,0,0,0,8230,
  	8232,1,0,0,0,8231,8225,1,0,0,0,8231,8226,1,0,0,0,8232,1165,1,0,0,0,8233,
  	8234,7,132,0,0,8234,1167,1,0,0,0,8235,8238,3,1170,585,0,8236,8238,3,1174,
  	587,0,8237,8235,1,0,0,0,8237,8236,1,0,0,0,8238,1169,1,0,0,0,8239,8241,
  	5,298,0,0,8240,8242,5,6,0,0,8241,8240,1,0,0,0,8241,8242,1,0,0,0,8242,
  	8243,1,0,0,0,8243,8261,3,1438,719,0,8244,8245,5,119,0,0,8245,8261,3,1464,
  	732,0,8246,8247,4,585,244,0,8247,8261,3,1172,586,0,8248,8249,4,585,245,
  	0,8249,8251,5,774,0,0,8250,8252,5,6,0,0,8251,8250,1,0,0,0,8251,8252,1,
  	0,0,0,8252,8253,1,0,0,0,8253,8261,3,1504,752,0,8254,8255,4,585,246,0,
  	8255,8257,5,775,0,0,8256,8258,5,6,0,0,8257,8256,1,0,0,0,8257,8258,1,0,
  	0,0,8258,8259,1,0,0,0,8259,8261,3,1504,752,0,8260,8239,1,0,0,0,8260,8244,
  	1,0,0,0,8260,8246,1,0,0,0,8260,8248,1,0,0,0,8260,8254,1,0,0,0,8261,1171,
  	1,0,0,0,8262,8263,7,133,0,0,8263,1173,1,0,0,0,8264,8265,7,134,0,0,8265,
  	8266,3,1166,583,0,8266,1175,1,0,0,0,8267,8272,3,1170,585,0,8268,8269,
  	5,670,0,0,8269,8270,5,431,0,0,8270,8272,3,1426,713,0,8271,8267,1,0,0,
  	0,8271,8268,1,0,0,0,8272,1177,1,0,0,0,8273,8274,3,1170,585,0,8274,1179,
  	1,0,0,0,8275,8276,3,1182,591,0,8276,8277,5,0,0,1,8277,1181,1,0,0,0,8278,
  	8280,7,135,0,0,8279,8281,3,1188,594,0,8280,8279,1,0,0,0,8280,8281,1,0,
  	0,0,8281,8283,1,0,0,0,8282,8284,3,1190,595,0,8283,8282,1,0,0,0,8283,8284,
  	1,0,0,0,8284,8430,1,0,0,0,8285,8291,5,467,0,0,8286,8288,5,185,0,0,8287,
  	8289,5,446,0,0,8288,8287,1,0,0,0,8288,8289,1,0,0,0,8289,8291,1,0,0,0,
  	8290,8285,1,0,0,0,8290,8286,1,0,0,0,8291,8293,1,0,0,0,8292,8294,3,1484,
  	742,0,8293,8292,1,0,0,0,8293,8294,1,0,0,0,8294,8296,1,0,0,0,8295,8297,
  	3,1190,595,0,8296,8295,1,0,0,0,8296,8297,1,0,0,0,8297,8430,1,0,0,0,8298,
  	8300,7,136,0,0,8299,8301,3,1480,740,0,8300,8299,1,0,0,0,8300,8301,1,0,
  	0,0,8301,8303,1,0,0,0,8302,8304,3,1190,595,0,8303,8302,1,0,0,0,8303,8304,
  	1,0,0,0,8304,8430,1,0,0,0,8305,8307,5,82,0,0,8306,8308,3,1188,594,0,8307,
  	8306,1,0,0,0,8307,8308,1,0,0,0,8308,8430,1,0,0,0,8309,8430,7,137,0,0,
  	8310,8312,5,104,0,0,8311,8313,3,1188,594,0,8312,8311,1,0,0,0,8312,8313,
  	1,0,0,0,8313,8315,1,0,0,0,8314,8316,3,1192,596,0,8315,8314,1,0,0,0,8315,
  	8316,1,0,0,0,8316,8430,1,0,0,0,8317,8319,3,1184,592,0,8318,8320,3,1188,
  	594,0,8319,8318,1,0,0,0,8319,8320,1,0,0,0,8320,8322,1,0,0,0,8321,8323,
  	5,77,0,0,8322,8321,1,0,0,0,8322,8323,1,0,0,0,8323,8430,1,0,0,0,8324,8326,
  	5,77,0,0,8325,8327,3,1188,594,0,8326,8325,1,0,0,0,8326,8327,1,0,0,0,8327,
  	8430,1,0,0,0,8328,8329,5,104,0,0,8329,8332,5,658,0,0,8330,8332,5,655,
  	0,0,8331,8328,1,0,0,0,8331,8330,1,0,0,0,8332,8333,1,0,0,0,8333,8335,3,
  	1188,594,0,8334,8336,3,1192,596,0,8335,8334,1,0,0,0,8335,8336,1,0,0,0,
  	8336,8430,1,0,0,0,8337,8338,5,389,0,0,8338,8348,5,655,0,0,8339,8348,5,
  	409,0,0,8340,8341,5,392,0,0,8341,8348,5,655,0,0,8342,8343,5,389,0,0,8343,
  	8344,5,104,0,0,8344,8348,5,658,0,0,8345,8346,5,392,0,0,8346,8348,5,658,
  	0,0,8347,8337,1,0,0,0,8347,8339,1,0,0,0,8347,8340,1,0,0,0,8347,8342,1,
  	0,0,0,8347,8345,1,0,0,0,8348,8349,1,0,0,0,8349,8351,3,1188,594,0,8350,
  	8352,5,77,0,0,8351,8350,1,0,0,0,8351,8352,1,0,0,0,8352,8430,1,0,0,0,8353,
  	8354,5,654,0,0,8354,8430,3,1188,594,0,8355,8357,5,834,0,0,8356,8358,3,
  	1188,594,0,8357,8356,1,0,0,0,8357,8358,1,0,0,0,8358,8430,1,0,0,0,8359,
  	8361,5,681,0,0,8360,8362,3,1188,594,0,8361,8360,1,0,0,0,8361,8362,1,0,
  	0,0,8362,8364,1,0,0,0,8363,8365,3,1190,595,0,8364,8363,1,0,0,0,8364,8365,
  	1,0,0,0,8365,8430,1,0,0,0,8366,8430,5,158,0,0,8367,8369,5,612,0,0,8368,
  	8370,3,1200,600,0,8369,8368,1,0,0,0,8369,8370,1,0,0,0,8370,8430,1,0,0,
  	0,8371,8373,5,609,0,0,8372,8374,3,1200,600,0,8373,8372,1,0,0,0,8373,8374,
  	1,0,0,0,8374,8430,1,0,0,0,8375,8377,5,155,0,0,8376,8378,3,1200,600,0,
  	8377,8376,1,0,0,0,8377,8378,1,0,0,0,8378,8430,1,0,0,0,8379,8430,5,613,
  	0,0,8380,8382,5,84,0,0,8381,8383,3,1188,594,0,8382,8381,1,0,0,0,8382,
  	8383,1,0,0,0,8383,8430,1,0,0,0,8384,8430,7,138,0,0,8385,8386,5,325,0,
  	0,8386,8430,5,654,0,0,8387,8391,5,325,0,0,8388,8389,5,104,0,0,8389,8392,
  	5,658,0,0,8390,8392,5,655,0,0,8391,8388,1,0,0,0,8391,8390,1,0,0,0,8391,
  	8392,1,0,0,0,8392,8394,1,0,0,0,8393,8395,3,1192,596,0,8394,8393,1,0,0,
  	0,8394,8395,1,0,0,0,8395,8430,1,0,0,0,8396,8398,5,615,0,0,8397,8399,3,
  	1192,596,0,8398,8397,1,0,0,0,8398,8399,1,0,0,0,8399,8430,1,0,0,0,8400,
  	8402,5,606,0,0,8401,8403,3,1188,594,0,8402,8401,1,0,0,0,8402,8403,1,0,
  	0,0,8403,8405,1,0,0,0,8404,8406,3,1192,596,0,8405,8404,1,0,0,0,8405,8406,
  	1,0,0,0,8406,8430,1,0,0,0,8407,8409,5,364,0,0,8408,8410,3,1192,596,0,
  	8409,8408,1,0,0,0,8409,8410,1,0,0,0,8410,8430,1,0,0,0,8411,8413,5,323,
  	0,0,8412,8414,3,1192,596,0,8413,8412,1,0,0,0,8413,8414,1,0,0,0,8414,8430,
  	1,0,0,0,8415,8416,5,203,0,0,8416,8418,3,1456,728,0,8417,8419,3,1192,596,
  	0,8418,8417,1,0,0,0,8418,8419,1,0,0,0,8419,8430,1,0,0,0,8420,8421,5,533,
  	0,0,8421,8423,3,1456,728,0,8422,8424,3,1192,596,0,8423,8422,1,0,0,0,8423,
  	8424,1,0,0,0,8424,8430,1,0,0,0,8425,8430,5,528,0,0,8426,8427,4,591,247,
  	0,8427,8430,5,296,0,0,8428,8430,7,139,0,0,8429,8278,1,0,0,0,8429,8290,
  	1,0,0,0,8429,8298,1,0,0,0,8429,8305,1,0,0,0,8429,8309,1,0,0,0,8429,8310,
  	1,0,0,0,8429,8317,1,0,0,0,8429,8324,1,0,0,0,8429,8331,1,0,0,0,8429,8347,
  	1,0,0,0,8429,8353,1,0,0,0,8429,8355,1,0,0,0,8429,8359,1,0,0,0,8429,8366,
  	1,0,0,0,8429,8367,1,0,0,0,8429,8371,1,0,0,0,8429,8375,1,0,0,0,8429,8379,
  	1,0,0,0,8429,8380,1,0,0,0,8429,8384,1,0,0,0,8429,8385,1,0,0,0,8429,8387,
  	1,0,0,0,8429,8396,1,0,0,0,8429,8400,1,0,0,0,8429,8407,1,0,0,0,8429,8411,
  	1,0,0,0,8429,8415,1,0,0,0,8429,8420,1,0,0,0,8429,8425,1,0,0,0,8429,8426,
  	1,0,0,0,8429,8428,1,0,0,0,8430,1183,1,0,0,0,8431,8435,5,392,0,0,8432,
  	8433,5,389,0,0,8433,8435,5,104,0,0,8434,8431,1,0,0,0,8434,8432,1,0,0,
  	0,8435,1185,1,0,0,0,8436,8442,5,467,0,0,8437,8439,5,185,0,0,8438,8440,
  	5,446,0,0,8439,8438,1,0,0,0,8439,8440,1,0,0,0,8440,8442,1,0,0,0,8441,
  	8436,1,0,0,0,8441,8437,1,0,0,0,8442,1187,1,0,0,0,8443,8446,5,32,0,0,8444,
  	8447,3,1444,722,0,8445,8447,5,45,0,0,8446,8444,1,0,0,0,8446,8445,1,0,
  	0,0,8447,8448,1,0,0,0,8448,8449,5,33,0,0,8449,1189,1,0,0,0,8450,8452,
  	7,140,0,0,8451,8450,1,0,0,0,8452,8453,1,0,0,0,8453,8451,1,0,0,0,8453,
  	8454,1,0,0,0,8454,1191,1,0,0,0,8455,8470,3,1194,597,0,8456,8470,3,1196,
  	598,0,8457,8470,5,91,0,0,8458,8459,3,1022,511,0,8459,8461,3,1204,602,
  	0,8460,8462,5,77,0,0,8461,8460,1,0,0,0,8461,8462,1,0,0,0,8462,8470,1,
  	0,0,0,8463,8467,5,77,0,0,8464,8465,3,1022,511,0,8465,8466,3,1204,602,
  	0,8466,8468,1,0,0,0,8467,8464,1,0,0,0,8467,8468,1,0,0,0,8468,8470,1,0,
  	0,0,8469,8455,1,0,0,0,8469,8456,1,0,0,0,8469,8457,1,0,0,0,8469,8458,1,
  	0,0,0,8469,8463,1,0,0,0,8470,1193,1,0,0,0,8471,8473,5,65,0,0,8472,8474,
  	5,77,0,0,8473,8472,1,0,0,0,8473,8474,1,0,0,0,8474,8478,1,0,0,0,8475,8476,
  	5,77,0,0,8476,8478,5,65,0,0,8477,8471,1,0,0,0,8477,8475,1,0,0,0,8478,
  	1195,1,0,0,0,8479,8481,5,632,0,0,8480,8482,5,77,0,0,8481,8480,1,0,0,0,
  	8481,8482,1,0,0,0,8482,8486,1,0,0,0,8483,8484,5,77,0,0,8484,8486,5,632,
  	0,0,8485,8479,1,0,0,0,8485,8483,1,0,0,0,8486,1197,1,0,0,0,8487,8488,5,
  	32,0,0,8488,8489,3,1440,720,0,8489,8490,5,33,0,0,8490,1199,1,0,0,0,8491,
  	8492,5,32,0,0,8492,8493,5,3,0,0,8493,8494,5,33,0,0,8494,1201,1,0,0,0,
  	8495,8501,1,0,0,0,8496,8501,3,1494,747,0,8497,8498,5,32,0,0,8498,8499,
  	5,3,0,0,8499,8501,5,33,0,0,8500,8495,1,0,0,0,8500,8496,1,0,0,0,8500,8497,
  	1,0,0,0,8501,1203,1,0,0,0,8502,8507,3,1486,743,0,8503,8507,5,77,0,0,8504,
  	8505,4,602,248,0,8505,8507,5,168,0,0,8506,8502,1,0,0,0,8506,8503,1,0,
  	0,0,8506,8504,1,0,0,0,8507,1205,1,0,0,0,8508,8514,3,1486,743,0,8509,8510,
  	4,603,249,0,8510,8514,5,168,0,0,8511,8512,4,603,250,0,8512,8514,5,77,
  	0,0,8513,8508,1,0,0,0,8513,8509,1,0,0,0,8513,8511,1,0,0,0,8514,1207,1,
  	0,0,0,8515,8522,3,1216,608,0,8516,8518,5,29,0,0,8517,8516,1,0,0,0,8517,
  	8518,1,0,0,0,8518,8519,1,0,0,0,8519,8521,3,1216,608,0,8520,8517,1,0,0,
  	0,8521,8524,1,0,0,0,8522,8520,1,0,0,0,8522,8523,1,0,0,0,8523,1209,1,0,
  	0,0,8524,8522,1,0,0,0,8525,8527,3,1208,604,0,8526,8528,3,1212,606,0,8527,
  	8526,1,0,0,0,8527,8528,1,0,0,0,8528,8531,1,0,0,0,8529,8531,3,1212,606,
  	0,8530,8525,1,0,0,0,8530,8529,1,0,0,0,8531,1211,1,0,0,0,8532,8534,3,1226,
  	613,0,8533,8535,3,92,46,0,8534,8533,1,0,0,0,8534,8535,1,0,0,0,8535,8538,
  	1,0,0,0,8536,8538,3,92,46,0,8537,8532,1,0,0,0,8537,8536,1,0,0,0,8538,
  	1213,1,0,0,0,8539,8541,3,1216,608,0,8540,8539,1,0,0,0,8541,8542,1,0,0,
  	0,8542,8540,1,0,0,0,8542,8543,1,0,0,0,8543,1215,1,0,0,0,8544,8546,5,202,
  	0,0,8545,8547,5,6,0,0,8546,8545,1,0,0,0,8546,8547,1,0,0,0,8547,8548,1,
  	0,0,0,8548,8691,3,1390,695,0,8549,8550,4,608,251,0,8550,8552,5,746,0,
  	0,8551,8553,3,1496,748,0,8552,8551,1,0,0,0,8552,8553,1,0,0,0,8553,8556,
  	1,0,0,0,8554,8557,5,406,0,0,8555,8557,3,1486,743,0,8556,8554,1,0,0,0,
  	8556,8555,1,0,0,0,8557,8691,1,0,0,0,8558,8560,5,355,0,0,8559,8561,5,6,
  	0,0,8560,8559,1,0,0,0,8560,8561,1,0,0,0,8561,8562,1,0,0,0,8562,8691,3,
  	1442,721,0,8563,8565,5,375,0,0,8564,8566,5,6,0,0,8565,8564,1,0,0,0,8565,
  	8566,1,0,0,0,8566,8567,1,0,0,0,8567,8691,3,1442,721,0,8568,8570,5,70,
  	0,0,8569,8571,5,6,0,0,8570,8569,1,0,0,0,8570,8571,1,0,0,0,8571,8572,1,
  	0,0,0,8572,8691,3,1442,721,0,8573,8575,5,436,0,0,8574,8576,5,6,0,0,8575,
  	8574,1,0,0,0,8575,8576,1,0,0,0,8576,8577,1,0,0,0,8577,8691,3,1458,729,
  	0,8578,8580,5,119,0,0,8579,8581,5,6,0,0,8580,8579,1,0,0,0,8580,8581,1,
  	0,0,0,8581,8582,1,0,0,0,8582,8691,3,1458,729,0,8583,8584,4,608,252,0,
  	8584,8586,5,125,0,0,8585,8587,5,6,0,0,8586,8585,1,0,0,0,8586,8587,1,0,
  	0,0,8587,8588,1,0,0,0,8588,8691,3,1460,730,0,8589,8590,4,608,253,0,8590,
  	8592,5,197,0,0,8591,8593,5,6,0,0,8592,8591,1,0,0,0,8592,8593,1,0,0,0,
  	8593,8594,1,0,0,0,8594,8691,3,1460,730,0,8595,8597,5,69,0,0,8596,8598,
  	5,6,0,0,8597,8596,1,0,0,0,8597,8598,1,0,0,0,8598,8599,1,0,0,0,8599,8691,
  	3,1442,721,0,8600,8602,5,429,0,0,8601,8603,5,6,0,0,8602,8601,1,0,0,0,
  	8602,8603,1,0,0,0,8603,8604,1,0,0,0,8604,8691,3,1218,609,0,8605,8607,
  	7,141,0,0,8606,8608,5,6,0,0,8607,8606,1,0,0,0,8607,8608,1,0,0,0,8608,
  	8609,1,0,0,0,8609,8691,3,1218,609,0,8610,8612,7,142,0,0,8611,8613,5,6,
  	0,0,8612,8611,1,0,0,0,8612,8613,1,0,0,0,8613,8614,1,0,0,0,8614,8691,3,
  	1438,719,0,8615,8617,5,172,0,0,8616,8618,5,6,0,0,8617,8616,1,0,0,0,8617,
  	8618,1,0,0,0,8618,8619,1,0,0,0,8619,8691,3,1438,719,0,8620,8622,5,515,
  	0,0,8621,8623,5,6,0,0,8622,8621,1,0,0,0,8622,8623,1,0,0,0,8623,8624,1,
  	0,0,0,8624,8691,7,143,0,0,8625,8627,5,634,0,0,8626,8628,5,6,0,0,8627,
  	8626,1,0,0,0,8627,8628,1,0,0,0,8628,8629,1,0,0,0,8629,8630,5,32,0,0,8630,
  	8631,3,1400,700,0,8631,8632,5,33,0,0,8632,8691,1,0,0,0,8633,8691,3,1224,
  	612,0,8634,8691,3,1220,610,0,8635,8637,5,279,0,0,8636,8638,5,6,0,0,8637,
  	8636,1,0,0,0,8637,8638,1,0,0,0,8638,8639,1,0,0,0,8639,8691,7,144,0,0,
  	8640,8641,5,154,0,0,8641,8643,5,179,0,0,8642,8644,5,6,0,0,8643,8642,1,
  	0,0,0,8643,8644,1,0,0,0,8644,8645,1,0,0,0,8645,8691,3,1460,730,0,8646,
  	8647,5,272,0,0,8647,8649,5,179,0,0,8648,8650,5,6,0,0,8649,8648,1,0,0,
  	0,8649,8650,1,0,0,0,8650,8651,1,0,0,0,8651,8691,3,1460,730,0,8652,8658,
  	5,598,0,0,8653,8655,4,608,254,0,8654,8656,5,6,0,0,8655,8654,1,0,0,0,8655,
  	8656,1,0,0,0,8656,8659,1,0,0,0,8657,8659,1,0,0,0,8658,8653,1,0,0,0,8658,
  	8657,1,0,0,0,8659,8660,1,0,0,0,8660,8691,3,1426,713,0,8661,8662,5,579,
  	0,0,8662,8691,7,145,0,0,8663,8665,5,128,0,0,8664,8666,5,6,0,0,8665,8664,
  	1,0,0,0,8665,8666,1,0,0,0,8666,8667,1,0,0,0,8667,8691,3,1460,730,0,8668,
  	8670,5,298,0,0,8669,8671,5,6,0,0,8670,8669,1,0,0,0,8670,8671,1,0,0,0,
  	8671,8672,1,0,0,0,8672,8691,3,1442,721,0,8673,8674,4,608,255,0,8674,8675,
  	5,569,0,0,8675,8691,5,618,0,0,8676,8677,4,608,256,0,8677,8679,5,774,0,
  	0,8678,8680,5,6,0,0,8679,8678,1,0,0,0,8679,8680,1,0,0,0,8680,8681,1,0,
  	0,0,8681,8691,3,1504,752,0,8682,8683,4,608,257,0,8683,8685,5,775,0,0,
  	8684,8686,5,6,0,0,8685,8684,1,0,0,0,8685,8686,1,0,0,0,8686,8687,1,0,0,
  	0,8687,8691,3,1504,752,0,8688,8689,4,608,258,0,8689,8691,3,158,79,0,8690,
  	8544,1,0,0,0,8690,8549,1,0,0,0,8690,8558,1,0,0,0,8690,8563,1,0,0,0,8690,
  	8568,1,0,0,0,8690,8573,1,0,0,0,8690,8578,1,0,0,0,8690,8583,1,0,0,0,8690,
  	8589,1,0,0,0,8690,8595,1,0,0,0,8690,8600,1,0,0,0,8690,8605,1,0,0,0,8690,
  	8610,1,0,0,0,8690,8615,1,0,0,0,8690,8620,1,0,0,0,8690,8625,1,0,0,0,8690,
  	8633,1,0,0,0,8690,8634,1,0,0,0,8690,8635,1,0,0,0,8690,8640,1,0,0,0,8690,
  	8646,1,0,0,0,8690,8652,1,0,0,0,8690,8661,1,0,0,0,8690,8663,1,0,0,0,8690,
  	8668,1,0,0,0,8690,8673,1,0,0,0,8690,8676,1,0,0,0,8690,8682,1,0,0,0,8690,
  	8688,1,0,0,0,8691,1217,1,0,0,0,8692,8695,3,1438,719,0,8693,8695,5,168,
  	0,0,8694,8692,1,0,0,0,8694,8693,1,0,0,0,8695,1219,1,0,0,0,8696,8698,5,
  	168,0,0,8697,8696,1,0,0,0,8697,8698,1,0,0,0,8698,8699,1,0,0,0,8699,8701,
  	5,113,0,0,8700,8702,5,6,0,0,8701,8700,1,0,0,0,8701,8702,1,0,0,0,8702,
  	8703,1,0,0,0,8703,8704,3,1206,603,0,8704,1221,1,0,0,0,8705,8707,5,168,
  	0,0,8706,8705,1,0,0,0,8706,8707,1,0,0,0,8707,8708,1,0,0,0,8708,8710,5,
  	197,0,0,8709,8711,5,6,0,0,8710,8709,1,0,0,0,8710,8711,1,0,0,0,8711,8712,
  	1,0,0,0,8712,8713,3,1458,729,0,8713,1223,1,0,0,0,8714,8716,5,168,0,0,
  	8715,8714,1,0,0,0,8715,8716,1,0,0,0,8716,8717,1,0,0,0,8717,8719,3,1022,
  	511,0,8718,8720,5,6,0,0,8719,8718,1,0,0,0,8719,8720,1,0,0,0,8720,8721,
  	1,0,0,0,8721,8722,3,1204,602,0,8722,1225,1,0,0,0,8723,8724,5,435,0,0,
  	8724,8725,5,90,0,0,8725,8728,3,1228,614,0,8726,8727,5,434,0,0,8727,8729,
  	3,1440,720,0,8728,8726,1,0,0,0,8728,8729,1,0,0,0,8729,8731,1,0,0,0,8730,
  	8732,3,1230,615,0,8731,8730,1,0,0,0,8731,8732,1,0,0,0,8732,8734,1,0,0,
  	0,8733,8735,3,1234,617,0,8734,8733,1,0,0,0,8734,8735,1,0,0,0,8735,1227,
  	1,0,0,0,8736,8738,5,311,0,0,8737,8736,1,0,0,0,8737,8738,1,0,0,0,8738,
  	8739,1,0,0,0,8739,8741,5,299,0,0,8740,8742,3,1232,616,0,8741,8740,1,0,
  	0,0,8741,8742,1,0,0,0,8742,8743,1,0,0,0,8743,8745,5,32,0,0,8744,8746,
  	3,1428,714,0,8745,8744,1,0,0,0,8745,8746,1,0,0,0,8746,8747,1,0,0,0,8747,
  	8770,5,33,0,0,8748,8750,5,311,0,0,8749,8748,1,0,0,0,8749,8750,1,0,0,0,
  	8750,8751,1,0,0,0,8751,8752,5,256,0,0,8752,8753,5,32,0,0,8753,8754,3,
  	934,467,0,8754,8755,5,33,0,0,8755,8770,1,0,0,0,8756,8767,7,146,0,0,8757,
  	8758,5,32,0,0,8758,8759,3,934,467,0,8759,8760,5,33,0,0,8760,8768,1,0,
  	0,0,8761,8762,5,115,0,0,8762,8764,5,32,0,0,8763,8765,3,1428,714,0,8764,
  	8763,1,0,0,0,8764,8765,1,0,0,0,8765,8766,1,0,0,0,8766,8768,5,33,0,0,8767,
  	8757,1,0,0,0,8767,8761,1,0,0,0,8768,8770,1,0,0,0,8769,8737,1,0,0,0,8769,
  	8749,1,0,0,0,8769,8756,1,0,0,0,8770,1229,1,0,0,0,8771,8772,5,587,0,0,
  	8772,8774,5,90,0,0,8773,8775,5,311,0,0,8774,8773,1,0,0,0,8774,8775,1,
  	0,0,0,8775,8786,1,0,0,0,8776,8777,5,256,0,0,8777,8778,5,32,0,0,8778,8779,
  	3,934,467,0,8779,8780,5,33,0,0,8780,8787,1,0,0,0,8781,8783,5,299,0,0,
  	8782,8784,3,1232,616,0,8783,8782,1,0,0,0,8783,8784,1,0,0,0,8784,8785,
  	1,0,0,0,8785,8787,3,1430,715,0,8786,8776,1,0,0,0,8786,8781,1,0,0,0,8787,
  	8790,1,0,0,0,8788,8789,5,586,0,0,8789,8791,3,1440,720,0,8790,8788,1,0,
  	0,0,8790,8791,1,0,0,0,8791,1231,1,0,0,0,8792,8793,5,55,0,0,8793,8794,
  	5,6,0,0,8794,8795,3,1440,720,0,8795,1233,1,0,0,0,8796,8797,5,32,0,0,8797,
  	8802,3,1236,618,0,8798,8799,5,29,0,0,8799,8801,3,1236,618,0,8800,8798,
  	1,0,0,0,8801,8804,1,0,0,0,8802,8800,1,0,0,0,8802,8803,1,0,0,0,8803,8805,
  	1,0,0,0,8804,8802,1,0,0,0,8805,8806,5,33,0,0,8806,1235,1,0,0,0,8807,8808,
  	5,435,0,0,8808,8819,3,1426,713,0,8809,8810,5,652,0,0,8810,8811,5,307,
  	0,0,8811,8814,5,607,0,0,8812,8815,3,1244,622,0,8813,8815,5,361,0,0,8814,
  	8812,1,0,0,0,8814,8813,1,0,0,0,8815,8820,1,0,0,0,8816,8817,5,652,0,0,
  	8817,8818,5,286,0,0,8818,8820,3,1238,619,0,8819,8809,1,0,0,0,8819,8816,
  	1,0,0,0,8819,8820,1,0,0,0,8820,8824,1,0,0,0,8821,8823,3,1240,620,0,8822,
  	8821,1,0,0,0,8823,8826,1,0,0,0,8824,8822,1,0,0,0,8824,8825,1,0,0,0,8825,
  	8838,1,0,0,0,8826,8824,1,0,0,0,8827,8828,5,32,0,0,8828,8833,3,1242,621,
  	0,8829,8830,5,29,0,0,8830,8832,3,1242,621,0,8831,8829,1,0,0,0,8832,8835,
  	1,0,0,0,8833,8831,1,0,0,0,8833,8834,1,0,0,0,8834,8836,1,0,0,0,8835,8833,
  	1,0,0,0,8836,8837,5,33,0,0,8837,8839,1,0,0,0,8838,8827,1,0,0,0,8838,8839,
  	1,0,0,0,8839,1237,1,0,0,0,8840,8853,3,1244,622,0,8841,8842,5,32,0,0,8842,
  	8847,3,1244,622,0,8843,8844,5,29,0,0,8844,8846,3,1244,622,0,8845,8843,
  	1,0,0,0,8846,8849,1,0,0,0,8847,8845,1,0,0,0,8847,8848,1,0,0,0,8848,8850,
  	1,0,0,0,8849,8847,1,0,0,0,8850,8851,5,33,0,0,8851,8853,1,0,0,0,8852,8840,
  	1,0,0,0,8852,8841,1,0,0,0,8853,1239,1,0,0,0,8854,8856,5,598,0,0,8855,
  	8857,5,6,0,0,8856,8855,1,0,0,0,8856,8857,1,0,0,0,8857,8858,1,0,0,0,8858,
  	8889,3,1426,713,0,8859,8861,5,579,0,0,8860,8859,1,0,0,0,8860,8861,1,0,
  	0,0,8861,8862,1,0,0,0,8862,8864,5,202,0,0,8863,8865,5,6,0,0,8864,8863,
  	1,0,0,0,8864,8865,1,0,0,0,8865,8866,1,0,0,0,8866,8889,3,1390,695,0,8867,
  	8869,5,398,0,0,8868,8870,5,6,0,0,8869,8868,1,0,0,0,8869,8870,1,0,0,0,
  	8870,8871,1,0,0,0,8871,8889,3,1440,720,0,8872,8874,7,147,0,0,8873,8875,
  	5,6,0,0,8874,8873,1,0,0,0,8874,8875,1,0,0,0,8875,8876,1,0,0,0,8876,8889,
  	3,1440,720,0,8877,8878,7,148,0,0,8878,8880,5,179,0,0,8879,8881,5,6,0,
  	0,8880,8879,1,0,0,0,8880,8881,1,0,0,0,8881,8882,1,0,0,0,8882,8889,3,1464,
  	732,0,8883,8885,5,119,0,0,8884,8886,5,6,0,0,8885,8884,1,0,0,0,8885,8886,
  	1,0,0,0,8886,8887,1,0,0,0,8887,8889,3,1464,732,0,8888,8854,1,0,0,0,8888,
  	8860,1,0,0,0,8888,8867,1,0,0,0,8888,8872,1,0,0,0,8888,8877,1,0,0,0,8888,
  	8883,1,0,0,0,8889,1241,1,0,0,0,8890,8891,5,587,0,0,8891,8895,3,1486,743,
  	0,8892,8894,3,1240,620,0,8893,8892,1,0,0,0,8894,8897,1,0,0,0,8895,8893,
  	1,0,0,0,8895,8896,1,0,0,0,8896,1243,1,0,0,0,8897,8895,1,0,0,0,8898,8899,
  	5,32,0,0,8899,8904,3,1246,623,0,8900,8901,5,29,0,0,8901,8903,3,1246,623,
  	0,8902,8900,1,0,0,0,8903,8906,1,0,0,0,8904,8902,1,0,0,0,8904,8905,1,0,
  	0,0,8905,8907,1,0,0,0,8906,8904,1,0,0,0,8907,8908,5,33,0,0,8908,1245,
  	1,0,0,0,8909,8912,3,934,467,0,8910,8912,5,361,0,0,8911,8909,1,0,0,0,8911,
  	8910,1,0,0,0,8912,1247,1,0,0,0,8913,8914,5,170,0,0,8914,8915,5,6,0,0,
  	8915,8916,3,1322,661,0,8916,1249,1,0,0,0,8917,8918,5,267,0,0,8918,8919,
  	5,213,0,0,8919,1251,1,0,0,0,8920,8922,3,1250,625,0,8921,8920,1,0,0,0,
  	8921,8922,1,0,0,0,8922,8923,1,0,0,0,8923,8924,3,1254,627,0,8924,1253,
  	1,0,0,0,8925,8933,3,1426,713,0,8926,8930,4,627,259,0,8927,8931,3,1432,
  	716,0,8928,8929,5,168,0,0,8929,8931,3,1436,718,0,8930,8927,1,0,0,0,8930,
  	8928,1,0,0,0,8931,8933,1,0,0,0,8932,8925,1,0,0,0,8932,8926,1,0,0,0,8933,
  	1255,1,0,0,0,8934,8935,5,267,0,0,8935,8936,3,1024,512,0,8936,8937,5,213,
  	0,0,8937,1257,1,0,0,0,8938,8939,5,268,0,0,8939,8940,5,636,0,0,8940,8941,
  	5,644,0,0,8941,1259,1,0,0,0,8942,8944,7,149,0,0,8943,8942,1,0,0,0,8943,
  	8944,1,0,0,0,8944,8945,1,0,0,0,8945,8946,3,1262,631,0,8946,1261,1,0,0,
  	0,8947,8948,3,1404,702,0,8948,8949,3,1266,633,0,8949,1263,1,0,0,0,8950,
  	8951,5,113,0,0,8951,8952,3,1206,603,0,8952,1265,1,0,0,0,8953,8955,3,1182,
  	591,0,8954,8956,3,1264,632,0,8955,8954,1,0,0,0,8955,8956,1,0,0,0,8956,
  	1267,1,0,0,0,8957,8958,5,32,0,0,8958,8959,3,1354,677,0,8959,8960,5,29,
  	0,0,8960,8961,3,1354,677,0,8961,8962,5,33,0,0,8962,1269,1,0,0,0,8963,
  	8968,3,1370,685,0,8964,8965,5,29,0,0,8965,8967,3,1370,685,0,8966,8964,
  	1,0,0,0,8967,8970,1,0,0,0,8968,8966,1,0,0,0,8968,8969,1,0,0,0,8969,1271,
  	1,0,0,0,8970,8968,1,0,0,0,8971,8976,3,1274,637,0,8972,8973,5,29,0,0,8973,
  	8975,3,1274,637,0,8974,8972,1,0,0,0,8975,8978,1,0,0,0,8976,8974,1,0,0,
  	0,8976,8977,1,0,0,0,8977,1273,1,0,0,0,8978,8976,1,0,0,0,8979,8980,3,1342,
  	671,0,8980,8983,5,6,0,0,8981,8984,3,924,462,0,8982,8984,5,168,0,0,8983,
  	8981,1,0,0,0,8983,8982,1,0,0,0,8984,1275,1,0,0,0,8985,8986,3,1022,511,
  	0,8986,8987,3,1204,602,0,8987,1277,1,0,0,0,8988,8990,5,115,0,0,8989,8991,
  	3,1280,640,0,8990,8989,1,0,0,0,8991,8992,1,0,0,0,8992,8990,1,0,0,0,8992,
  	8993,1,0,0,0,8993,1279,1,0,0,0,8994,8995,5,605,0,0,8995,8996,5,90,0,0,
  	8996,9024,3,1460,730,0,8997,8999,5,422,0,0,8998,8997,1,0,0,0,8998,8999,
  	1,0,0,0,8999,9000,1,0,0,0,9000,9001,5,196,0,0,9001,9002,5,90,0,0,9002,
  	9024,3,1460,730,0,9003,9004,5,206,0,0,9004,9005,5,90,0,0,9005,9024,3,
  	1460,730,0,9006,9021,4,640,260,0,9007,9008,5,401,0,0,9008,9022,5,196,
  	0,0,9009,9010,5,158,0,0,9010,9011,5,237,0,0,9011,9022,3,1460,730,0,9012,
  	9013,5,612,0,0,9013,9014,5,237,0,0,9014,9022,3,1460,730,0,9015,9016,5,
  	406,0,0,9016,9017,5,63,0,0,9017,9022,3,1460,730,0,9018,9019,5,725,0,0,
  	9019,9020,5,63,0,0,9020,9022,3,1460,730,0,9021,9007,1,0,0,0,9021,9009,
  	1,0,0,0,9021,9012,1,0,0,0,9021,9015,1,0,0,0,9021,9018,1,0,0,0,9022,9024,
  	1,0,0,0,9023,8994,1,0,0,0,9023,8998,1,0,0,0,9023,9003,1,0,0,0,9023,9006,
  	1,0,0,0,9024,1281,1,0,0,0,9025,9027,5,312,0,0,9026,9028,3,1284,642,0,
  	9027,9026,1,0,0,0,9028,9029,1,0,0,0,9029,9027,1,0,0,0,9029,9030,1,0,0,
  	0,9030,1283,1,0,0,0,9031,9032,7,150,0,0,9032,9033,5,90,0,0,9033,9034,
  	3,1460,730,0,9034,1285,1,0,0,0,9035,9040,3,1322,661,0,9036,9037,5,29,
  	0,0,9037,9039,3,1322,661,0,9038,9036,1,0,0,0,9039,9042,1,0,0,0,9040,9038,
  	1,0,0,0,9040,9041,1,0,0,0,9041,1287,1,0,0,0,9042,9040,1,0,0,0,9043,9048,
  	3,1290,645,0,9044,9045,5,29,0,0,9045,9047,3,1290,645,0,9046,9044,1,0,
  	0,0,9047,9050,1,0,0,0,9048,9046,1,0,0,0,9048,9049,1,0,0,0,9049,1289,1,
  	0,0,0,9050,9048,1,0,0,0,9051,9064,3,1322,661,0,9052,9055,3,1294,647,0,
  	9053,9054,4,645,261,0,9054,9056,3,1292,646,0,9055,9053,1,0,0,0,9055,9056,
  	1,0,0,0,9056,9065,1,0,0,0,9057,9060,3,1300,650,0,9058,9059,4,645,262,
  	0,9059,9061,3,1308,654,0,9060,9058,1,0,0,0,9060,9061,1,0,0,0,9061,9065,
  	1,0,0,0,9062,9063,4,645,263,0,9063,9065,3,1292,646,0,9064,9052,1,0,0,
  	0,9064,9057,1,0,0,0,9064,9062,1,0,0,0,9064,9065,1,0,0,0,9065,1291,1,0,
  	0,0,9066,9067,5,61,0,0,9067,9070,3,1294,647,0,9068,9069,5,61,0,0,9069,
  	9071,3,1294,647,0,9070,9068,1,0,0,0,9070,9071,1,0,0,0,9071,1293,1,0,0,
  	0,9072,9082,3,1296,648,0,9073,9074,4,647,264,0,9074,9082,3,1298,649,0,
  	9075,9082,3,1300,650,0,9076,9082,3,1302,651,0,9077,9078,4,647,265,0,9078,
  	9082,3,1304,652,0,9079,9080,4,647,266,0,9080,9082,3,1306,653,0,9081,9072,
  	1,0,0,0,9081,9073,1,0,0,0,9081,9075,1,0,0,0,9081,9076,1,0,0,0,9081,9077,
  	1,0,0,0,9081,9079,1,0,0,0,9082,1295,1,0,0,0,9083,9084,5,266,0,0,9084,
  	9087,5,90,0,0,9085,9086,4,648,267,0,9086,9088,5,436,0,0,9087,9085,1,0,
  	0,0,9087,9088,1,0,0,0,9088,9089,1,0,0,0,9089,9090,3,1458,729,0,9090,1297,
  	1,0,0,0,9091,9092,5,266,0,0,9092,9093,5,90,0,0,9093,9094,5,759,0,0,9094,
  	9095,5,436,0,0,9095,1299,1,0,0,0,9096,9097,5,266,0,0,9097,9098,5,670,
  	0,0,9098,9099,3,1486,743,0,9099,1301,1,0,0,0,9100,9101,5,266,0,0,9101,
  	9102,5,670,0,0,9102,9103,3,1486,743,0,9103,9104,5,63,0,0,9104,9105,3,
  	1462,731,0,9105,1303,1,0,0,0,9106,9107,5,266,0,0,9107,9108,5,670,0,0,
  	9108,9109,3,1486,743,0,9109,9110,5,90,0,0,9110,9111,3,1458,729,0,9111,
  	1305,1,0,0,0,9112,9113,5,266,0,0,9113,9114,5,670,0,0,9114,9115,3,1486,
  	743,0,9115,9116,5,90,0,0,9116,9117,5,759,0,0,9117,9118,5,436,0,0,9118,
  	1307,1,0,0,0,9119,9120,5,817,0,0,9120,9124,5,811,0,0,9121,9125,3,1298,
  	649,0,9122,9125,3,1302,651,0,9123,9125,3,1296,648,0,9124,9121,1,0,0,0,
  	9124,9122,1,0,0,0,9124,9123,1,0,0,0,9125,1309,1,0,0,0,9126,9127,5,752,
  	0,0,9127,9128,5,144,0,0,9128,9129,5,436,0,0,9129,1311,1,0,0,0,9130,9131,
  	5,181,0,0,9131,9132,5,753,0,0,9132,9133,5,436,0,0,9133,1313,1,0,0,0,9134,
  	9135,3,1316,658,0,9135,9136,5,814,0,0,9136,9137,5,815,0,0,9137,9150,1,
  	0,0,0,9138,9139,3,1316,658,0,9139,9140,5,816,0,0,9140,9150,1,0,0,0,9141,
  	9142,3,1316,658,0,9142,9143,5,813,0,0,9143,9144,5,815,0,0,9144,9145,5,
  	533,0,0,9145,9146,5,818,0,0,9146,9147,5,63,0,0,9147,9148,3,1462,731,0,
  	9148,9150,1,0,0,0,9149,9134,1,0,0,0,9149,9138,1,0,0,0,9149,9141,1,0,0,
  	0,9150,1315,1,0,0,0,9151,9152,3,1470,735,0,9152,9153,5,812,0,0,9153,1317,
  	1,0,0,0,9154,9155,5,488,0,0,9155,9156,3,1460,730,0,9156,1319,1,0,0,0,
  	9157,9163,3,1486,743,0,9158,9161,5,39,0,0,9159,9162,3,1486,743,0,9160,
  	9162,5,854,0,0,9161,9159,1,0,0,0,9161,9160,1,0,0,0,9162,9164,1,0,0,0,
  	9163,9158,1,0,0,0,9163,9164,1,0,0,0,9164,1321,1,0,0,0,9165,9171,3,1320,
  	660,0,9166,9168,5,147,0,0,9167,9169,3,1494,747,0,9168,9167,1,0,0,0,9168,
  	9169,1,0,0,0,9169,9171,1,0,0,0,9170,9165,1,0,0,0,9170,9166,1,0,0,0,9171,
  	1323,1,0,0,0,9172,9173,5,309,0,0,9173,9174,3,1458,729,0,9174,1325,1,0,
  	0,0,9175,9178,3,1324,662,0,9176,9178,3,408,204,0,9177,9175,1,0,0,0,9177,
  	9176,1,0,0,0,9178,1327,1,0,0,0,9179,9180,7,151,0,0,9180,1329,1,0,0,0,
  	9181,9182,7,152,0,0,9182,1331,1,0,0,0,9183,9184,5,435,0,0,9184,9185,3,
  	1430,715,0,9185,1333,1,0,0,0,9186,9192,3,1436,718,0,9187,9189,3,1432,
  	716,0,9188,9190,3,1436,718,0,9189,9188,1,0,0,0,9189,9190,1,0,0,0,9190,
  	9192,1,0,0,0,9191,9186,1,0,0,0,9191,9187,1,0,0,0,9192,1335,1,0,0,0,9193,
  	9194,4,668,268,0,9194,9198,3,1426,713,0,9195,9196,4,668,269,0,9196,9198,
  	3,1334,667,0,9197,9193,1,0,0,0,9197,9195,1,0,0,0,9198,1337,1,0,0,0,9199,
  	9200,3,1426,713,0,9200,1339,1,0,0,0,9201,9202,5,32,0,0,9202,9207,3,1338,
  	669,0,9203,9204,5,29,0,0,9204,9206,3,1338,669,0,9205,9203,1,0,0,0,9206,
  	9209,1,0,0,0,9207,9205,1,0,0,0,9207,9208,1,0,0,0,9208,9210,1,0,0,0,9209,
  	9207,1,0,0,0,9210,9211,5,33,0,0,9211,1341,1,0,0,0,9212,9213,3,1334,667,
  	0,9213,1343,1,0,0,0,9214,9217,3,1342,671,0,9215,9217,3,1350,675,0,9216,
  	9214,1,0,0,0,9216,9215,1,0,0,0,9217,1345,1,0,0,0,9218,9219,3,1426,713,
  	0,9219,1347,1,0,0,0,9220,9221,3,1334,667,0,9221,1349,1,0,0,0,9222,9223,
  	3,1426,713,0,9223,9227,5,28,0,0,9224,9225,3,1426,713,0,9225,9226,5,28,
  	0,0,9226,9228,1,0,0,0,9227,9224,1,0,0,0,9227,9228,1,0,0,0,9228,9229,1,
  	0,0,0,9229,9230,5,16,0,0,9230,1351,1,0,0,0,9231,9232,3,1426,713,0,9232,
  	1353,1,0,0,0,9233,9234,3,1426,713,0,9234,1355,1,0,0,0,9235,9236,3,1432,
  	716,0,9236,1357,1,0,0,0,9237,9238,3,1432,716,0,9238,1359,1,0,0,0,9239,
  	9240,3,1432,716,0,9240,1361,1,0,0,0,9241,9242,3,1432,716,0,9242,1363,
  	1,0,0,0,9243,9244,3,1432,716,0,9244,1365,1,0,0,0,9245,9246,3,1432,716,
  	0,9246,1367,1,0,0,0,9247,9250,3,1432,716,0,9248,9250,3,1436,718,0,9249,
  	9247,1,0,0,0,9249,9248,1,0,0,0,9250,1369,1,0,0,0,9251,9254,3,1432,716,
  	0,9252,9254,3,1436,718,0,9253,9251,1,0,0,0,9253,9252,1,0,0,0,9254,1371,
  	1,0,0,0,9255,9256,3,1426,713,0,9256,1373,1,0,0,0,9257,9258,3,1426,713,
  	0,9258,1375,1,0,0,0,9259,9260,3,1426,713,0,9260,1377,1,0,0,0,9261,9262,
  	3,1426,713,0,9262,1379,1,0,0,0,9263,9264,3,1432,716,0,9264,1381,1,0,0,
  	0,9265,9266,3,1432,716,0,9266,1383,1,0,0,0,9267,9268,3,1426,713,0,9268,
  	1385,1,0,0,0,9269,9270,3,1486,743,0,9270,1387,1,0,0,0,9271,9272,3,1486,
  	743,0,9272,1389,1,0,0,0,9273,9274,3,1486,743,0,9274,1391,1,0,0,0,9275,
  	9278,3,1432,716,0,9276,9278,3,1436,718,0,9277,9275,1,0,0,0,9277,9276,
  	1,0,0,0,9278,1393,1,0,0,0,9279,9280,3,1354,677,0,9280,9281,3,1436,718,
  	0,9281,1395,1,0,0,0,9282,9290,3,1426,713,0,9283,9284,5,28,0,0,9284,9291,
  	5,16,0,0,9285,9288,3,1436,718,0,9286,9287,5,28,0,0,9287,9289,5,16,0,0,
  	9288,9286,1,0,0,0,9288,9289,1,0,0,0,9289,9291,1,0,0,0,9290,9283,1,0,0,
  	0,9290,9285,1,0,0,0,9290,9291,1,0,0,0,9291,1397,1,0,0,0,9292,9295,3,1432,
  	716,0,9293,9295,3,1436,718,0,9294,9292,1,0,0,0,9294,9293,1,0,0,0,9295,
  	1399,1,0,0,0,9296,9301,3,1398,699,0,9297,9298,5,29,0,0,9298,9300,3,1398,
  	699,0,9299,9297,1,0,0,0,9300,9303,1,0,0,0,9301,9299,1,0,0,0,9301,9302,
  	1,0,0,0,9302,1401,1,0,0,0,9303,9301,1,0,0,0,9304,9309,3,1396,698,0,9305,
  	9306,5,29,0,0,9306,9308,3,1396,698,0,9307,9305,1,0,0,0,9308,9311,1,0,
  	0,0,9309,9307,1,0,0,0,9309,9310,1,0,0,0,9310,1403,1,0,0,0,9311,9309,1,
  	0,0,0,9312,9313,3,1426,713,0,9313,1405,1,0,0,0,9314,9317,3,1424,712,0,
  	9315,9317,3,1512,756,0,9316,9314,1,0,0,0,9316,9315,1,0,0,0,9317,1407,
  	1,0,0,0,9318,9319,3,1406,703,0,9319,1409,1,0,0,0,9320,9323,3,1424,712,
  	0,9321,9323,3,1518,759,0,9322,9320,1,0,0,0,9322,9321,1,0,0,0,9323,1411,
  	1,0,0,0,9324,9325,3,1426,713,0,9325,1413,1,0,0,0,9326,9327,3,1458,729,
  	0,9327,1415,1,0,0,0,9328,9329,3,1426,713,0,9329,1417,1,0,0,0,9330,9331,
  	3,1426,713,0,9331,1419,1,0,0,0,9332,9333,3,1432,716,0,9333,1421,1,0,0,
  	0,9334,9335,3,1432,716,0,9335,1423,1,0,0,0,9336,9340,7,153,0,0,9337,9338,
  	4,712,270,0,9338,9340,5,845,0,0,9339,9336,1,0,0,0,9339,9337,1,0,0,0,9340,
  	1425,1,0,0,0,9341,9344,3,1424,712,0,9342,9344,3,1506,753,0,9343,9341,
  	1,0,0,0,9343,9342,1,0,0,0,9344,1427,1,0,0,0,9345,9350,3,1426,713,0,9346,
  	9347,5,29,0,0,9347,9349,3,1426,713,0,9348,9346,1,0,0,0,9349,9352,1,0,
  	0,0,9350,9348,1,0,0,0,9350,9351,1,0,0,0,9351,1429,1,0,0,0,9352,9350,1,
  	0,0,0,9353,9354,5,32,0,0,9354,9355,3,1428,714,0,9355,9356,5,33,0,0,9356,
  	1431,1,0,0,0,9357,9359,3,1426,713,0,9358,9360,3,1436,718,0,9359,9358,
  	1,0,0,0,9359,9360,1,0,0,0,9360,1433,1,0,0,0,9361,9366,3,1426,713,0,9362,
  	9364,3,1436,718,0,9363,9365,3,1436,718,0,9364,9363,1,0,0,0,9364,9365,
  	1,0,0,0,9365,9367,1,0,0,0,9366,9362,1,0,0,0,9366,9367,1,0,0,0,9367,9373,
  	1,0,0,0,9368,9369,4,717,271,0,9369,9370,3,1436,718,0,9370,9371,3,1436,
  	718,0,9371,9373,1,0,0,0,9372,9361,1,0,0,0,9372,9368,1,0,0,0,9373,1435,
  	1,0,0,0,9374,9375,5,28,0,0,9375,9376,3,1426,713,0,9376,1437,1,0,0,0,9377,
  	9378,7,154,0,0,9378,1439,1,0,0,0,9379,9380,7,155,0,0,9380,1441,1,0,0,
  	0,9381,9382,7,156,0,0,9382,1443,1,0,0,0,9383,9389,5,3,0,0,9384,9385,4,
  	722,272,0,9385,9389,5,43,0,0,9386,9389,5,5,0,0,9387,9389,5,4,0,0,9388,
  	9383,1,0,0,0,9388,9384,1,0,0,0,9388,9386,1,0,0,0,9388,9387,1,0,0,0,9389,
  	1445,1,0,0,0,9390,9396,3,1450,725,0,9391,9392,5,14,0,0,9392,9396,3,1438,
  	719,0,9393,9394,5,15,0,0,9394,9396,3,1438,719,0,9395,9390,1,0,0,0,9395,
  	9391,1,0,0,0,9395,9393,1,0,0,0,9396,1447,1,0,0,0,9397,9401,3,1446,723,
  	0,9398,9399,4,724,273,0,9399,9401,3,1454,727,0,9400,9397,1,0,0,0,9400,
  	9398,1,0,0,0,9401,1449,1,0,0,0,9402,9412,3,1464,732,0,9403,9412,3,1470,
  	735,0,9404,9412,3,1478,739,0,9405,9412,3,1474,737,0,9406,9412,3,1472,
  	736,0,9407,9409,5,840,0,0,9408,9407,1,0,0,0,9408,9409,1,0,0,0,9409,9410,
  	1,0,0,0,9410,9412,7,157,0,0,9411,9402,1,0,0,0,9411,9403,1,0,0,0,9411,
  	9404,1,0,0,0,9411,9405,1,0,0,0,9411,9406,1,0,0,0,9411,9408,1,0,0,0,9412,
  	1451,1,0,0,0,9413,9417,3,1450,725,0,9414,9415,4,726,274,0,9415,9417,3,
  	1454,727,0,9416,9413,1,0,0,0,9416,9414,1,0,0,0,9417,1453,1,0,0,0,9418,
  	9419,5,406,0,0,9419,1455,1,0,0,0,9420,9421,5,32,0,0,9421,9426,3,1460,
  	730,0,9422,9423,5,29,0,0,9423,9425,3,1460,730,0,9424,9422,1,0,0,0,9425,
  	9428,1,0,0,0,9426,9424,1,0,0,0,9426,9427,1,0,0,0,9427,9429,1,0,0,0,9428,
  	9426,1,0,0,0,9429,9430,5,33,0,0,9430,1457,1,0,0,0,9431,9435,5,846,0,0,
  	9432,9433,4,729,275,0,9433,9435,5,845,0,0,9434,9431,1,0,0,0,9434,9432,
  	1,0,0,0,9435,1459,1,0,0,0,9436,9440,3,1458,729,0,9437,9440,5,43,0,0,9438,
  	9440,5,44,0,0,9439,9436,1,0,0,0,9439,9437,1,0,0,0,9439,9438,1,0,0,0,9440,
  	1461,1,0,0,0,9441,9445,3,1458,729,0,9442,9443,4,731,276,0,9443,9445,5,
  	43,0,0,9444,9441,1,0,0,0,9444,9442,1,0,0,0,9445,1463,1,0,0,0,9446,9448,
  	5,840,0,0,9447,9446,1,0,0,0,9447,9448,1,0,0,0,9448,9449,1,0,0,0,9449,
  	9452,3,1458,729,0,9450,9452,5,843,0,0,9451,9447,1,0,0,0,9451,9450,1,0,
  	0,0,9452,9456,1,0,0,0,9453,9455,3,1458,729,0,9454,9453,1,0,0,0,9455,9458,
  	1,0,0,0,9456,9454,1,0,0,0,9456,9457,1,0,0,0,9457,1465,1,0,0,0,9458,9456,
  	1,0,0,0,9459,9460,3,1458,729,0,9460,1467,1,0,0,0,9461,9466,3,1458,729,
  	0,9462,9463,5,29,0,0,9463,9465,3,1458,729,0,9464,9462,1,0,0,0,9465,9468,
  	1,0,0,0,9466,9464,1,0,0,0,9466,9467,1,0,0,0,9467,1469,1,0,0,0,9468,9466,
  	1,0,0,0,9469,9473,3,1476,738,0,9470,9473,5,45,0,0,9471,9473,5,46,0,0,
  	9472,9469,1,0,0,0,9472,9470,1,0,0,0,9472,9471,1,0,0,0,9473,1471,1,0,0,
  	0,9474,9475,7,158,0,0,9475,1473,1,0,0,0,9476,9477,7,159,0,0,9477,1475,
  	1,0,0,0,9478,9479,7,160,0,0,9479,1477,1,0,0,0,9480,9481,5,158,0,0,9481,
  	9487,5,846,0,0,9482,9483,5,612,0,0,9483,9487,5,846,0,0,9484,9485,5,609,
  	0,0,9485,9487,5,846,0,0,9486,9480,1,0,0,0,9486,9482,1,0,0,0,9486,9484,
  	1,0,0,0,9487,1479,1,0,0,0,9488,9491,3,1188,594,0,9489,9491,3,1484,742,
  	0,9490,9488,1,0,0,0,9490,9489,1,0,0,0,9491,1481,1,0,0,0,9492,9493,3,1484,
  	742,0,9493,1483,1,0,0,0,9494,9495,5,32,0,0,9495,9496,5,3,0,0,9496,9497,
  	5,29,0,0,9497,9498,5,3,0,0,9498,9499,5,33,0,0,9499,1485,1,0,0,0,9500,
  	9503,3,1426,713,0,9501,9503,3,1458,729,0,9502,9500,1,0,0,0,9502,9501,
  	1,0,0,0,9503,1487,1,0,0,0,9504,9507,3,1424,712,0,9505,9507,3,1520,760,
  	0,9506,9504,1,0,0,0,9506,9505,1,0,0,0,9507,1489,1,0,0,0,9508,9511,3,1410,
  	705,0,9509,9511,3,1458,729,0,9510,9508,1,0,0,0,9510,9509,1,0,0,0,9511,
  	1491,1,0,0,0,9512,9515,3,1444,722,0,9513,9515,3,1424,712,0,9514,9512,
  	1,0,0,0,9514,9513,1,0,0,0,9515,1493,1,0,0,0,9516,9517,5,32,0,0,9517,9518,
  	5,33,0,0,9518,1495,1,0,0,0,9519,9520,7,161,0,0,9520,1497,1,0,0,0,9521,
  	9522,4,749,277,0,9522,9529,5,683,0,0,9523,9524,4,749,278,0,9524,9529,
  	5,698,0,0,9525,9529,5,250,0,0,9526,9529,5,316,0,0,9527,9529,5,529,0,0,
  	9528,9521,1,0,0,0,9528,9523,1,0,0,0,9528,9525,1,0,0,0,9528,9526,1,0,0,
  	0,9528,9527,1,0,0,0,9529,1499,1,0,0,0,9530,9531,5,250,0,0,9531,9537,5,
  	28,0,0,9532,9533,5,316,0,0,9533,9537,5,28,0,0,9534,9535,5,529,0,0,9535,
  	9537,5,28,0,0,9536,9530,1,0,0,0,9536,9532,1,0,0,0,9536,9534,1,0,0,0,9537,
  	1501,1,0,0,0,9538,9539,4,751,279,0,9539,9546,5,683,0,0,9540,9541,4,751,
  	280,0,9541,9546,5,698,0,0,9542,9546,5,250,0,0,9543,9546,5,316,0,0,9544,
  	9546,5,529,0,0,9545,9538,1,0,0,0,9545,9540,1,0,0,0,9545,9542,1,0,0,0,
  	9545,9543,1,0,0,0,9545,9544,1,0,0,0,9546,9547,1,0,0,0,9547,9548,5,28,
  	0,0,9548,1503,1,0,0,0,9549,9550,3,1458,729,0,9550,1505,1,0,0,0,9551,9559,
  	4,753,281,0,9552,9560,3,1512,756,0,9553,9560,3,1524,762,0,9554,9560,5,
  	212,0,0,9555,9556,4,753,282,0,9556,9560,5,537,0,0,9557,9558,4,753,283,
  	0,9558,9560,5,739,0,0,9559,9552,1,0,0,0,9559,9553,1,0,0,0,9559,9554,1,
  	0,0,0,9559,9555,1,0,0,0,9559,9557,1,0,0,0,9560,9569,1,0,0,0,9561,9567,
  	3,1516,758,0,9562,9567,3,1508,754,0,9563,9567,3,1510,755,0,9564,9567,
  	3,1514,757,0,9565,9567,3,1522,761,0,9566,9561,1,0,0,0,9566,9562,1,0,0,
  	0,9566,9563,1,0,0,0,9566,9564,1,0,0,0,9566,9565,1,0,0,0,9567,9569,1,0,
  	0,0,9568,9551,1,0,0,0,9568,9566,1,0,0,0,9569,1507,1,0,0,0,9570,9571,7,
  	162,0,0,9571,1509,1,0,0,0,9572,9610,5,65,0,0,9573,9610,5,74,0,0,9574,
  	9610,5,91,0,0,9575,9610,5,92,0,0,9576,9610,5,103,0,0,9577,9610,5,105,
  	0,0,9578,9610,5,702,0,0,9579,9610,5,119,0,0,9580,9610,5,121,0,0,9581,
  	9610,5,134,0,0,9582,9610,5,164,0,0,9583,9610,5,186,0,0,9584,9610,5,198,
  	0,0,9585,9610,5,232,0,0,9586,9610,5,233,0,0,9587,9610,5,255,0,0,9588,
  	9610,5,258,0,0,9589,9610,5,270,0,0,9590,9610,5,281,0,0,9591,9610,5,301,
  	0,0,9592,9610,5,403,0,0,9593,9610,5,445,0,0,9594,9610,5,447,0,0,9595,
  	9610,5,485,0,0,9596,9610,5,498,0,0,9597,9610,5,509,0,0,9598,9610,5,518,
  	0,0,9599,9610,5,539,0,0,9600,9610,5,541,0,0,9601,9610,5,569,0,0,9602,
  	9610,5,578,0,0,9603,9610,5,623,0,0,9604,9610,5,632,0,0,9605,9610,5,633,
  	0,0,9606,9610,5,676,0,0,9607,9608,4,755,284,0,9608,9610,5,78,0,0,9609,
  	9572,1,0,0,0,9609,9573,1,0,0,0,9609,9574,1,0,0,0,9609,9575,1,0,0,0,9609,
  	9576,1,0,0,0,9609,9577,1,0,0,0,9609,9578,1,0,0,0,9609,9579,1,0,0,0,9609,
  	9580,1,0,0,0,9609,9581,1,0,0,0,9609,9582,1,0,0,0,9609,9583,1,0,0,0,9609,
  	9584,1,0,0,0,9609,9585,1,0,0,0,9609,9586,1,0,0,0,9609,9587,1,0,0,0,9609,
  	9588,1,0,0,0,9609,9589,1,0,0,0,9609,9590,1,0,0,0,9609,9591,1,0,0,0,9609,
  	9592,1,0,0,0,9609,9593,1,0,0,0,9609,9594,1,0,0,0,9609,9595,1,0,0,0,9609,
  	9596,1,0,0,0,9609,9597,1,0,0,0,9609,9598,1,0,0,0,9609,9599,1,0,0,0,9609,
  	9600,1,0,0,0,9609,9601,1,0,0,0,9609,9602,1,0,0,0,9609,9603,1,0,0,0,9609,
  	9604,1,0,0,0,9609,9605,1,0,0,0,9609,9606,1,0,0,0,9609,9607,1,0,0,0,9610,
  	1511,1,0,0,0,9611,9622,4,756,285,0,9612,9623,3,1526,763,0,9613,9623,5,
  	209,0,0,9614,9623,5,226,0,0,9615,9623,5,399,0,0,9616,9623,5,453,0,0,9617,
  	9623,5,457,0,0,9618,9623,5,481,0,0,9619,9623,5,489,0,0,9620,9623,5,734,
  	0,0,9621,9623,5,591,0,0,9622,9612,1,0,0,0,9622,9613,1,0,0,0,9622,9614,
  	1,0,0,0,9622,9615,1,0,0,0,9622,9616,1,0,0,0,9622,9617,1,0,0,0,9622,9618,
  	1,0,0,0,9622,9619,1,0,0,0,9622,9620,1,0,0,0,9622,9621,1,0,0,0,9623,9630,
  	1,0,0,0,9624,9628,3,1516,758,0,9625,9628,3,1514,757,0,9626,9628,3,1522,
  	761,0,9627,9624,1,0,0,0,9627,9625,1,0,0,0,9627,9626,1,0,0,0,9628,9630,
  	1,0,0,0,9629,9611,1,0,0,0,9629,9627,1,0,0,0,9630,1513,1,0,0,0,9631,9632,
  	7,163,0,0,9632,1515,1,0,0,0,9633,9647,7,164,0,0,9634,9635,4,758,286,0,
  	9635,9647,7,165,0,0,9636,9637,4,758,287,0,9637,9647,7,166,0,0,9638,9639,
  	4,758,288,0,9639,9647,5,824,0,0,9640,9641,4,758,289,0,9641,9647,7,167,
  	0,0,9642,9643,4,758,290,0,9643,9647,7,168,0,0,9644,9645,4,758,291,0,9645,
  	9647,5,834,0,0,9646,9633,1,0,0,0,9646,9634,1,0,0,0,9646,9636,1,0,0,0,
  	9646,9638,1,0,0,0,9646,9640,1,0,0,0,9646,9642,1,0,0,0,9646,9644,1,0,0,
  	0,9647,1517,1,0,0,0,9648,9651,4,759,292,0,9649,9652,3,1526,763,0,9650,
  	9652,3,1524,762,0,9651,9649,1,0,0,0,9651,9650,1,0,0,0,9652,9659,1,0,0,
  	0,9653,9657,3,1516,758,0,9654,9657,3,1510,755,0,9655,9657,3,1522,761,
  	0,9656,9653,1,0,0,0,9656,9654,1,0,0,0,9656,9655,1,0,0,0,9657,9659,1,0,
  	0,0,9658,9648,1,0,0,0,9658,9656,1,0,0,0,9659,1519,1,0,0,0,9660,9665,3,
  	1516,758,0,9661,9665,3,1508,754,0,9662,9665,3,1510,755,0,9663,9665,3,
  	1514,757,0,9664,9660,1,0,0,0,9664,9661,1,0,0,0,9664,9662,1,0,0,0,9664,
  	9663,1,0,0,0,9665,1521,1,0,0,0,9666,9667,7,169,0,0,9667,1523,1,0,0,0,
  	9668,9674,7,170,0,0,9669,9670,4,762,293,0,9670,9674,5,537,0,0,9671,9672,
  	4,762,294,0,9672,9674,5,270,0,0,9673,9668,1,0,0,0,9673,9669,1,0,0,0,9673,
  	9671,1,0,0,0,9674,1525,1,0,0,0,9675,9687,7,171,0,0,9676,9677,4,763,295,
  	0,9677,9687,5,537,0,0,9678,9679,4,763,296,0,9679,9687,7,172,0,0,9680,
  	9681,4,763,297,0,9681,9687,7,173,0,0,9682,9683,4,763,298,0,9683,9687,
  	5,685,0,0,9684,9685,4,763,299,0,9685,9687,5,338,0,0,9686,9675,1,0,0,0,
  	9686,9676,1,0,0,0,9686,9678,1,0,0,0,9686,9680,1,0,0,0,9686,9682,1,0,0,
  	0,9686,9684,1,0,0,0,9687,1527,1,0,0,0,1218,1530,1533,1535,1623,1631,1636,
  	1646,1653,1660,1666,1669,1672,1679,1684,1687,1692,1698,1700,1704,1708,
  	1717,1721,1726,1732,1739,1744,1749,1756,1759,1765,1768,1775,1787,1792,
  	1794,1796,1801,1806,1814,1820,1824,1829,1838,1844,1850,1856,1865,1871,
  	1880,1894,1898,1904,1908,1914,1918,1923,1926,1932,1938,1944,1948,1953,
  	1957,1961,1977,1985,1993,2000,2029,2044,2047,2056,2061,2067,2072,2076,
  	2081,2085,2089,2093,2097,2101,2103,2114,2122,2129,2137,2141,2146,2153,
  	2158,2163,2173,2177,2182,2185,2188,2191,2198,2205,2209,2228,2234,2244,
  	2247,2270,2274,2280,2287,2290,2294,2301,2304,2313,2320,2325,2328,2333,
  	2339,2342,2346,2352,2355,2360,2365,2374,2377,2383,2390,2396,2399,2404,
  	2413,2416,2424,2430,2435,2445,2454,2461,2466,2469,2474,2482,2497,2500,
  	2503,2508,2514,2524,2534,2537,2540,2544,2552,2565,2569,2574,2583,2600,
  	2619,2628,2631,2639,2643,2656,2658,2665,2670,2685,2689,2695,2701,2707,
  	2713,2719,2724,2728,2736,2742,2748,2754,2759,2762,2765,2770,2778,2781,
  	2792,2797,2808,2816,2820,2829,2832,2838,2840,2844,2851,2864,2871,2877,
  	2880,2897,2919,2923,2929,2935,2941,2946,2953,2960,2965,2968,2972,2976,
  	2981,2985,2989,2995,3000,3003,3007,3013,3017,3021,3029,3037,3042,3053,
  	3062,3075,3078,3082,3088,3096,3101,3104,3107,3110,3113,3115,3121,3123,
  	3137,3143,3150,3153,3155,3157,3167,3169,3173,3176,3179,3183,3187,3192,
  	3195,3198,3204,3207,3216,3226,3229,3232,3236,3242,3247,3252,3257,3261,
  	3268,3279,3282,3285,3288,3292,3295,3298,3304,3308,3311,3314,3317,3320,
  	3324,3327,3330,3342,3351,3367,3370,3374,3378,3384,3389,3393,3418,3421,
  	3425,3431,3435,3438,3447,3457,3461,3465,3468,3472,3476,3481,3484,3489,
  	3495,3504,3510,3515,3518,3521,3524,3527,3531,3534,3549,3553,3563,3574,
  	3581,3586,3589,3595,3598,3601,3607,3612,3616,3619,3627,3629,3646,3658,
  	3663,3666,3669,3674,3680,3696,3716,3725,3729,3736,3741,3750,3760,3767,
  	3778,3785,3794,3803,3815,3821,3828,3832,3838,3843,3848,3852,3858,3864,
  	3866,3869,3873,3883,3888,3893,3900,3909,3917,3922,3926,3932,3935,3938,
  	3942,3946,3956,3960,3963,3966,3969,3974,3980,3984,3990,3993,3995,4000,
  	4012,4021,4034,4037,4042,4049,4053,4056,4062,4076,4083,4091,4097,4106,
  	4110,4114,4124,4126,4134,4141,4146,4150,4154,4157,4163,4166,4169,4175,
  	4182,4187,4191,4194,4197,4200,4202,4206,4213,4219,4223,4228,4231,4234,
  	4237,4239,4244,4253,4266,4268,4272,4278,4282,4285,4291,4298,4300,4308,
  	4314,4319,4322,4329,4331,4343,4350,4356,4361,4368,4372,4379,4382,4384,
  	4393,4404,4411,4418,4549,4603,4610,4614,4630,4642,4645,4657,4662,4668,
  	4675,4682,4689,4696,4703,4710,4713,4720,4728,4736,4746,4752,4756,4759,
  	4762,4765,4768,4771,4776,4779,4786,4792,4816,4825,4829,4836,4842,4859,
  	4866,4872,4878,4885,4893,4899,4911,4913,4919,4923,4925,4929,4941,4947,
  	4953,4961,4965,4969,4975,4977,4990,4994,4996,4998,5005,5016,5019,5021,
  	5025,5030,5032,5037,5043,5046,5048,5052,5055,5065,5075,5082,5084,5086,
  	5094,5098,5104,5107,5109,5119,5123,5129,5136,5138,5143,5145,5154,5162,
  	5165,5170,5175,5178,5184,5190,5193,5198,5209,5211,5223,5228,5236,5242,
  	5244,5253,5255,5261,5273,5278,5280,5284,5290,5293,5296,5306,5308,5314,
  	5327,5331,5336,5353,5359,5369,5377,5382,5388,5398,5402,5411,5417,5423,
  	5425,5429,5440,5447,5453,5458,5463,5468,5476,5480,5485,5494,5507,5509,
  	5523,5532,5534,5541,5548,5550,5554,5560,5568,5575,5579,5585,5592,5595,
  	5602,5605,5611,5627,5632,5645,5648,5659,5661,5667,5681,5698,5703,5706,
  	5710,5713,5727,5733,5738,5741,5743,5747,5752,5754,5766,5772,5787,5799,
  	5803,5805,5813,5820,5835,5840,5844,5848,5851,5855,5859,5862,5867,5870,
  	5876,5879,5885,5888,5915,5921,5924,5930,5943,5950,5954,5957,5960,5967,
  	5971,5974,5977,5982,5988,5991,5995,6016,6021,6029,6034,6037,6041,6045,
  	6049,6055,6059,6064,6069,6080,6082,6088,6111,6114,6140,6146,6172,6174,
  	6178,6190,6200,6210,6214,6222,6225,6229,6239,6243,6250,6255,6263,6268,
  	6274,6281,6288,6294,6301,6311,6313,6320,6325,6329,6332,6339,6344,6348,
  	6359,6367,6371,6374,6377,6381,6385,6390,6396,6400,6411,6414,6417,6420,
  	6428,6432,6437,6445,6453,6459,6463,6469,6478,6491,6501,6519,6522,6526,
  	6537,6539,6548,6560,6562,6569,6575,6581,6589,6600,6604,6633,6635,6641,
  	6660,6667,6681,6692,6697,6709,6719,6726,6729,6763,6771,6773,6785,6790,
  	6796,6804,6812,6817,6822,6828,6833,6838,6844,6852,6861,6866,6870,6874,
  	6879,6881,6899,6907,6911,6918,6930,6933,6937,6945,6957,6964,6968,6972,
  	6977,6987,6996,6998,7001,7010,7017,7030,7035,7042,7048,7074,7085,7117,
  	7136,7142,7146,7177,7183,7195,7208,7212,7216,7244,7294,7304,7308,7320,
  	7325,7341,7361,7365,7381,7384,7389,7392,7401,7405,7411,7417,7421,7432,
  	7438,7440,7447,7454,7458,7465,7470,7477,7487,7490,7494,7499,7501,7505,
  	7509,7522,7526,7529,7533,7537,7541,7548,7552,7556,7565,7569,7576,7582,
  	7590,7611,7616,7623,7646,7662,7672,7676,7683,7686,7697,7706,7709,7716,
  	7721,7747,7753,7759,7763,7773,7777,7790,7802,7818,7826,7836,7839,7844,
  	7848,7855,7860,7867,7875,7878,7883,7891,7894,7908,7911,7924,7928,7930,
  	7935,7940,7947,7953,7959,7964,7967,7973,7978,7981,7987,7991,7997,7999,
  	8002,8008,8014,8021,8023,8025,8029,8035,8040,8044,8049,8055,8062,8065,
  	8067,8070,8080,8086,8093,8098,8112,8120,8126,8131,8142,8146,8151,8155,
  	8158,8163,8167,8175,8183,8185,8194,8202,8209,8212,8220,8229,8231,8237,
  	8241,8251,8257,8260,8271,8280,8283,8288,8290,8293,8296,8300,8303,8307,
  	8312,8315,8319,8322,8326,8331,8335,8347,8351,8357,8361,8364,8369,8373,
  	8377,8382,8391,8394,8398,8402,8405,8409,8413,8418,8423,8429,8434,8439,
  	8441,8446,8453,8461,8467,8469,8473,8477,8481,8485,8500,8506,8513,8517,
  	8522,8527,8530,8534,8537,8542,8546,8552,8556,8560,8565,8570,8575,8580,
  	8586,8592,8597,8602,8607,8612,8617,8622,8627,8637,8643,8649,8655,8658,
  	8665,8670,8679,8685,8690,8694,8697,8701,8706,8710,8715,8719,8728,8731,
  	8734,8737,8741,8745,8749,8764,8767,8769,8774,8783,8786,8790,8802,8814,
  	8819,8824,8833,8838,8847,8852,8856,8860,8864,8869,8874,8880,8885,8888,
  	8895,8904,8911,8921,8930,8932,8943,8955,8968,8976,8983,8992,8998,9021,
  	9023,9029,9040,9048,9055,9060,9064,9070,9081,9087,9124,9149,9161,9163,
  	9168,9170,9177,9189,9191,9197,9207,9216,9227,9249,9253,9277,9288,9290,
  	9294,9301,9309,9316,9322,9339,9343,9350,9359,9364,9366,9372,9388,9395,
  	9400,9408,9411,9416,9426,9434,9439,9444,9447,9451,9456,9466,9472,9486,
  	9490,9502,9506,9510,9514,9528,9536,9545,9559,9566,9568,9609,9622,9627,
  	9629,9646,9651,9656,9658,9664,9673,9686
  };
  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));

  antlr4::atn::ATNDeserializer deserializer;
  staticData->atn = deserializer.deserialize(staticData->serializedATN);

  const size_t count = staticData->atn->getNumberOfDecisions();
  staticData->decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
  }
  mysqlparserParserStaticData = staticData.release();
}

}

MySQLParser::MySQLParser(TokenStream *input) : MySQLParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}

MySQLParser::MySQLParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : MySQLBaseRecognizer(input) {
  MySQLParser::initialize();
  _interpreter = new atn::ParserATNSimulator(this, *mysqlparserParserStaticData->atn, mysqlparserParserStaticData->decisionToDFA, mysqlparserParserStaticData->sharedContextCache, options);
}

MySQLParser::~MySQLParser() {
  delete _interpreter;
}

const atn::ATN& MySQLParser::getATN() const {
  return *mysqlparserParserStaticData->atn;
}

std::string MySQLParser::getGrammarFileName() const {
  return "MySQLParser.g4";
}

const std::vector<std::string>& MySQLParser::getRuleNames() const {
  return mysqlparserParserStaticData->ruleNames;
}

const dfa::Vocabulary& MySQLParser::getVocabulary() const {
  return mysqlparserParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView MySQLParser::getSerializedATN() const {
  return mysqlparserParserStaticData->serializedATN;
}


//----------------- QueryContext ------------------------------------------------------------------

MySQLParser::QueryContext::QueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::QueryContext::EOF() {
  return getToken(MySQLParser::EOF, 0);
}

MySQLParser::SimpleStatementContext* MySQLParser::QueryContext::simpleStatement() {
  return getRuleContext<MySQLParser::SimpleStatementContext>(0);
}

MySQLParser::BeginWorkContext* MySQLParser::QueryContext::beginWork() {
  return getRuleContext<MySQLParser::BeginWorkContext>(0);
}

tree::TerminalNode* MySQLParser::QueryContext::SEMICOLON_SYMBOL() {
  return getToken(MySQLParser::SEMICOLON_SYMBOL, 0);
}


size_t MySQLParser::QueryContext::getRuleIndex() const {
  return MySQLParser::RuleQuery;
}

void MySQLParser::QueryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQuery(this);
}

void MySQLParser::QueryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQuery(this);
}


std::any MySQLParser::QueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQuery(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryContext* MySQLParser::query() {
  QueryContext *_localctx = _tracker.createInstance<QueryContext>(_ctx, getState());
  enterRule(_localctx, 0, MySQLParser::RuleQuery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1535);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
    case 1: {
      setState(1530);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 0, _ctx)) {
      case 1: {
        setState(1528);
        simpleStatement();
        break;
      }

      case 2: {
        setState(1529);
        beginWork();
        break;
      }

      default:
        break;
      }
      setState(1533);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::SEMICOLON_SYMBOL) {
        setState(1532);
        match(MySQLParser::SEMICOLON_SYMBOL);
      }
      break;
    }

    default:
      break;
    }
    setState(1537);
    match(MySQLParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleStatementContext ------------------------------------------------------------------

MySQLParser::SimpleStatementContext::SimpleStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AlterStatementContext* MySQLParser::SimpleStatementContext::alterStatement() {
  return getRuleContext<MySQLParser::AlterStatementContext>(0);
}

MySQLParser::CreateStatementContext* MySQLParser::SimpleStatementContext::createStatement() {
  return getRuleContext<MySQLParser::CreateStatementContext>(0);
}

MySQLParser::DropStatementContext* MySQLParser::SimpleStatementContext::dropStatement() {
  return getRuleContext<MySQLParser::DropStatementContext>(0);
}

MySQLParser::RenameTableStatementContext* MySQLParser::SimpleStatementContext::renameTableStatement() {
  return getRuleContext<MySQLParser::RenameTableStatementContext>(0);
}

MySQLParser::TruncateTableStatementContext* MySQLParser::SimpleStatementContext::truncateTableStatement() {
  return getRuleContext<MySQLParser::TruncateTableStatementContext>(0);
}

MySQLParser::ImportStatementContext* MySQLParser::SimpleStatementContext::importStatement() {
  return getRuleContext<MySQLParser::ImportStatementContext>(0);
}

MySQLParser::CallStatementContext* MySQLParser::SimpleStatementContext::callStatement() {
  return getRuleContext<MySQLParser::CallStatementContext>(0);
}

MySQLParser::DeleteStatementContext* MySQLParser::SimpleStatementContext::deleteStatement() {
  return getRuleContext<MySQLParser::DeleteStatementContext>(0);
}

MySQLParser::DoStatementContext* MySQLParser::SimpleStatementContext::doStatement() {
  return getRuleContext<MySQLParser::DoStatementContext>(0);
}

MySQLParser::HandlerStatementContext* MySQLParser::SimpleStatementContext::handlerStatement() {
  return getRuleContext<MySQLParser::HandlerStatementContext>(0);
}

MySQLParser::InsertStatementContext* MySQLParser::SimpleStatementContext::insertStatement() {
  return getRuleContext<MySQLParser::InsertStatementContext>(0);
}

MySQLParser::LoadStatementContext* MySQLParser::SimpleStatementContext::loadStatement() {
  return getRuleContext<MySQLParser::LoadStatementContext>(0);
}

MySQLParser::ReplaceStatementContext* MySQLParser::SimpleStatementContext::replaceStatement() {
  return getRuleContext<MySQLParser::ReplaceStatementContext>(0);
}

MySQLParser::SelectStatementContext* MySQLParser::SimpleStatementContext::selectStatement() {
  return getRuleContext<MySQLParser::SelectStatementContext>(0);
}

MySQLParser::UpdateStatementContext* MySQLParser::SimpleStatementContext::updateStatement() {
  return getRuleContext<MySQLParser::UpdateStatementContext>(0);
}

MySQLParser::TransactionOrLockingStatementContext* MySQLParser::SimpleStatementContext::transactionOrLockingStatement() {
  return getRuleContext<MySQLParser::TransactionOrLockingStatementContext>(0);
}

MySQLParser::ReplicationStatementContext* MySQLParser::SimpleStatementContext::replicationStatement() {
  return getRuleContext<MySQLParser::ReplicationStatementContext>(0);
}

MySQLParser::PreparedStatementContext* MySQLParser::SimpleStatementContext::preparedStatement() {
  return getRuleContext<MySQLParser::PreparedStatementContext>(0);
}

MySQLParser::CloneStatementContext* MySQLParser::SimpleStatementContext::cloneStatement() {
  return getRuleContext<MySQLParser::CloneStatementContext>(0);
}

MySQLParser::AccountManagementStatementContext* MySQLParser::SimpleStatementContext::accountManagementStatement() {
  return getRuleContext<MySQLParser::AccountManagementStatementContext>(0);
}

MySQLParser::TableAdministrationStatementContext* MySQLParser::SimpleStatementContext::tableAdministrationStatement() {
  return getRuleContext<MySQLParser::TableAdministrationStatementContext>(0);
}

MySQLParser::UninstallStatementContext* MySQLParser::SimpleStatementContext::uninstallStatement() {
  return getRuleContext<MySQLParser::UninstallStatementContext>(0);
}

MySQLParser::InstallStatementContext* MySQLParser::SimpleStatementContext::installStatement() {
  return getRuleContext<MySQLParser::InstallStatementContext>(0);
}

MySQLParser::SetStatementContext* MySQLParser::SimpleStatementContext::setStatement() {
  return getRuleContext<MySQLParser::SetStatementContext>(0);
}

MySQLParser::ShowDatabasesStatementContext* MySQLParser::SimpleStatementContext::showDatabasesStatement() {
  return getRuleContext<MySQLParser::ShowDatabasesStatementContext>(0);
}

MySQLParser::ShowTablesStatementContext* MySQLParser::SimpleStatementContext::showTablesStatement() {
  return getRuleContext<MySQLParser::ShowTablesStatementContext>(0);
}

MySQLParser::ShowTriggersStatementContext* MySQLParser::SimpleStatementContext::showTriggersStatement() {
  return getRuleContext<MySQLParser::ShowTriggersStatementContext>(0);
}

MySQLParser::ShowEventsStatementContext* MySQLParser::SimpleStatementContext::showEventsStatement() {
  return getRuleContext<MySQLParser::ShowEventsStatementContext>(0);
}

MySQLParser::ShowTableStatusStatementContext* MySQLParser::SimpleStatementContext::showTableStatusStatement() {
  return getRuleContext<MySQLParser::ShowTableStatusStatementContext>(0);
}

MySQLParser::ShowOpenTablesStatementContext* MySQLParser::SimpleStatementContext::showOpenTablesStatement() {
  return getRuleContext<MySQLParser::ShowOpenTablesStatementContext>(0);
}

MySQLParser::ShowParseTreeStatementContext* MySQLParser::SimpleStatementContext::showParseTreeStatement() {
  return getRuleContext<MySQLParser::ShowParseTreeStatementContext>(0);
}

MySQLParser::ShowPluginsStatementContext* MySQLParser::SimpleStatementContext::showPluginsStatement() {
  return getRuleContext<MySQLParser::ShowPluginsStatementContext>(0);
}

MySQLParser::ShowEngineLogsStatementContext* MySQLParser::SimpleStatementContext::showEngineLogsStatement() {
  return getRuleContext<MySQLParser::ShowEngineLogsStatementContext>(0);
}

MySQLParser::ShowEngineMutexStatementContext* MySQLParser::SimpleStatementContext::showEngineMutexStatement() {
  return getRuleContext<MySQLParser::ShowEngineMutexStatementContext>(0);
}

MySQLParser::ShowEngineStatusStatementContext* MySQLParser::SimpleStatementContext::showEngineStatusStatement() {
  return getRuleContext<MySQLParser::ShowEngineStatusStatementContext>(0);
}

MySQLParser::ShowColumnsStatementContext* MySQLParser::SimpleStatementContext::showColumnsStatement() {
  return getRuleContext<MySQLParser::ShowColumnsStatementContext>(0);
}

MySQLParser::ShowBinaryLogsStatementContext* MySQLParser::SimpleStatementContext::showBinaryLogsStatement() {
  return getRuleContext<MySQLParser::ShowBinaryLogsStatementContext>(0);
}

MySQLParser::ShowBinaryLogStatusStatementContext* MySQLParser::SimpleStatementContext::showBinaryLogStatusStatement() {
  return getRuleContext<MySQLParser::ShowBinaryLogStatusStatementContext>(0);
}

MySQLParser::ShowReplicasStatementContext* MySQLParser::SimpleStatementContext::showReplicasStatement() {
  return getRuleContext<MySQLParser::ShowReplicasStatementContext>(0);
}

MySQLParser::ShowBinlogEventsStatementContext* MySQLParser::SimpleStatementContext::showBinlogEventsStatement() {
  return getRuleContext<MySQLParser::ShowBinlogEventsStatementContext>(0);
}

MySQLParser::ShowRelaylogEventsStatementContext* MySQLParser::SimpleStatementContext::showRelaylogEventsStatement() {
  return getRuleContext<MySQLParser::ShowRelaylogEventsStatementContext>(0);
}

MySQLParser::ShowKeysStatementContext* MySQLParser::SimpleStatementContext::showKeysStatement() {
  return getRuleContext<MySQLParser::ShowKeysStatementContext>(0);
}

MySQLParser::ShowEnginesStatementContext* MySQLParser::SimpleStatementContext::showEnginesStatement() {
  return getRuleContext<MySQLParser::ShowEnginesStatementContext>(0);
}

MySQLParser::ShowCountWarningsStatementContext* MySQLParser::SimpleStatementContext::showCountWarningsStatement() {
  return getRuleContext<MySQLParser::ShowCountWarningsStatementContext>(0);
}

MySQLParser::ShowCountErrorsStatementContext* MySQLParser::SimpleStatementContext::showCountErrorsStatement() {
  return getRuleContext<MySQLParser::ShowCountErrorsStatementContext>(0);
}

MySQLParser::ShowWarningsStatementContext* MySQLParser::SimpleStatementContext::showWarningsStatement() {
  return getRuleContext<MySQLParser::ShowWarningsStatementContext>(0);
}

MySQLParser::ShowErrorsStatementContext* MySQLParser::SimpleStatementContext::showErrorsStatement() {
  return getRuleContext<MySQLParser::ShowErrorsStatementContext>(0);
}

MySQLParser::ShowProfilesStatementContext* MySQLParser::SimpleStatementContext::showProfilesStatement() {
  return getRuleContext<MySQLParser::ShowProfilesStatementContext>(0);
}

MySQLParser::ShowProfileStatementContext* MySQLParser::SimpleStatementContext::showProfileStatement() {
  return getRuleContext<MySQLParser::ShowProfileStatementContext>(0);
}

MySQLParser::ShowStatusStatementContext* MySQLParser::SimpleStatementContext::showStatusStatement() {
  return getRuleContext<MySQLParser::ShowStatusStatementContext>(0);
}

MySQLParser::ShowProcessListStatementContext* MySQLParser::SimpleStatementContext::showProcessListStatement() {
  return getRuleContext<MySQLParser::ShowProcessListStatementContext>(0);
}

MySQLParser::ShowVariablesStatementContext* MySQLParser::SimpleStatementContext::showVariablesStatement() {
  return getRuleContext<MySQLParser::ShowVariablesStatementContext>(0);
}

MySQLParser::ShowCharacterSetStatementContext* MySQLParser::SimpleStatementContext::showCharacterSetStatement() {
  return getRuleContext<MySQLParser::ShowCharacterSetStatementContext>(0);
}

MySQLParser::ShowCollationStatementContext* MySQLParser::SimpleStatementContext::showCollationStatement() {
  return getRuleContext<MySQLParser::ShowCollationStatementContext>(0);
}

MySQLParser::ShowPrivilegesStatementContext* MySQLParser::SimpleStatementContext::showPrivilegesStatement() {
  return getRuleContext<MySQLParser::ShowPrivilegesStatementContext>(0);
}

MySQLParser::ShowGrantsStatementContext* MySQLParser::SimpleStatementContext::showGrantsStatement() {
  return getRuleContext<MySQLParser::ShowGrantsStatementContext>(0);
}

MySQLParser::ShowCreateDatabaseStatementContext* MySQLParser::SimpleStatementContext::showCreateDatabaseStatement() {
  return getRuleContext<MySQLParser::ShowCreateDatabaseStatementContext>(0);
}

MySQLParser::ShowCreateTableStatementContext* MySQLParser::SimpleStatementContext::showCreateTableStatement() {
  return getRuleContext<MySQLParser::ShowCreateTableStatementContext>(0);
}

MySQLParser::ShowCreateViewStatementContext* MySQLParser::SimpleStatementContext::showCreateViewStatement() {
  return getRuleContext<MySQLParser::ShowCreateViewStatementContext>(0);
}

MySQLParser::ShowMasterStatusStatementContext* MySQLParser::SimpleStatementContext::showMasterStatusStatement() {
  return getRuleContext<MySQLParser::ShowMasterStatusStatementContext>(0);
}

MySQLParser::ShowReplicaStatusStatementContext* MySQLParser::SimpleStatementContext::showReplicaStatusStatement() {
  return getRuleContext<MySQLParser::ShowReplicaStatusStatementContext>(0);
}

MySQLParser::ShowCreateProcedureStatementContext* MySQLParser::SimpleStatementContext::showCreateProcedureStatement() {
  return getRuleContext<MySQLParser::ShowCreateProcedureStatementContext>(0);
}

MySQLParser::ShowCreateFunctionStatementContext* MySQLParser::SimpleStatementContext::showCreateFunctionStatement() {
  return getRuleContext<MySQLParser::ShowCreateFunctionStatementContext>(0);
}

MySQLParser::ShowCreateLibraryStatementContext* MySQLParser::SimpleStatementContext::showCreateLibraryStatement() {
  return getRuleContext<MySQLParser::ShowCreateLibraryStatementContext>(0);
}

MySQLParser::ShowCreateTriggerStatementContext* MySQLParser::SimpleStatementContext::showCreateTriggerStatement() {
  return getRuleContext<MySQLParser::ShowCreateTriggerStatementContext>(0);
}

MySQLParser::ShowProcedureStatusStatementContext* MySQLParser::SimpleStatementContext::showProcedureStatusStatement() {
  return getRuleContext<MySQLParser::ShowProcedureStatusStatementContext>(0);
}

MySQLParser::ShowFunctionStatusStatementContext* MySQLParser::SimpleStatementContext::showFunctionStatusStatement() {
  return getRuleContext<MySQLParser::ShowFunctionStatusStatementContext>(0);
}

MySQLParser::ShowProcedureCodeStatementContext* MySQLParser::SimpleStatementContext::showProcedureCodeStatement() {
  return getRuleContext<MySQLParser::ShowProcedureCodeStatementContext>(0);
}

MySQLParser::ShowFunctionCodeStatementContext* MySQLParser::SimpleStatementContext::showFunctionCodeStatement() {
  return getRuleContext<MySQLParser::ShowFunctionCodeStatementContext>(0);
}

MySQLParser::ShowCreateEventStatementContext* MySQLParser::SimpleStatementContext::showCreateEventStatement() {
  return getRuleContext<MySQLParser::ShowCreateEventStatementContext>(0);
}

MySQLParser::ShowCreateUserStatementContext* MySQLParser::SimpleStatementContext::showCreateUserStatement() {
  return getRuleContext<MySQLParser::ShowCreateUserStatementContext>(0);
}

MySQLParser::ResourceGroupManagementContext* MySQLParser::SimpleStatementContext::resourceGroupManagement() {
  return getRuleContext<MySQLParser::ResourceGroupManagementContext>(0);
}

MySQLParser::OtherAdministrativeStatementContext* MySQLParser::SimpleStatementContext::otherAdministrativeStatement() {
  return getRuleContext<MySQLParser::OtherAdministrativeStatementContext>(0);
}

MySQLParser::UtilityStatementContext* MySQLParser::SimpleStatementContext::utilityStatement() {
  return getRuleContext<MySQLParser::UtilityStatementContext>(0);
}

MySQLParser::GetDiagnosticsStatementContext* MySQLParser::SimpleStatementContext::getDiagnosticsStatement() {
  return getRuleContext<MySQLParser::GetDiagnosticsStatementContext>(0);
}

MySQLParser::SignalStatementContext* MySQLParser::SimpleStatementContext::signalStatement() {
  return getRuleContext<MySQLParser::SignalStatementContext>(0);
}

MySQLParser::ResignalStatementContext* MySQLParser::SimpleStatementContext::resignalStatement() {
  return getRuleContext<MySQLParser::ResignalStatementContext>(0);
}


size_t MySQLParser::SimpleStatementContext::getRuleIndex() const {
  return MySQLParser::RuleSimpleStatement;
}

void MySQLParser::SimpleStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleStatement(this);
}

void MySQLParser::SimpleStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleStatement(this);
}


std::any MySQLParser::SimpleStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SimpleStatementContext* MySQLParser::simpleStatement() {
  SimpleStatementContext *_localctx = _tracker.createInstance<SimpleStatementContext>(_ctx, getState());
  enterRule(_localctx, 2, MySQLParser::RuleSimpleStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1623);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1539);
      alterStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1540);
      createStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1541);
      dropStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1542);
      renameTableStatement();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1543);
      truncateTableStatement();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1544);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(1545);
      importStatement();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1546);
      callStatement();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1547);
      deleteStatement();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1548);
      doStatement();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1549);
      handlerStatement();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1550);
      insertStatement();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1551);
      loadStatement();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1552);
      replaceStatement();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1553);
      selectStatement();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(1554);
      updateStatement();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(1555);
      transactionOrLockingStatement();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(1556);
      replicationStatement();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(1557);
      preparedStatement();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(1558);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(1559);
      cloneStatement();
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(1560);
      accountManagementStatement();
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(1561);
      tableAdministrationStatement();
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(1562);
      uninstallStatement();
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(1563);
      installStatement();
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(1564);
      setStatement();
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(1565);
      showDatabasesStatement();
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(1566);
      showTablesStatement();
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(1567);
      showTriggersStatement();
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(1568);
      showEventsStatement();
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(1569);
      showTableStatusStatement();
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(1570);
      showOpenTablesStatement();
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(1571);
      showParseTreeStatement();
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(1572);
      showPluginsStatement();
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(1573);
      showEngineLogsStatement();
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(1574);
      showEngineMutexStatement();
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(1575);
      showEngineStatusStatement();
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(1576);
      showColumnsStatement();
      break;
    }

    case 37: {
      enterOuterAlt(_localctx, 37);
      setState(1577);
      showBinaryLogsStatement();
      break;
    }

    case 38: {
      enterOuterAlt(_localctx, 38);
      setState(1578);

      if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
      setState(1579);
      showBinaryLogStatusStatement();
      break;
    }

    case 39: {
      enterOuterAlt(_localctx, 39);
      setState(1580);
      showReplicasStatement();
      break;
    }

    case 40: {
      enterOuterAlt(_localctx, 40);
      setState(1581);
      showBinlogEventsStatement();
      break;
    }

    case 41: {
      enterOuterAlt(_localctx, 41);
      setState(1582);
      showRelaylogEventsStatement();
      break;
    }

    case 42: {
      enterOuterAlt(_localctx, 42);
      setState(1583);
      showKeysStatement();
      break;
    }

    case 43: {
      enterOuterAlt(_localctx, 43);
      setState(1584);
      showEnginesStatement();
      break;
    }

    case 44: {
      enterOuterAlt(_localctx, 44);
      setState(1585);
      showCountWarningsStatement();
      break;
    }

    case 45: {
      enterOuterAlt(_localctx, 45);
      setState(1586);
      showCountErrorsStatement();
      break;
    }

    case 46: {
      enterOuterAlt(_localctx, 46);
      setState(1587);
      showWarningsStatement();
      break;
    }

    case 47: {
      enterOuterAlt(_localctx, 47);
      setState(1588);
      showErrorsStatement();
      break;
    }

    case 48: {
      enterOuterAlt(_localctx, 48);
      setState(1589);
      showProfilesStatement();
      break;
    }

    case 49: {
      enterOuterAlt(_localctx, 49);
      setState(1590);
      showProfileStatement();
      break;
    }

    case 50: {
      enterOuterAlt(_localctx, 50);
      setState(1591);
      showStatusStatement();
      break;
    }

    case 51: {
      enterOuterAlt(_localctx, 51);
      setState(1592);
      showProcessListStatement();
      break;
    }

    case 52: {
      enterOuterAlt(_localctx, 52);
      setState(1593);
      showVariablesStatement();
      break;
    }

    case 53: {
      enterOuterAlt(_localctx, 53);
      setState(1594);
      showCharacterSetStatement();
      break;
    }

    case 54: {
      enterOuterAlt(_localctx, 54);
      setState(1595);
      showCollationStatement();
      break;
    }

    case 55: {
      enterOuterAlt(_localctx, 55);
      setState(1596);
      showPrivilegesStatement();
      break;
    }

    case 56: {
      enterOuterAlt(_localctx, 56);
      setState(1597);
      showGrantsStatement();
      break;
    }

    case 57: {
      enterOuterAlt(_localctx, 57);
      setState(1598);
      showCreateDatabaseStatement();
      break;
    }

    case 58: {
      enterOuterAlt(_localctx, 58);
      setState(1599);
      showCreateTableStatement();
      break;
    }

    case 59: {
      enterOuterAlt(_localctx, 59);
      setState(1600);
      showCreateViewStatement();
      break;
    }

    case 60: {
      enterOuterAlt(_localctx, 60);
      setState(1601);

      if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
      setState(1602);
      showMasterStatusStatement();
      break;
    }

    case 61: {
      enterOuterAlt(_localctx, 61);
      setState(1603);
      showReplicaStatusStatement();
      break;
    }

    case 62: {
      enterOuterAlt(_localctx, 62);
      setState(1604);
      showCreateProcedureStatement();
      break;
    }

    case 63: {
      enterOuterAlt(_localctx, 63);
      setState(1605);
      showCreateFunctionStatement();
      break;
    }

    case 64: {
      enterOuterAlt(_localctx, 64);
      setState(1606);

      if (!(serverVersion >= 90200)) throw FailedPredicateException(this, "serverVersion >= 90200");
      setState(1607);
      showCreateLibraryStatement();
      break;
    }

    case 65: {
      enterOuterAlt(_localctx, 65);
      setState(1608);
      showCreateTriggerStatement();
      break;
    }

    case 66: {
      enterOuterAlt(_localctx, 66);
      setState(1609);
      showProcedureStatusStatement();
      break;
    }

    case 67: {
      enterOuterAlt(_localctx, 67);
      setState(1610);
      showFunctionStatusStatement();
      break;
    }

    case 68: {
      enterOuterAlt(_localctx, 68);
      setState(1611);
      showProcedureCodeStatement();
      break;
    }

    case 69: {
      enterOuterAlt(_localctx, 69);
      setState(1612);
      showFunctionCodeStatement();
      break;
    }

    case 70: {
      enterOuterAlt(_localctx, 70);
      setState(1613);
      showCreateEventStatement();
      break;
    }

    case 71: {
      enterOuterAlt(_localctx, 71);
      setState(1614);

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(1615);
      showCreateUserStatement();
      break;
    }

    case 72: {
      enterOuterAlt(_localctx, 72);
      setState(1616);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(1617);
      resourceGroupManagement();
      break;
    }

    case 73: {
      enterOuterAlt(_localctx, 73);
      setState(1618);
      otherAdministrativeStatement();
      break;
    }

    case 74: {
      enterOuterAlt(_localctx, 74);
      setState(1619);
      utilityStatement();
      break;
    }

    case 75: {
      enterOuterAlt(_localctx, 75);
      setState(1620);
      getDiagnosticsStatement();
      break;
    }

    case 76: {
      enterOuterAlt(_localctx, 76);
      setState(1621);
      signalStatement();
      break;
    }

    case 77: {
      enterOuterAlt(_localctx, 77);
      setState(1622);
      resignalStatement();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterStatementContext ------------------------------------------------------------------

MySQLParser::AlterStatementContext::AlterStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterStatementContext::ALTER_SYMBOL() {
  return getToken(MySQLParser::ALTER_SYMBOL, 0);
}

MySQLParser::AlterTableContext* MySQLParser::AlterStatementContext::alterTable() {
  return getRuleContext<MySQLParser::AlterTableContext>(0);
}

MySQLParser::AlterDatabaseContext* MySQLParser::AlterStatementContext::alterDatabase() {
  return getRuleContext<MySQLParser::AlterDatabaseContext>(0);
}

tree::TerminalNode* MySQLParser::AlterStatementContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

MySQLParser::ProcedureRefContext* MySQLParser::AlterStatementContext::procedureRef() {
  return getRuleContext<MySQLParser::ProcedureRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterStatementContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

MySQLParser::FunctionRefContext* MySQLParser::AlterStatementContext::functionRef() {
  return getRuleContext<MySQLParser::FunctionRefContext>(0);
}

MySQLParser::AlterViewContext* MySQLParser::AlterStatementContext::alterView() {
  return getRuleContext<MySQLParser::AlterViewContext>(0);
}

MySQLParser::AlterEventContext* MySQLParser::AlterStatementContext::alterEvent() {
  return getRuleContext<MySQLParser::AlterEventContext>(0);
}

MySQLParser::AlterTablespaceContext* MySQLParser::AlterStatementContext::alterTablespace() {
  return getRuleContext<MySQLParser::AlterTablespaceContext>(0);
}

MySQLParser::AlterUndoTablespaceContext* MySQLParser::AlterStatementContext::alterUndoTablespace() {
  return getRuleContext<MySQLParser::AlterUndoTablespaceContext>(0);
}

MySQLParser::AlterLogfileGroupContext* MySQLParser::AlterStatementContext::alterLogfileGroup() {
  return getRuleContext<MySQLParser::AlterLogfileGroupContext>(0);
}

MySQLParser::AlterServerContext* MySQLParser::AlterStatementContext::alterServer() {
  return getRuleContext<MySQLParser::AlterServerContext>(0);
}

MySQLParser::AlterInstanceStatementContext* MySQLParser::AlterStatementContext::alterInstanceStatement() {
  return getRuleContext<MySQLParser::AlterInstanceStatementContext>(0);
}

MySQLParser::RoutineAlterOptionsContext* MySQLParser::AlterStatementContext::routineAlterOptions() {
  return getRuleContext<MySQLParser::RoutineAlterOptionsContext>(0);
}


size_t MySQLParser::AlterStatementContext::getRuleIndex() const {
  return MySQLParser::RuleAlterStatement;
}

void MySQLParser::AlterStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterStatement(this);
}

void MySQLParser::AlterStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterStatement(this);
}


std::any MySQLParser::AlterStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterStatementContext* MySQLParser::alterStatement() {
  AlterStatementContext *_localctx = _tracker.createInstance<AlterStatementContext>(_ctx, getState());
  enterRule(_localctx, 4, MySQLParser::RuleAlterStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1625);
    match(MySQLParser::ALTER_SYMBOL);
    setState(1646);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
    case 1: {
      setState(1626);
      alterTable();
      break;
    }

    case 2: {
      setState(1627);
      alterDatabase();
      break;
    }

    case 3: {
      setState(1628);
      match(MySQLParser::PROCEDURE_SYMBOL);
      setState(1629);
      procedureRef();
      setState(1631);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMENT_SYMBOL

      || _la == MySQLParser::CONTAINS_SYMBOL || _la == MySQLParser::LANGUAGE_SYMBOL || _la == MySQLParser::MODIFIES_SYMBOL

      || _la == MySQLParser::NO_SYMBOL || _la == MySQLParser::READS_SYMBOL || _la == MySQLParser::SQL_SYMBOL) {
        setState(1630);
        routineAlterOptions();
      }
      break;
    }

    case 4: {
      setState(1633);
      match(MySQLParser::FUNCTION_SYMBOL);
      setState(1634);
      functionRef();
      setState(1636);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMENT_SYMBOL

      || _la == MySQLParser::CONTAINS_SYMBOL || _la == MySQLParser::LANGUAGE_SYMBOL || _la == MySQLParser::MODIFIES_SYMBOL

      || _la == MySQLParser::NO_SYMBOL || _la == MySQLParser::READS_SYMBOL || _la == MySQLParser::SQL_SYMBOL) {
        setState(1635);
        routineAlterOptions();
      }
      break;
    }

    case 5: {
      setState(1638);
      alterView();
      break;
    }

    case 6: {
      setState(1639);
      alterEvent();
      break;
    }

    case 7: {
      setState(1640);
      alterTablespace();
      break;
    }

    case 8: {
      setState(1641);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(1642);
      alterUndoTablespace();
      break;
    }

    case 9: {
      setState(1643);
      alterLogfileGroup();
      break;
    }

    case 10: {
      setState(1644);
      alterServer();
      break;
    }

    case 11: {
      setState(1645);
      alterInstanceStatement();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterDatabaseContext ------------------------------------------------------------------

MySQLParser::AlterDatabaseContext::AlterDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterDatabaseContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

MySQLParser::SchemaRefContext* MySQLParser::AlterDatabaseContext::schemaRef() {
  return getRuleContext<MySQLParser::SchemaRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseContext::UPGRADE_SYMBOL() {
  return getToken(MySQLParser::UPGRADE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseContext::NAME_SYMBOL() {
  return getToken(MySQLParser::NAME_SYMBOL, 0);
}

std::vector<MySQLParser::AlterDatabaseOptionContext *> MySQLParser::AlterDatabaseContext::alterDatabaseOption() {
  return getRuleContexts<MySQLParser::AlterDatabaseOptionContext>();
}

MySQLParser::AlterDatabaseOptionContext* MySQLParser::AlterDatabaseContext::alterDatabaseOption(size_t i) {
  return getRuleContext<MySQLParser::AlterDatabaseOptionContext>(i);
}


size_t MySQLParser::AlterDatabaseContext::getRuleIndex() const {
  return MySQLParser::RuleAlterDatabase;
}

void MySQLParser::AlterDatabaseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterDatabase(this);
}

void MySQLParser::AlterDatabaseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterDatabase(this);
}


std::any MySQLParser::AlterDatabaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterDatabase(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterDatabaseContext* MySQLParser::alterDatabase() {
  AlterDatabaseContext *_localctx = _tracker.createInstance<AlterDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 6, MySQLParser::RuleAlterDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1648);
    match(MySQLParser::DATABASE_SYMBOL);
    setState(1649);
    schemaRef();
    setState(1660);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {
    case 1: {
      setState(1651); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1650);
                alterDatabaseOption();
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(1653); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx);
      } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
      break;
    }

    case 2: {
      setState(1655);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(1656);
      match(MySQLParser::UPGRADE_SYMBOL);
      setState(1657);
      match(MySQLParser::DATA_SYMBOL);
      setState(1658);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(1659);
      match(MySQLParser::NAME_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterDatabaseOptionContext ------------------------------------------------------------------

MySQLParser::AlterDatabaseOptionContext::AlterDatabaseOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CreateDatabaseOptionContext* MySQLParser::AlterDatabaseOptionContext::createDatabaseOption() {
  return getRuleContext<MySQLParser::CreateDatabaseOptionContext>(0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseOptionContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseOptionContext::ONLY_SYMBOL() {
  return getToken(MySQLParser::ONLY_SYMBOL, 0);
}

MySQLParser::TernaryOptionContext* MySQLParser::AlterDatabaseOptionContext::ternaryOption() {
  return getRuleContext<MySQLParser::TernaryOptionContext>(0);
}

tree::TerminalNode* MySQLParser::AlterDatabaseOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::AlterDatabaseOptionContext::getRuleIndex() const {
  return MySQLParser::RuleAlterDatabaseOption;
}

void MySQLParser::AlterDatabaseOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterDatabaseOption(this);
}

void MySQLParser::AlterDatabaseOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterDatabaseOption(this);
}


std::any MySQLParser::AlterDatabaseOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterDatabaseOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterDatabaseOptionContext* MySQLParser::alterDatabaseOption() {
  AlterDatabaseOptionContext *_localctx = _tracker.createInstance<AlterDatabaseOptionContext>(_ctx, getState());
  enterRule(_localctx, 8, MySQLParser::RuleAlterDatabaseOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1669);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1662);
      createDatabaseOption();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1663);
      match(MySQLParser::READ_SYMBOL);
      setState(1664);
      match(MySQLParser::ONLY_SYMBOL);
      setState(1666);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(1665);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(1668);
      ternaryOption();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterEventContext ------------------------------------------------------------------

MySQLParser::AlterEventContext::AlterEventContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterEventContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

MySQLParser::EventRefContext* MySQLParser::AlterEventContext::eventRef() {
  return getRuleContext<MySQLParser::EventRefContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::AlterEventContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterEventContext::ON_SYMBOL() {
  return getTokens(MySQLParser::ON_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterEventContext::ON_SYMBOL(size_t i) {
  return getToken(MySQLParser::ON_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::AlterEventContext::SCHEDULE_SYMBOL() {
  return getToken(MySQLParser::SCHEDULE_SYMBOL, 0);
}

MySQLParser::ScheduleContext* MySQLParser::AlterEventContext::schedule() {
  return getRuleContext<MySQLParser::ScheduleContext>(0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::COMPLETION_SYMBOL() {
  return getToken(MySQLParser::COMPLETION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::PRESERVE_SYMBOL() {
  return getToken(MySQLParser::PRESERVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::RENAME_SYMBOL() {
  return getToken(MySQLParser::RENAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::AlterEventContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::AlterEventContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::DO_SYMBOL() {
  return getToken(MySQLParser::DO_SYMBOL, 0);
}

MySQLParser::CompoundStatementContext* MySQLParser::AlterEventContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

tree::TerminalNode* MySQLParser::AlterEventContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::AlterEventContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}


size_t MySQLParser::AlterEventContext::getRuleIndex() const {
  return MySQLParser::RuleAlterEvent;
}

void MySQLParser::AlterEventContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterEvent(this);
}

void MySQLParser::AlterEventContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterEvent(this);
}


std::any MySQLParser::AlterEventContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterEvent(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterEventContext* MySQLParser::alterEvent() {
  AlterEventContext *_localctx = _tracker.createInstance<AlterEventContext>(_ctx, getState());
  enterRule(_localctx, 10, MySQLParser::RuleAlterEvent);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1672);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(1671);
      definerClause();
    }
    setState(1674);
    match(MySQLParser::EVENT_SYMBOL);
    setState(1675);
    eventRef();
    setState(1679);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {
    case 1: {
      setState(1676);
      match(MySQLParser::ON_SYMBOL);
      setState(1677);
      match(MySQLParser::SCHEDULE_SYMBOL);
      setState(1678);
      schedule();
      break;
    }

    default:
      break;
    }
    setState(1687);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ON_SYMBOL) {
      setState(1681);
      match(MySQLParser::ON_SYMBOL);
      setState(1682);
      match(MySQLParser::COMPLETION_SYMBOL);
      setState(1684);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(1683);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(1686);
      match(MySQLParser::PRESERVE_SYMBOL);
    }
    setState(1692);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::RENAME_SYMBOL) {
      setState(1689);
      match(MySQLParser::RENAME_SYMBOL);
      setState(1690);
      match(MySQLParser::TO_SYMBOL);
      setState(1691);
      identifier();
    }
    setState(1700);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ENABLE_SYMBOL: {
        setState(1694);
        match(MySQLParser::ENABLE_SYMBOL);
        break;
      }

      case MySQLParser::DISABLE_SYMBOL: {
        setState(1695);
        match(MySQLParser::DISABLE_SYMBOL);
        setState(1698);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ON_SYMBOL) {
          setState(1696);
          match(MySQLParser::ON_SYMBOL);
          setState(1697);
          replica();
        }
        break;
      }

      case MySQLParser::EOF:
      case MySQLParser::SEMICOLON_SYMBOL:
      case MySQLParser::COMMENT_SYMBOL:
      case MySQLParser::DO_SYMBOL: {
        break;
      }

    default:
      break;
    }
    setState(1704);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMENT_SYMBOL) {
      setState(1702);
      match(MySQLParser::COMMENT_SYMBOL);
      setState(1703);
      textLiteral();
    }
    setState(1708);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DO_SYMBOL) {
      setState(1706);
      match(MySQLParser::DO_SYMBOL);
      setState(1707);
      compoundStatement();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterLogfileGroupContext ------------------------------------------------------------------

MySQLParser::AlterLogfileGroupContext::AlterLogfileGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterLogfileGroupContext::LOGFILE_SYMBOL() {
  return getToken(MySQLParser::LOGFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterLogfileGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::LogfileGroupRefContext* MySQLParser::AlterLogfileGroupContext::logfileGroupRef() {
  return getRuleContext<MySQLParser::LogfileGroupRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterLogfileGroupContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterLogfileGroupContext::UNDOFILE_SYMBOL() {
  return getToken(MySQLParser::UNDOFILE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::AlterLogfileGroupContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::AlterLogfileGroupOptionsContext* MySQLParser::AlterLogfileGroupContext::alterLogfileGroupOptions() {
  return getRuleContext<MySQLParser::AlterLogfileGroupOptionsContext>(0);
}


size_t MySQLParser::AlterLogfileGroupContext::getRuleIndex() const {
  return MySQLParser::RuleAlterLogfileGroup;
}

void MySQLParser::AlterLogfileGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterLogfileGroup(this);
}

void MySQLParser::AlterLogfileGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterLogfileGroup(this);
}


std::any MySQLParser::AlterLogfileGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterLogfileGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterLogfileGroupContext* MySQLParser::alterLogfileGroup() {
  AlterLogfileGroupContext *_localctx = _tracker.createInstance<AlterLogfileGroupContext>(_ctx, getState());
  enterRule(_localctx, 12, MySQLParser::RuleAlterLogfileGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1710);
    match(MySQLParser::LOGFILE_SYMBOL);
    setState(1711);
    match(MySQLParser::GROUP_SYMBOL);
    setState(1712);
    logfileGroupRef();
    setState(1713);
    match(MySQLParser::ADD_SYMBOL);
    setState(1714);
    match(MySQLParser::UNDOFILE_SYMBOL);
    setState(1715);
    textLiteral();
    setState(1717);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
      setState(1716);
      alterLogfileGroupOptions();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterLogfileGroupOptionsContext ------------------------------------------------------------------

MySQLParser::AlterLogfileGroupOptionsContext::AlterLogfileGroupOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::AlterLogfileGroupOptionContext *> MySQLParser::AlterLogfileGroupOptionsContext::alterLogfileGroupOption() {
  return getRuleContexts<MySQLParser::AlterLogfileGroupOptionContext>();
}

MySQLParser::AlterLogfileGroupOptionContext* MySQLParser::AlterLogfileGroupOptionsContext::alterLogfileGroupOption(size_t i) {
  return getRuleContext<MySQLParser::AlterLogfileGroupOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterLogfileGroupOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterLogfileGroupOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::AlterLogfileGroupOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleAlterLogfileGroupOptions;
}

void MySQLParser::AlterLogfileGroupOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterLogfileGroupOptions(this);
}

void MySQLParser::AlterLogfileGroupOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterLogfileGroupOptions(this);
}


std::any MySQLParser::AlterLogfileGroupOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterLogfileGroupOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterLogfileGroupOptionsContext* MySQLParser::alterLogfileGroupOptions() {
  AlterLogfileGroupOptionsContext *_localctx = _tracker.createInstance<AlterLogfileGroupOptionsContext>(_ctx, getState());
  enterRule(_localctx, 14, MySQLParser::RuleAlterLogfileGroupOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1719);
    alterLogfileGroupOption();
    setState(1726);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
      setState(1721);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(1720);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(1723);
      alterLogfileGroupOption();
      setState(1728);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterLogfileGroupOptionContext ------------------------------------------------------------------

MySQLParser::AlterLogfileGroupOptionContext::AlterLogfileGroupOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TsOptionInitialSizeContext* MySQLParser::AlterLogfileGroupOptionContext::tsOptionInitialSize() {
  return getRuleContext<MySQLParser::TsOptionInitialSizeContext>(0);
}

MySQLParser::TsOptionEngineContext* MySQLParser::AlterLogfileGroupOptionContext::tsOptionEngine() {
  return getRuleContext<MySQLParser::TsOptionEngineContext>(0);
}

MySQLParser::TsOptionWaitContext* MySQLParser::AlterLogfileGroupOptionContext::tsOptionWait() {
  return getRuleContext<MySQLParser::TsOptionWaitContext>(0);
}


size_t MySQLParser::AlterLogfileGroupOptionContext::getRuleIndex() const {
  return MySQLParser::RuleAlterLogfileGroupOption;
}

void MySQLParser::AlterLogfileGroupOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterLogfileGroupOption(this);
}

void MySQLParser::AlterLogfileGroupOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterLogfileGroupOption(this);
}


std::any MySQLParser::AlterLogfileGroupOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterLogfileGroupOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterLogfileGroupOptionContext* MySQLParser::alterLogfileGroupOption() {
  AlterLogfileGroupOptionContext *_localctx = _tracker.createInstance<AlterLogfileGroupOptionContext>(_ctx, getState());
  enterRule(_localctx, 16, MySQLParser::RuleAlterLogfileGroupOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1732);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INITIAL_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(1729);
        tsOptionInitialSize();
        break;
      }

      case MySQLParser::ENGINE_SYMBOL:
      case MySQLParser::STORAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(1730);
        tsOptionEngine();
        break;
      }

      case MySQLParser::NO_WAIT_SYMBOL:
      case MySQLParser::WAIT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(1731);
        tsOptionWait();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterServerContext ------------------------------------------------------------------

MySQLParser::AlterServerContext::AlterServerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterServerContext::SERVER_SYMBOL() {
  return getToken(MySQLParser::SERVER_SYMBOL, 0);
}

MySQLParser::ServerRefContext* MySQLParser::AlterServerContext::serverRef() {
  return getRuleContext<MySQLParser::ServerRefContext>(0);
}

MySQLParser::ServerOptionsContext* MySQLParser::AlterServerContext::serverOptions() {
  return getRuleContext<MySQLParser::ServerOptionsContext>(0);
}


size_t MySQLParser::AlterServerContext::getRuleIndex() const {
  return MySQLParser::RuleAlterServer;
}

void MySQLParser::AlterServerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterServer(this);
}

void MySQLParser::AlterServerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterServer(this);
}


std::any MySQLParser::AlterServerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterServer(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterServerContext* MySQLParser::alterServer() {
  AlterServerContext *_localctx = _tracker.createInstance<AlterServerContext>(_ctx, getState());
  enterRule(_localctx, 18, MySQLParser::RuleAlterServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1734);
    match(MySQLParser::SERVER_SYMBOL);
    setState(1735);
    serverRef();
    setState(1736);
    serverOptions();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterTableContext ------------------------------------------------------------------

MySQLParser::AlterTableContext::AlterTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterTableContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::AlterTableContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::OnlineOptionContext* MySQLParser::AlterTableContext::onlineOption() {
  return getRuleContext<MySQLParser::OnlineOptionContext>(0);
}

MySQLParser::AlterTableActionsContext* MySQLParser::AlterTableContext::alterTableActions() {
  return getRuleContext<MySQLParser::AlterTableActionsContext>(0);
}


size_t MySQLParser::AlterTableContext::getRuleIndex() const {
  return MySQLParser::RuleAlterTable;
}

void MySQLParser::AlterTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterTable(this);
}

void MySQLParser::AlterTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterTable(this);
}


std::any MySQLParser::AlterTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterTableContext* MySQLParser::alterTable() {
  AlterTableContext *_localctx = _tracker.createInstance<AlterTableContext>(_ctx, getState());
  enterRule(_localctx, 20, MySQLParser::RuleAlterTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1739);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OFFLINE_SYMBOL

    || _la == MySQLParser::ONLINE_SYMBOL) {
      setState(1738);
      onlineOption();
    }
    setState(1741);
    match(MySQLParser::TABLE_SYMBOL);
    setState(1742);
    tableRef();
    setState(1744);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx)) {
    case 1: {
      setState(1743);
      alterTableActions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterTableActionsContext ------------------------------------------------------------------

MySQLParser::AlterTableActionsContext::AlterTableActionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AlterCommandListContext* MySQLParser::AlterTableActionsContext::alterCommandList() {
  return getRuleContext<MySQLParser::AlterCommandListContext>(0);
}

MySQLParser::PartitionClauseContext* MySQLParser::AlterTableActionsContext::partitionClause() {
  return getRuleContext<MySQLParser::PartitionClauseContext>(0);
}

MySQLParser::RemovePartitioningContext* MySQLParser::AlterTableActionsContext::removePartitioning() {
  return getRuleContext<MySQLParser::RemovePartitioningContext>(0);
}

MySQLParser::StandaloneAlterCommandsContext* MySQLParser::AlterTableActionsContext::standaloneAlterCommands() {
  return getRuleContext<MySQLParser::StandaloneAlterCommandsContext>(0);
}

MySQLParser::AlterCommandsModifierListContext* MySQLParser::AlterTableActionsContext::alterCommandsModifierList() {
  return getRuleContext<MySQLParser::AlterCommandsModifierListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterTableActionsContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}


size_t MySQLParser::AlterTableActionsContext::getRuleIndex() const {
  return MySQLParser::RuleAlterTableActions;
}

void MySQLParser::AlterTableActionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterTableActions(this);
}

void MySQLParser::AlterTableActionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterTableActions(this);
}


std::any MySQLParser::AlterTableActionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterTableActions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterTableActionsContext* MySQLParser::alterTableActions() {
  AlterTableActionsContext *_localctx = _tracker.createInstance<AlterTableActionsContext>(_ctx, getState());
  enterRule(_localctx, 22, MySQLParser::RuleAlterTableActions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1759);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1746);
      alterCommandList();
      setState(1749);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::PARTITION_SYMBOL: {
          setState(1747);
          partitionClause();
          break;
        }

        case MySQLParser::REMOVE_SYMBOL: {
          setState(1748);
          removePartitioning();
          break;
        }

        case MySQLParser::EOF:
        case MySQLParser::SEMICOLON_SYMBOL: {
          break;
        }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1751);
      partitionClause();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1752);
      removePartitioning();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1756);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
      case 1: {
        setState(1753);
        alterCommandsModifierList();
        setState(1754);
        match(MySQLParser::COMMA_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(1758);
      standaloneAlterCommands();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterCommandListContext ------------------------------------------------------------------

MySQLParser::AlterCommandListContext::AlterCommandListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AlterCommandsModifierListContext* MySQLParser::AlterCommandListContext::alterCommandsModifierList() {
  return getRuleContext<MySQLParser::AlterCommandsModifierListContext>(0);
}

MySQLParser::AlterListContext* MySQLParser::AlterCommandListContext::alterList() {
  return getRuleContext<MySQLParser::AlterListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterCommandListContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}


size_t MySQLParser::AlterCommandListContext::getRuleIndex() const {
  return MySQLParser::RuleAlterCommandList;
}

void MySQLParser::AlterCommandListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterCommandList(this);
}

void MySQLParser::AlterCommandListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterCommandList(this);
}


std::any MySQLParser::AlterCommandListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterCommandList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterCommandListContext* MySQLParser::alterCommandList() {
  AlterCommandListContext *_localctx = _tracker.createInstance<AlterCommandListContext>(_ctx, getState());
  enterRule(_localctx, 24, MySQLParser::RuleAlterCommandList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1768);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1761);
      alterCommandsModifierList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1765);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
      case 1: {
        setState(1762);
        alterCommandsModifierList();
        setState(1763);
        match(MySQLParser::COMMA_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(1767);
      alterList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterCommandsModifierListContext ------------------------------------------------------------------

MySQLParser::AlterCommandsModifierListContext::AlterCommandsModifierListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::AlterCommandsModifierContext *> MySQLParser::AlterCommandsModifierListContext::alterCommandsModifier() {
  return getRuleContexts<MySQLParser::AlterCommandsModifierContext>();
}

MySQLParser::AlterCommandsModifierContext* MySQLParser::AlterCommandsModifierListContext::alterCommandsModifier(size_t i) {
  return getRuleContext<MySQLParser::AlterCommandsModifierContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterCommandsModifierListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterCommandsModifierListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::AlterCommandsModifierListContext::getRuleIndex() const {
  return MySQLParser::RuleAlterCommandsModifierList;
}

void MySQLParser::AlterCommandsModifierListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterCommandsModifierList(this);
}

void MySQLParser::AlterCommandsModifierListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterCommandsModifierList(this);
}


std::any MySQLParser::AlterCommandsModifierListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterCommandsModifierList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterCommandsModifierListContext* MySQLParser::alterCommandsModifierList() {
  AlterCommandsModifierListContext *_localctx = _tracker.createInstance<AlterCommandsModifierListContext>(_ctx, getState());
  enterRule(_localctx, 26, MySQLParser::RuleAlterCommandsModifierList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1770);
    alterCommandsModifier();
    setState(1775);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1771);
        match(MySQLParser::COMMA_SYMBOL);
        setState(1772);
        alterCommandsModifier(); 
      }
      setState(1777);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StandaloneAlterCommandsContext ------------------------------------------------------------------

MySQLParser::StandaloneAlterCommandsContext::StandaloneAlterCommandsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StandaloneAlterCommandsContext::DISCARD_SYMBOL() {
  return getToken(MySQLParser::DISCARD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StandaloneAlterCommandsContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StandaloneAlterCommandsContext::IMPORT_SYMBOL() {
  return getToken(MySQLParser::IMPORT_SYMBOL, 0);
}

MySQLParser::AlterPartitionContext* MySQLParser::StandaloneAlterCommandsContext::alterPartition() {
  return getRuleContext<MySQLParser::AlterPartitionContext>(0);
}

tree::TerminalNode* MySQLParser::StandaloneAlterCommandsContext::SECONDARY_LOAD_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_LOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StandaloneAlterCommandsContext::SECONDARY_UNLOAD_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_UNLOAD_SYMBOL, 0);
}

MySQLParser::UsePartitionContext* MySQLParser::StandaloneAlterCommandsContext::usePartition() {
  return getRuleContext<MySQLParser::UsePartitionContext>(0);
}


size_t MySQLParser::StandaloneAlterCommandsContext::getRuleIndex() const {
  return MySQLParser::RuleStandaloneAlterCommands;
}

void MySQLParser::StandaloneAlterCommandsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStandaloneAlterCommands(this);
}

void MySQLParser::StandaloneAlterCommandsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStandaloneAlterCommands(this);
}


std::any MySQLParser::StandaloneAlterCommandsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStandaloneAlterCommands(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StandaloneAlterCommandsContext* MySQLParser::standaloneAlterCommands() {
  StandaloneAlterCommandsContext *_localctx = _tracker.createInstance<StandaloneAlterCommandsContext>(_ctx, getState());
  enterRule(_localctx, 28, MySQLParser::RuleStandaloneAlterCommands);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1796);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 35, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1778);
      match(MySQLParser::DISCARD_SYMBOL);
      setState(1779);
      match(MySQLParser::TABLESPACE_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1780);
      match(MySQLParser::IMPORT_SYMBOL);
      setState(1781);
      match(MySQLParser::TABLESPACE_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1782);
      alterPartition();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1783);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(1794);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::SECONDARY_LOAD_SYMBOL: {
          setState(1784);
          match(MySQLParser::SECONDARY_LOAD_SYMBOL);
          setState(1787);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
          case 1: {
            setState(1785);

            if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
            setState(1786);
            usePartition();
            break;
          }

          default:
            break;
          }
          break;
        }

        case MySQLParser::SECONDARY_UNLOAD_SYMBOL: {
          setState(1789);
          match(MySQLParser::SECONDARY_UNLOAD_SYMBOL);
          setState(1792);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx)) {
          case 1: {
            setState(1790);

            if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
            setState(1791);
            usePartition();
            break;
          }

          default:
            break;
          }
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterPartitionContext ------------------------------------------------------------------

MySQLParser::AlterPartitionContext::AlterPartitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

MySQLParser::PartitionDefinitionsContext* MySQLParser::AlterPartitionContext::partitionDefinitions() {
  return getRuleContext<MySQLParser::PartitionDefinitionsContext>(0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::PARTITIONS_SYMBOL() {
  return getToken(MySQLParser::PARTITIONS_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::AlterPartitionContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

std::vector<MySQLParser::NoWriteToBinLogContext *> MySQLParser::AlterPartitionContext::noWriteToBinLog() {
  return getRuleContexts<MySQLParser::NoWriteToBinLogContext>();
}

MySQLParser::NoWriteToBinLogContext* MySQLParser::AlterPartitionContext::noWriteToBinLog(size_t i) {
  return getRuleContext<MySQLParser::NoWriteToBinLogContext>(i);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::AlterPartitionContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::REBUILD_SYMBOL() {
  return getToken(MySQLParser::REBUILD_SYMBOL, 0);
}

MySQLParser::AllOrPartitionNameListContext* MySQLParser::AlterPartitionContext::allOrPartitionNameList() {
  return getRuleContext<MySQLParser::AllOrPartitionNameListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::OPTIMIZE_SYMBOL() {
  return getToken(MySQLParser::OPTIMIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::ANALYZE_SYMBOL() {
  return getToken(MySQLParser::ANALYZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::CHECK_SYMBOL() {
  return getToken(MySQLParser::CHECK_SYMBOL, 0);
}

std::vector<MySQLParser::CheckOptionContext *> MySQLParser::AlterPartitionContext::checkOption() {
  return getRuleContexts<MySQLParser::CheckOptionContext>();
}

MySQLParser::CheckOptionContext* MySQLParser::AlterPartitionContext::checkOption(size_t i) {
  return getRuleContext<MySQLParser::CheckOptionContext>(i);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::REPAIR_SYMBOL() {
  return getToken(MySQLParser::REPAIR_SYMBOL, 0);
}

std::vector<MySQLParser::RepairTypeContext *> MySQLParser::AlterPartitionContext::repairType() {
  return getRuleContexts<MySQLParser::RepairTypeContext>();
}

MySQLParser::RepairTypeContext* MySQLParser::AlterPartitionContext::repairType(size_t i) {
  return getRuleContext<MySQLParser::RepairTypeContext>(i);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::COALESCE_SYMBOL() {
  return getToken(MySQLParser::COALESCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::TRUNCATE_SYMBOL() {
  return getToken(MySQLParser::TRUNCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::REORGANIZE_SYMBOL() {
  return getToken(MySQLParser::REORGANIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::EXCHANGE_SYMBOL() {
  return getToken(MySQLParser::EXCHANGE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::AlterPartitionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::AlterPartitionContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::WithValidationContext* MySQLParser::AlterPartitionContext::withValidation() {
  return getRuleContext<MySQLParser::WithValidationContext>(0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::DISCARD_SYMBOL() {
  return getToken(MySQLParser::DISCARD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterPartitionContext::IMPORT_SYMBOL() {
  return getToken(MySQLParser::IMPORT_SYMBOL, 0);
}


size_t MySQLParser::AlterPartitionContext::getRuleIndex() const {
  return MySQLParser::RuleAlterPartition;
}

void MySQLParser::AlterPartitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterPartition(this);
}

void MySQLParser::AlterPartitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterPartition(this);
}


std::any MySQLParser::AlterPartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterPartition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterPartitionContext* MySQLParser::alterPartition() {
  AlterPartitionContext *_localctx = _tracker.createInstance<AlterPartitionContext>(_ctx, getState());
  enterRule(_localctx, 30, MySQLParser::RuleAlterPartition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1894);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1798);
      match(MySQLParser::ADD_SYMBOL);
      setState(1799);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1801);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
        setState(1800);
        noWriteToBinLog();
      }
      setState(1806);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::OPEN_PAR_SYMBOL: {
          setState(1803);
          partitionDefinitions();
          break;
        }

        case MySQLParser::PARTITIONS_SYMBOL: {
          setState(1804);
          match(MySQLParser::PARTITIONS_SYMBOL);
          setState(1805);
          real_ulong_number();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1808);
      match(MySQLParser::DROP_SYMBOL);
      setState(1809);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1810);
      identifierList();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1811);
      match(MySQLParser::REBUILD_SYMBOL);
      setState(1812);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1814);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx)) {
      case 1: {
        setState(1813);
        noWriteToBinLog();
        break;
      }

      default:
        break;
      }
      setState(1816);
      allOrPartitionNameList();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1817);
      match(MySQLParser::OPTIMIZE_SYMBOL);
      setState(1818);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1820);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
      case 1: {
        setState(1819);
        noWriteToBinLog();
        break;
      }

      default:
        break;
      }
      setState(1822);
      allOrPartitionNameList();
      setState(1824);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
        setState(1823);
        noWriteToBinLog();
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1826);
      match(MySQLParser::ANALYZE_SYMBOL);
      setState(1827);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1829);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
      case 1: {
        setState(1828);
        noWriteToBinLog();
        break;
      }

      default:
        break;
      }
      setState(1831);
      allOrPartitionNameList();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1832);
      match(MySQLParser::CHECK_SYMBOL);
      setState(1833);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1834);
      allOrPartitionNameList();
      setState(1838);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::CHANGED_SYMBOL || ((((_la - 219) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 219)) & ((1ULL << (MySQLParser::EXTENDED_SYMBOL - 219))
        | (1ULL << (MySQLParser::FAST_SYMBOL - 219))
        | (1ULL << (MySQLParser::FOR_SYMBOL - 219)))) != 0) || _la == MySQLParser::MEDIUM_SYMBOL || _la == MySQLParser::QUICK_SYMBOL) {
        setState(1835);
        checkOption();
        setState(1840);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1841);
      match(MySQLParser::REPAIR_SYMBOL);
      setState(1842);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1844);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 43, _ctx)) {
      case 1: {
        setState(1843);
        noWriteToBinLog();
        break;
      }

      default:
        break;
      }
      setState(1846);
      allOrPartitionNameList();
      setState(1850);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL || _la == MySQLParser::USE_FRM_SYMBOL) {
        setState(1847);
        repairType();
        setState(1852);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1853);
      match(MySQLParser::COALESCE_SYMBOL);
      setState(1854);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1856);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
        setState(1855);
        noWriteToBinLog();
      }
      setState(1858);
      real_ulong_number();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1859);
      match(MySQLParser::TRUNCATE_SYMBOL);
      setState(1860);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1861);
      allOrPartitionNameList();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1862);
      match(MySQLParser::REORGANIZE_SYMBOL);
      setState(1863);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1865);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 46, _ctx)) {
      case 1: {
        setState(1864);
        noWriteToBinLog();
        break;
      }

      default:
        break;
      }
      setState(1871);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
      case 1: {
        setState(1867);
        identifierList();
        setState(1868);
        match(MySQLParser::INTO_SYMBOL);
        setState(1869);
        partitionDefinitions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1873);
      match(MySQLParser::EXCHANGE_SYMBOL);
      setState(1874);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1875);
      identifier();
      setState(1876);
      match(MySQLParser::WITH_SYMBOL);
      setState(1877);
      match(MySQLParser::TABLE_SYMBOL);
      setState(1878);
      tableRef();
      setState(1880);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
      case 1: {
        setState(1879);
        withValidation();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1882);

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(1883);
      match(MySQLParser::DISCARD_SYMBOL);
      setState(1884);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1885);
      allOrPartitionNameList();
      setState(1886);
      match(MySQLParser::TABLESPACE_SYMBOL);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1888);

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(1889);
      match(MySQLParser::IMPORT_SYMBOL);
      setState(1890);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1891);
      allOrPartitionNameList();
      setState(1892);
      match(MySQLParser::TABLESPACE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterListContext ------------------------------------------------------------------

MySQLParser::AlterListContext::AlterListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::AlterListItemContext *> MySQLParser::AlterListContext::alterListItem() {
  return getRuleContexts<MySQLParser::AlterListItemContext>();
}

MySQLParser::AlterListItemContext* MySQLParser::AlterListContext::alterListItem(size_t i) {
  return getRuleContext<MySQLParser::AlterListItemContext>(i);
}

std::vector<MySQLParser::CreateTableOptionsSpaceSeparatedContext *> MySQLParser::AlterListContext::createTableOptionsSpaceSeparated() {
  return getRuleContexts<MySQLParser::CreateTableOptionsSpaceSeparatedContext>();
}

MySQLParser::CreateTableOptionsSpaceSeparatedContext* MySQLParser::AlterListContext::createTableOptionsSpaceSeparated(size_t i) {
  return getRuleContext<MySQLParser::CreateTableOptionsSpaceSeparatedContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

std::vector<MySQLParser::AlterCommandsModifierContext *> MySQLParser::AlterListContext::alterCommandsModifier() {
  return getRuleContexts<MySQLParser::AlterCommandsModifierContext>();
}

MySQLParser::AlterCommandsModifierContext* MySQLParser::AlterListContext::alterCommandsModifier(size_t i) {
  return getRuleContext<MySQLParser::AlterCommandsModifierContext>(i);
}


size_t MySQLParser::AlterListContext::getRuleIndex() const {
  return MySQLParser::RuleAlterList;
}

void MySQLParser::AlterListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterList(this);
}

void MySQLParser::AlterListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterList(this);
}


std::any MySQLParser::AlterListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterListContext* MySQLParser::alterList() {
  AlterListContext *_localctx = _tracker.createInstance<AlterListContext>(_ctx, getState());
  enterRule(_localctx, 32, MySQLParser::RuleAlterList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1898);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 50, _ctx)) {
    case 1: {
      setState(1896);
      alterListItem();
      break;
    }

    case 2: {
      setState(1897);
      createTableOptionsSpaceSeparated();
      break;
    }

    default:
      break;
    }
    setState(1908);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(1900);
      match(MySQLParser::COMMA_SYMBOL);
      setState(1904);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 51, _ctx)) {
      case 1: {
        setState(1901);
        alterListItem();
        break;
      }

      case 2: {
        setState(1902);
        alterCommandsModifier();
        break;
      }

      case 3: {
        setState(1903);
        createTableOptionsSpaceSeparated();
        break;
      }

      default:
        break;
      }
      setState(1910);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterCommandsModifierContext ------------------------------------------------------------------

MySQLParser::AlterCommandsModifierContext::AlterCommandsModifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AlterAlgorithmOptionContext* MySQLParser::AlterCommandsModifierContext::alterAlgorithmOption() {
  return getRuleContext<MySQLParser::AlterAlgorithmOptionContext>(0);
}

MySQLParser::AlterLockOptionContext* MySQLParser::AlterCommandsModifierContext::alterLockOption() {
  return getRuleContext<MySQLParser::AlterLockOptionContext>(0);
}

MySQLParser::WithValidationContext* MySQLParser::AlterCommandsModifierContext::withValidation() {
  return getRuleContext<MySQLParser::WithValidationContext>(0);
}


size_t MySQLParser::AlterCommandsModifierContext::getRuleIndex() const {
  return MySQLParser::RuleAlterCommandsModifier;
}

void MySQLParser::AlterCommandsModifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterCommandsModifier(this);
}

void MySQLParser::AlterCommandsModifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterCommandsModifier(this);
}


std::any MySQLParser::AlterCommandsModifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterCommandsModifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterCommandsModifierContext* MySQLParser::alterCommandsModifier() {
  AlterCommandsModifierContext *_localctx = _tracker.createInstance<AlterCommandsModifierContext>(_ctx, getState());
  enterRule(_localctx, 34, MySQLParser::RuleAlterCommandsModifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1914);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1911);
      alterAlgorithmOption();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1912);
      alterLockOption();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1913);
      withValidation();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterListItemContext ------------------------------------------------------------------

MySQLParser::AlterListItemContext::AlterListItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterListItemContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::AlterListItemContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::FieldDefinitionContext* MySQLParser::AlterListItemContext::fieldDefinition() {
  return getRuleContext<MySQLParser::FieldDefinitionContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::TableElementListContext* MySQLParser::AlterListItemContext::tableElementList() {
  return getRuleContext<MySQLParser::TableElementListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::COLUMN_SYMBOL() {
  return getToken(MySQLParser::COLUMN_SYMBOL, 0);
}

MySQLParser::CheckOrReferencesContext* MySQLParser::AlterListItemContext::checkOrReferences() {
  return getRuleContext<MySQLParser::CheckOrReferencesContext>(0);
}

MySQLParser::PlaceContext* MySQLParser::AlterListItemContext::place() {
  return getRuleContext<MySQLParser::PlaceContext>(0);
}

MySQLParser::TableConstraintDefContext* MySQLParser::AlterListItemContext::tableConstraintDef() {
  return getRuleContext<MySQLParser::TableConstraintDefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::CHANGE_SYMBOL() {
  return getToken(MySQLParser::CHANGE_SYMBOL, 0);
}

MySQLParser::ColumnInternalRefContext* MySQLParser::AlterListItemContext::columnInternalRef() {
  return getRuleContext<MySQLParser::ColumnInternalRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::MODIFY_SYMBOL() {
  return getToken(MySQLParser::MODIFY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::FOREIGN_SYMBOL() {
  return getToken(MySQLParser::FOREIGN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}

MySQLParser::KeyOrIndexContext* MySQLParser::AlterListItemContext::keyOrIndex() {
  return getRuleContext<MySQLParser::KeyOrIndexContext>(0);
}

MySQLParser::IndexRefContext* MySQLParser::AlterListItemContext::indexRef() {
  return getRuleContext<MySQLParser::IndexRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::CHECK_SYMBOL() {
  return getToken(MySQLParser::CHECK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::CONSTRAINT_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_SYMBOL, 0);
}

MySQLParser::RestrictContext* MySQLParser::AlterListItemContext::restrict() {
  return getRuleContext<MySQLParser::RestrictContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::KEYS_SYMBOL() {
  return getToken(MySQLParser::KEYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::ALTER_SYMBOL() {
  return getToken(MySQLParser::ALTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::VisibilityContext* MySQLParser::AlterListItemContext::visibility() {
  return getRuleContext<MySQLParser::VisibilityContext>(0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::AlterListItemContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

MySQLParser::SignedLiteralOrNullContext* MySQLParser::AlterListItemContext::signedLiteralOrNull() {
  return getRuleContext<MySQLParser::SignedLiteralOrNullContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

MySQLParser::ConstraintEnforcementContext* MySQLParser::AlterListItemContext::constraintEnforcement() {
  return getRuleContext<MySQLParser::ConstraintEnforcementContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::RENAME_SYMBOL() {
  return getToken(MySQLParser::RENAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::TableNameContext* MySQLParser::AlterListItemContext::tableName() {
  return getRuleContext<MySQLParser::TableNameContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::IndexNameContext* MySQLParser::AlterListItemContext::indexName() {
  return getRuleContext<MySQLParser::IndexNameContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::CONVERT_SYMBOL() {
  return getToken(MySQLParser::CONVERT_SYMBOL, 0);
}

MySQLParser::CharsetContext* MySQLParser::AlterListItemContext::charset() {
  return getRuleContext<MySQLParser::CharsetContext>(0);
}

MySQLParser::CharsetNameContext* MySQLParser::AlterListItemContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}

MySQLParser::CollateContext* MySQLParser::AlterListItemContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::FORCE_SYMBOL() {
  return getToken(MySQLParser::FORCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::ORDER_SYMBOL() {
  return getToken(MySQLParser::ORDER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::AlterOrderListContext* MySQLParser::AlterListItemContext::alterOrderList() {
  return getRuleContext<MySQLParser::AlterOrderListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::UPGRADE_SYMBOL() {
  return getToken(MySQLParser::UPGRADE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterListItemContext::PARTITIONING_SYMBOL() {
  return getToken(MySQLParser::PARTITIONING_SYMBOL, 0);
}


size_t MySQLParser::AlterListItemContext::getRuleIndex() const {
  return MySQLParser::RuleAlterListItem;
}

void MySQLParser::AlterListItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterListItem(this);
}

void MySQLParser::AlterListItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterListItem(this);
}


std::any MySQLParser::AlterListItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterListItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterListItemContext* MySQLParser::alterListItem() {
  AlterListItemContext *_localctx = _tracker.createInstance<AlterListItemContext>(_ctx, getState());
  enterRule(_localctx, 36, MySQLParser::RuleAlterListItem);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2056);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 71, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1916);
      match(MySQLParser::ADD_SYMBOL);
      setState(1918);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx)) {
      case 1: {
        setState(1917);
        match(MySQLParser::COLUMN_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(1932);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 57, _ctx)) {
      case 1: {
        setState(1920);
        identifier();
        setState(1921);
        fieldDefinition();
        setState(1923);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 55, _ctx)) {
        case 1: {
          setState(1922);
          checkOrReferences();
          break;
        }

        default:
          break;
        }
        setState(1926);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::AFTER_SYMBOL || _la == MySQLParser::FIRST_SYMBOL) {
          setState(1925);
          place();
        }
        break;
      }

      case 2: {
        setState(1928);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(1929);
        tableElementList();
        setState(1930);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1934);
      match(MySQLParser::ADD_SYMBOL);
      setState(1935);
      tableConstraintDef();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1936);
      match(MySQLParser::CHANGE_SYMBOL);
      setState(1938);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
      case 1: {
        setState(1937);
        match(MySQLParser::COLUMN_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(1940);
      columnInternalRef();
      setState(1941);
      identifier();
      setState(1942);
      fieldDefinition();
      setState(1944);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::AFTER_SYMBOL || _la == MySQLParser::FIRST_SYMBOL) {
        setState(1943);
        place();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1946);
      match(MySQLParser::MODIFY_SYMBOL);
      setState(1948);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 60, _ctx)) {
      case 1: {
        setState(1947);
        match(MySQLParser::COLUMN_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(1950);
      columnInternalRef();
      setState(1951);
      fieldDefinition();
      setState(1953);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::AFTER_SYMBOL || _la == MySQLParser::FIRST_SYMBOL) {
        setState(1952);
        place();
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1955);
      match(MySQLParser::DROP_SYMBOL);
      setState(1977);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 64, _ctx)) {
      case 1: {
        setState(1957);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx)) {
        case 1: {
          setState(1956);
          match(MySQLParser::COLUMN_SYMBOL);
          break;
        }

        default:
          break;
        }
        setState(1959);
        columnInternalRef();
        setState(1961);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL) {
          setState(1960);
          restrict();
        }
        break;
      }

      case 2: {
        setState(1963);
        match(MySQLParser::FOREIGN_SYMBOL);
        setState(1964);
        match(MySQLParser::KEY_SYMBOL);
        setState(1965);
        columnInternalRef();
        break;
      }

      case 3: {
        setState(1966);
        match(MySQLParser::PRIMARY_SYMBOL);
        setState(1967);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      case 4: {
        setState(1968);
        keyOrIndex();
        setState(1969);
        indexRef();
        break;
      }

      case 5: {
        setState(1971);

        if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
        setState(1972);
        match(MySQLParser::CHECK_SYMBOL);
        setState(1973);
        identifier();
        break;
      }

      case 6: {
        setState(1974);

        if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
        setState(1975);
        match(MySQLParser::CONSTRAINT_SYMBOL);
        setState(1976);
        identifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1979);
      match(MySQLParser::DISABLE_SYMBOL);
      setState(1980);
      match(MySQLParser::KEYS_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1981);
      match(MySQLParser::ENABLE_SYMBOL);
      setState(1982);
      match(MySQLParser::KEYS_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1983);
      match(MySQLParser::ALTER_SYMBOL);
      setState(1985);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
      case 1: {
        setState(1984);
        match(MySQLParser::COLUMN_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(1987);
      columnInternalRef();
      setState(2000);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx)) {
      case 1: {
        setState(1988);
        match(MySQLParser::SET_SYMBOL);
        setState(1989);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(1993);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 66, _ctx)) {
        case 1: {
          setState(1990);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(1991);
          exprWithParentheses();
          break;
        }

        case 2: {
          setState(1992);
          signedLiteralOrNull();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(1995);
        match(MySQLParser::DROP_SYMBOL);
        setState(1996);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      case 3: {
        setState(1997);

        if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
        setState(1998);
        match(MySQLParser::SET_SYMBOL);
        setState(1999);
        visibility();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2002);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(2003);
      match(MySQLParser::ALTER_SYMBOL);
      setState(2004);
      match(MySQLParser::INDEX_SYMBOL);
      setState(2005);
      indexRef();
      setState(2006);
      visibility();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(2008);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(2009);
      match(MySQLParser::ALTER_SYMBOL);
      setState(2010);
      match(MySQLParser::CHECK_SYMBOL);
      setState(2011);
      identifier();
      setState(2012);
      constraintEnforcement();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(2014);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(2015);
      match(MySQLParser::ALTER_SYMBOL);
      setState(2016);
      match(MySQLParser::CONSTRAINT_SYMBOL);
      setState(2017);
      identifier();
      setState(2018);
      constraintEnforcement();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(2020);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(2021);
      match(MySQLParser::RENAME_SYMBOL);
      setState(2022);
      match(MySQLParser::COLUMN_SYMBOL);
      setState(2023);
      columnInternalRef();
      setState(2024);
      match(MySQLParser::TO_SYMBOL);
      setState(2025);
      identifier();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(2027);
      match(MySQLParser::RENAME_SYMBOL);
      setState(2029);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
      case 1: {
        setState(2028);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::AS_SYMBOL || _la == MySQLParser::TO_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      default:
        break;
      }
      setState(2031);
      tableName();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(2032);
      match(MySQLParser::RENAME_SYMBOL);
      setState(2033);
      keyOrIndex();
      setState(2034);
      indexRef();
      setState(2035);
      match(MySQLParser::TO_SYMBOL);
      setState(2036);
      indexName();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(2038);
      match(MySQLParser::CONVERT_SYMBOL);
      setState(2039);
      match(MySQLParser::TO_SYMBOL);
      setState(2040);
      charset();
      setState(2044);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 69, _ctx)) {
      case 1: {
        setState(2041);

        if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
        setState(2042);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      case 2: {
        setState(2043);
        charsetName();
        break;
      }

      default:
        break;
      }
      setState(2047);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COLLATE_SYMBOL) {
        setState(2046);
        collate();
      }
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(2049);
      match(MySQLParser::FORCE_SYMBOL);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(2050);
      match(MySQLParser::ORDER_SYMBOL);
      setState(2051);
      match(MySQLParser::BY_SYMBOL);
      setState(2052);
      alterOrderList();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(2053);

      if (!(serverVersion >= 50708 && serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion >= 50708 && serverVersion < 80000");
      setState(2054);
      match(MySQLParser::UPGRADE_SYMBOL);
      setState(2055);
      match(MySQLParser::PARTITIONING_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PlaceContext ------------------------------------------------------------------

MySQLParser::PlaceContext::PlaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PlaceContext::AFTER_SYMBOL() {
  return getToken(MySQLParser::AFTER_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::PlaceContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::PlaceContext::FIRST_SYMBOL() {
  return getToken(MySQLParser::FIRST_SYMBOL, 0);
}


size_t MySQLParser::PlaceContext::getRuleIndex() const {
  return MySQLParser::RulePlace;
}

void MySQLParser::PlaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPlace(this);
}

void MySQLParser::PlaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPlace(this);
}


std::any MySQLParser::PlaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPlace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PlaceContext* MySQLParser::place() {
  PlaceContext *_localctx = _tracker.createInstance<PlaceContext>(_ctx, getState());
  enterRule(_localctx, 38, MySQLParser::RulePlace);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2061);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::AFTER_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2058);
        match(MySQLParser::AFTER_SYMBOL);
        setState(2059);
        identifier();
        break;
      }

      case MySQLParser::FIRST_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2060);
        match(MySQLParser::FIRST_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RestrictContext ------------------------------------------------------------------

MySQLParser::RestrictContext::RestrictContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RestrictContext::RESTRICT_SYMBOL() {
  return getToken(MySQLParser::RESTRICT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RestrictContext::CASCADE_SYMBOL() {
  return getToken(MySQLParser::CASCADE_SYMBOL, 0);
}


size_t MySQLParser::RestrictContext::getRuleIndex() const {
  return MySQLParser::RuleRestrict;
}

void MySQLParser::RestrictContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRestrict(this);
}

void MySQLParser::RestrictContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRestrict(this);
}


std::any MySQLParser::RestrictContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRestrict(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RestrictContext* MySQLParser::restrict() {
  RestrictContext *_localctx = _tracker.createInstance<RestrictContext>(_ctx, getState());
  enterRule(_localctx, 40, MySQLParser::RuleRestrict);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2063);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterOrderListContext ------------------------------------------------------------------

MySQLParser::AlterOrderListContext::AlterOrderListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::IdentifierContext *> MySQLParser::AlterOrderListContext::identifier() {
  return getRuleContexts<MySQLParser::IdentifierContext>();
}

MySQLParser::IdentifierContext* MySQLParser::AlterOrderListContext::identifier(size_t i) {
  return getRuleContext<MySQLParser::IdentifierContext>(i);
}

std::vector<MySQLParser::DirectionContext *> MySQLParser::AlterOrderListContext::direction() {
  return getRuleContexts<MySQLParser::DirectionContext>();
}

MySQLParser::DirectionContext* MySQLParser::AlterOrderListContext::direction(size_t i) {
  return getRuleContext<MySQLParser::DirectionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterOrderListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterOrderListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::AlterOrderListContext::getRuleIndex() const {
  return MySQLParser::RuleAlterOrderList;
}

void MySQLParser::AlterOrderListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterOrderList(this);
}

void MySQLParser::AlterOrderListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterOrderList(this);
}


std::any MySQLParser::AlterOrderListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterOrderList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterOrderListContext* MySQLParser::alterOrderList() {
  AlterOrderListContext *_localctx = _tracker.createInstance<AlterOrderListContext>(_ctx, getState());
  enterRule(_localctx, 42, MySQLParser::RuleAlterOrderList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2065);
    identifier();
    setState(2067);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
      setState(2066);
      direction();
    }
    setState(2076);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2069);
        match(MySQLParser::COMMA_SYMBOL);
        setState(2070);
        identifier();
        setState(2072);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
          setState(2071);
          direction();
        } 
      }
      setState(2078);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterAlgorithmOptionContext ------------------------------------------------------------------

MySQLParser::AlterAlgorithmOptionContext::AlterAlgorithmOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterAlgorithmOptionContext::ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterAlgorithmOptionContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::AlterAlgorithmOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::AlterAlgorithmOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::AlterAlgorithmOptionContext::getRuleIndex() const {
  return MySQLParser::RuleAlterAlgorithmOption;
}

void MySQLParser::AlterAlgorithmOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterAlgorithmOption(this);
}

void MySQLParser::AlterAlgorithmOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterAlgorithmOption(this);
}


std::any MySQLParser::AlterAlgorithmOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterAlgorithmOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterAlgorithmOptionContext* MySQLParser::alterAlgorithmOption() {
  AlterAlgorithmOptionContext *_localctx = _tracker.createInstance<AlterAlgorithmOptionContext>(_ctx, getState());
  enterRule(_localctx, 44, MySQLParser::RuleAlterAlgorithmOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2079);
    match(MySQLParser::ALGORITHM_SYMBOL);
    setState(2081);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx)) {
    case 1: {
      setState(2080);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2085);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 77, _ctx)) {
    case 1: {
      setState(2083);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    case 2: {
      setState(2084);
      identifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterLockOptionContext ------------------------------------------------------------------

MySQLParser::AlterLockOptionContext::AlterLockOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterLockOptionContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterLockOptionContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::AlterLockOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::AlterLockOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::AlterLockOptionContext::getRuleIndex() const {
  return MySQLParser::RuleAlterLockOption;
}

void MySQLParser::AlterLockOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterLockOption(this);
}

void MySQLParser::AlterLockOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterLockOption(this);
}


std::any MySQLParser::AlterLockOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterLockOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterLockOptionContext* MySQLParser::alterLockOption() {
  AlterLockOptionContext *_localctx = _tracker.createInstance<AlterLockOptionContext>(_ctx, getState());
  enterRule(_localctx, 46, MySQLParser::RuleAlterLockOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2087);
    match(MySQLParser::LOCK_SYMBOL);
    setState(2089);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 78, _ctx)) {
    case 1: {
      setState(2088);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2093);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
    case 1: {
      setState(2091);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    case 2: {
      setState(2092);
      identifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexLockAndAlgorithmContext ------------------------------------------------------------------

MySQLParser::IndexLockAndAlgorithmContext::IndexLockAndAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AlterAlgorithmOptionContext* MySQLParser::IndexLockAndAlgorithmContext::alterAlgorithmOption() {
  return getRuleContext<MySQLParser::AlterAlgorithmOptionContext>(0);
}

MySQLParser::AlterLockOptionContext* MySQLParser::IndexLockAndAlgorithmContext::alterLockOption() {
  return getRuleContext<MySQLParser::AlterLockOptionContext>(0);
}


size_t MySQLParser::IndexLockAndAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RuleIndexLockAndAlgorithm;
}

void MySQLParser::IndexLockAndAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexLockAndAlgorithm(this);
}

void MySQLParser::IndexLockAndAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexLockAndAlgorithm(this);
}


std::any MySQLParser::IndexLockAndAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexLockAndAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexLockAndAlgorithmContext* MySQLParser::indexLockAndAlgorithm() {
  IndexLockAndAlgorithmContext *_localctx = _tracker.createInstance<IndexLockAndAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 48, MySQLParser::RuleIndexLockAndAlgorithm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2103);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ALGORITHM_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2095);
        alterAlgorithmOption();
        setState(2097);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCK_SYMBOL) {
          setState(2096);
          alterLockOption();
        }
        break;
      }

      case MySQLParser::LOCK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2099);
        alterLockOption();
        setState(2101);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ALGORITHM_SYMBOL) {
          setState(2100);
          alterAlgorithmOption();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WithValidationContext ------------------------------------------------------------------

MySQLParser::WithValidationContext::WithValidationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WithValidationContext::VALIDATION_SYMBOL() {
  return getToken(MySQLParser::VALIDATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WithValidationContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WithValidationContext::WITHOUT_SYMBOL() {
  return getToken(MySQLParser::WITHOUT_SYMBOL, 0);
}


size_t MySQLParser::WithValidationContext::getRuleIndex() const {
  return MySQLParser::RuleWithValidation;
}

void MySQLParser::WithValidationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWithValidation(this);
}

void MySQLParser::WithValidationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWithValidation(this);
}


std::any MySQLParser::WithValidationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWithValidation(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WithValidationContext* MySQLParser::withValidation() {
  WithValidationContext *_localctx = _tracker.createInstance<WithValidationContext>(_ctx, getState());
  enterRule(_localctx, 50, MySQLParser::RuleWithValidation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2105);

    if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
    setState(2106);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::WITH_SYMBOL

    || _la == MySQLParser::WITHOUT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2107);
    match(MySQLParser::VALIDATION_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RemovePartitioningContext ------------------------------------------------------------------

MySQLParser::RemovePartitioningContext::RemovePartitioningContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RemovePartitioningContext::REMOVE_SYMBOL() {
  return getToken(MySQLParser::REMOVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RemovePartitioningContext::PARTITIONING_SYMBOL() {
  return getToken(MySQLParser::PARTITIONING_SYMBOL, 0);
}


size_t MySQLParser::RemovePartitioningContext::getRuleIndex() const {
  return MySQLParser::RuleRemovePartitioning;
}

void MySQLParser::RemovePartitioningContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRemovePartitioning(this);
}

void MySQLParser::RemovePartitioningContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRemovePartitioning(this);
}


std::any MySQLParser::RemovePartitioningContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRemovePartitioning(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RemovePartitioningContext* MySQLParser::removePartitioning() {
  RemovePartitioningContext *_localctx = _tracker.createInstance<RemovePartitioningContext>(_ctx, getState());
  enterRule(_localctx, 52, MySQLParser::RuleRemovePartitioning);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2109);
    match(MySQLParser::REMOVE_SYMBOL);
    setState(2110);
    match(MySQLParser::PARTITIONING_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AllOrPartitionNameListContext ------------------------------------------------------------------

MySQLParser::AllOrPartitionNameListContext::AllOrPartitionNameListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AllOrPartitionNameListContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::AllOrPartitionNameListContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}


size_t MySQLParser::AllOrPartitionNameListContext::getRuleIndex() const {
  return MySQLParser::RuleAllOrPartitionNameList;
}

void MySQLParser::AllOrPartitionNameListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAllOrPartitionNameList(this);
}

void MySQLParser::AllOrPartitionNameListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAllOrPartitionNameList(this);
}


std::any MySQLParser::AllOrPartitionNameListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAllOrPartitionNameList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AllOrPartitionNameListContext* MySQLParser::allOrPartitionNameList() {
  AllOrPartitionNameListContext *_localctx = _tracker.createInstance<AllOrPartitionNameListContext>(_ctx, getState());
  enterRule(_localctx, 54, MySQLParser::RuleAllOrPartitionNameList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2114);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2112);
      match(MySQLParser::ALL_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2113);
      identifierList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterTablespaceContext ------------------------------------------------------------------

MySQLParser::AlterTablespaceContext::AlterTablespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

MySQLParser::TablespaceRefContext* MySQLParser::AlterTablespaceContext::tablespaceRef() {
  return getRuleContext<MySQLParser::TablespaceRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::DATAFILE_SYMBOL() {
  return getToken(MySQLParser::DATAFILE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::AlterTablespaceContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::RENAME_SYMBOL() {
  return getToken(MySQLParser::RENAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::AlterTablespaceContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::AlterTablespaceOptionsContext* MySQLParser::AlterTablespaceContext::alterTablespaceOptions() {
  return getRuleContext<MySQLParser::AlterTablespaceOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}


size_t MySQLParser::AlterTablespaceContext::getRuleIndex() const {
  return MySQLParser::RuleAlterTablespace;
}

void MySQLParser::AlterTablespaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterTablespace(this);
}

void MySQLParser::AlterTablespaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterTablespace(this);
}


std::any MySQLParser::AlterTablespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterTablespace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterTablespaceContext* MySQLParser::alterTablespace() {
  AlterTablespaceContext *_localctx = _tracker.createInstance<AlterTablespaceContext>(_ctx, getState());
  enterRule(_localctx, 56, MySQLParser::RuleAlterTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2116);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2117);
    tablespaceRef();
    setState(2129);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      setState(2118);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ADD_SYMBOL || _la == MySQLParser::DROP_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(2119);
      match(MySQLParser::DATAFILE_SYMBOL);
      setState(2120);
      textLiteral();
      setState(2122);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx)) {
      case 1: {
        setState(2121);
        alterTablespaceOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(2124);
      match(MySQLParser::RENAME_SYMBOL);
      setState(2125);
      match(MySQLParser::TO_SYMBOL);
      setState(2126);
      identifier();
      break;
    }

    case 3: {
      setState(2127);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2128);
      alterTablespaceOptions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterUndoTablespaceContext ------------------------------------------------------------------

MySQLParser::AlterUndoTablespaceContext::AlterUndoTablespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterUndoTablespaceContext::UNDO_SYMBOL() {
  return getToken(MySQLParser::UNDO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUndoTablespaceContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

MySQLParser::TablespaceRefContext* MySQLParser::AlterUndoTablespaceContext::tablespaceRef() {
  return getRuleContext<MySQLParser::TablespaceRefContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUndoTablespaceContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUndoTablespaceContext::ACTIVE_SYMBOL() {
  return getToken(MySQLParser::ACTIVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUndoTablespaceContext::INACTIVE_SYMBOL() {
  return getToken(MySQLParser::INACTIVE_SYMBOL, 0);
}

MySQLParser::UndoTableSpaceOptionsContext* MySQLParser::AlterUndoTablespaceContext::undoTableSpaceOptions() {
  return getRuleContext<MySQLParser::UndoTableSpaceOptionsContext>(0);
}


size_t MySQLParser::AlterUndoTablespaceContext::getRuleIndex() const {
  return MySQLParser::RuleAlterUndoTablespace;
}

void MySQLParser::AlterUndoTablespaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterUndoTablespace(this);
}

void MySQLParser::AlterUndoTablespaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterUndoTablespace(this);
}


std::any MySQLParser::AlterUndoTablespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterUndoTablespace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterUndoTablespaceContext* MySQLParser::alterUndoTablespace() {
  AlterUndoTablespaceContext *_localctx = _tracker.createInstance<AlterUndoTablespaceContext>(_ctx, getState());
  enterRule(_localctx, 58, MySQLParser::RuleAlterUndoTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2131);
    match(MySQLParser::UNDO_SYMBOL);
    setState(2132);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2133);
    tablespaceRef();
    setState(2134);
    match(MySQLParser::SET_SYMBOL);
    setState(2135);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ACTIVE_SYMBOL

    || _la == MySQLParser::INACTIVE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2137);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(2136);
      undoTableSpaceOptions();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UndoTableSpaceOptionsContext ------------------------------------------------------------------

MySQLParser::UndoTableSpaceOptionsContext::UndoTableSpaceOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::UndoTableSpaceOptionContext *> MySQLParser::UndoTableSpaceOptionsContext::undoTableSpaceOption() {
  return getRuleContexts<MySQLParser::UndoTableSpaceOptionContext>();
}

MySQLParser::UndoTableSpaceOptionContext* MySQLParser::UndoTableSpaceOptionsContext::undoTableSpaceOption(size_t i) {
  return getRuleContext<MySQLParser::UndoTableSpaceOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::UndoTableSpaceOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::UndoTableSpaceOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::UndoTableSpaceOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleUndoTableSpaceOptions;
}

void MySQLParser::UndoTableSpaceOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUndoTableSpaceOptions(this);
}

void MySQLParser::UndoTableSpaceOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUndoTableSpaceOptions(this);
}


std::any MySQLParser::UndoTableSpaceOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUndoTableSpaceOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UndoTableSpaceOptionsContext* MySQLParser::undoTableSpaceOptions() {
  UndoTableSpaceOptionsContext *_localctx = _tracker.createInstance<UndoTableSpaceOptionsContext>(_ctx, getState());
  enterRule(_localctx, 60, MySQLParser::RuleUndoTableSpaceOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2139);
    undoTableSpaceOption();
    setState(2146);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(2141);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(2140);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(2143);
      undoTableSpaceOption();
      setState(2148);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UndoTableSpaceOptionContext ------------------------------------------------------------------

MySQLParser::UndoTableSpaceOptionContext::UndoTableSpaceOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TsOptionEngineContext* MySQLParser::UndoTableSpaceOptionContext::tsOptionEngine() {
  return getRuleContext<MySQLParser::TsOptionEngineContext>(0);
}


size_t MySQLParser::UndoTableSpaceOptionContext::getRuleIndex() const {
  return MySQLParser::RuleUndoTableSpaceOption;
}

void MySQLParser::UndoTableSpaceOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUndoTableSpaceOption(this);
}

void MySQLParser::UndoTableSpaceOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUndoTableSpaceOption(this);
}


std::any MySQLParser::UndoTableSpaceOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUndoTableSpaceOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UndoTableSpaceOptionContext* MySQLParser::undoTableSpaceOption() {
  UndoTableSpaceOptionContext *_localctx = _tracker.createInstance<UndoTableSpaceOptionContext>(_ctx, getState());
  enterRule(_localctx, 62, MySQLParser::RuleUndoTableSpaceOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2149);
    tsOptionEngine();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterTablespaceOptionsContext ------------------------------------------------------------------

MySQLParser::AlterTablespaceOptionsContext::AlterTablespaceOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::AlterTablespaceOptionContext *> MySQLParser::AlterTablespaceOptionsContext::alterTablespaceOption() {
  return getRuleContexts<MySQLParser::AlterTablespaceOptionContext>();
}

MySQLParser::AlterTablespaceOptionContext* MySQLParser::AlterTablespaceOptionsContext::alterTablespaceOption(size_t i) {
  return getRuleContext<MySQLParser::AlterTablespaceOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterTablespaceOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterTablespaceOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::AlterTablespaceOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleAlterTablespaceOptions;
}

void MySQLParser::AlterTablespaceOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterTablespaceOptions(this);
}

void MySQLParser::AlterTablespaceOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterTablespaceOptions(this);
}


std::any MySQLParser::AlterTablespaceOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterTablespaceOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterTablespaceOptionsContext* MySQLParser::alterTablespaceOptions() {
  AlterTablespaceOptionsContext *_localctx = _tracker.createInstance<AlterTablespaceOptionsContext>(_ctx, getState());
  enterRule(_localctx, 64, MySQLParser::RuleAlterTablespaceOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2151);
    alterTablespaceOption();
    setState(2158);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2153);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) {
        case 1: {
          setState(2152);
          match(MySQLParser::COMMA_SYMBOL);
          break;
        }

        default:
          break;
        }
        setState(2155);
        alterTablespaceOption(); 
      }
      setState(2160);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterTablespaceOptionContext ------------------------------------------------------------------

MySQLParser::AlterTablespaceOptionContext::AlterTablespaceOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterTablespaceOptionContext::INITIAL_SIZE_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::AlterTablespaceOptionContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TsOptionAutoextendSizeContext* MySQLParser::AlterTablespaceOptionContext::tsOptionAutoextendSize() {
  return getRuleContext<MySQLParser::TsOptionAutoextendSizeContext>(0);
}

MySQLParser::TsOptionMaxSizeContext* MySQLParser::AlterTablespaceOptionContext::tsOptionMaxSize() {
  return getRuleContext<MySQLParser::TsOptionMaxSizeContext>(0);
}

MySQLParser::TsOptionEngineContext* MySQLParser::AlterTablespaceOptionContext::tsOptionEngine() {
  return getRuleContext<MySQLParser::TsOptionEngineContext>(0);
}

MySQLParser::TsOptionWaitContext* MySQLParser::AlterTablespaceOptionContext::tsOptionWait() {
  return getRuleContext<MySQLParser::TsOptionWaitContext>(0);
}

MySQLParser::TsOptionEncryptionContext* MySQLParser::AlterTablespaceOptionContext::tsOptionEncryption() {
  return getRuleContext<MySQLParser::TsOptionEncryptionContext>(0);
}

MySQLParser::TsOptionEngineAttributeContext* MySQLParser::AlterTablespaceOptionContext::tsOptionEngineAttribute() {
  return getRuleContext<MySQLParser::TsOptionEngineAttributeContext>(0);
}


size_t MySQLParser::AlterTablespaceOptionContext::getRuleIndex() const {
  return MySQLParser::RuleAlterTablespaceOption;
}

void MySQLParser::AlterTablespaceOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterTablespaceOption(this);
}

void MySQLParser::AlterTablespaceOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterTablespaceOption(this);
}


std::any MySQLParser::AlterTablespaceOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterTablespaceOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterTablespaceOptionContext* MySQLParser::alterTablespaceOption() {
  AlterTablespaceOptionContext *_localctx = _tracker.createInstance<AlterTablespaceOptionContext>(_ctx, getState());
  enterRule(_localctx, 66, MySQLParser::RuleAlterTablespaceOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2173);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2161);
      match(MySQLParser::INITIAL_SIZE_SYMBOL);
      setState(2163);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
      case 1: {
        setState(2162);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(2165);
      sizeNumber();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2166);
      tsOptionAutoextendSize();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2167);
      tsOptionMaxSize();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2168);
      tsOptionEngine();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2169);
      tsOptionWait();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2170);
      tsOptionEncryption();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2171);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(2172);
      tsOptionEngineAttribute();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeTablespaceOptionContext ------------------------------------------------------------------

MySQLParser::ChangeTablespaceOptionContext::ChangeTablespaceOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeTablespaceOptionContext::INITIAL_SIZE_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::ChangeTablespaceOptionContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::ChangeTablespaceOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TsOptionAutoextendSizeContext* MySQLParser::ChangeTablespaceOptionContext::tsOptionAutoextendSize() {
  return getRuleContext<MySQLParser::TsOptionAutoextendSizeContext>(0);
}

MySQLParser::TsOptionMaxSizeContext* MySQLParser::ChangeTablespaceOptionContext::tsOptionMaxSize() {
  return getRuleContext<MySQLParser::TsOptionMaxSizeContext>(0);
}


size_t MySQLParser::ChangeTablespaceOptionContext::getRuleIndex() const {
  return MySQLParser::RuleChangeTablespaceOption;
}

void MySQLParser::ChangeTablespaceOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeTablespaceOption(this);
}

void MySQLParser::ChangeTablespaceOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeTablespaceOption(this);
}


std::any MySQLParser::ChangeTablespaceOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeTablespaceOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeTablespaceOptionContext* MySQLParser::changeTablespaceOption() {
  ChangeTablespaceOptionContext *_localctx = _tracker.createInstance<ChangeTablespaceOptionContext>(_ctx, getState());
  enterRule(_localctx, 68, MySQLParser::RuleChangeTablespaceOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2182);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INITIAL_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2175);
        match(MySQLParser::INITIAL_SIZE_SYMBOL);
        setState(2177);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx)) {
        case 1: {
          setState(2176);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        setState(2179);
        sizeNumber();
        break;
      }

      case MySQLParser::AUTOEXTEND_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2180);
        tsOptionAutoextendSize();
        break;
      }

      case MySQLParser::MAX_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2181);
        tsOptionMaxSize();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterViewContext ------------------------------------------------------------------

MySQLParser::AlterViewContext::AlterViewContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterViewContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

MySQLParser::ViewRefContext* MySQLParser::AlterViewContext::viewRef() {
  return getRuleContext<MySQLParser::ViewRefContext>(0);
}

MySQLParser::ViewTailContext* MySQLParser::AlterViewContext::viewTail() {
  return getRuleContext<MySQLParser::ViewTailContext>(0);
}

MySQLParser::ViewAlgorithmContext* MySQLParser::AlterViewContext::viewAlgorithm() {
  return getRuleContext<MySQLParser::ViewAlgorithmContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::AlterViewContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

MySQLParser::ViewSuidContext* MySQLParser::AlterViewContext::viewSuid() {
  return getRuleContext<MySQLParser::ViewSuidContext>(0);
}


size_t MySQLParser::AlterViewContext::getRuleIndex() const {
  return MySQLParser::RuleAlterView;
}

void MySQLParser::AlterViewContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterView(this);
}

void MySQLParser::AlterViewContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterView(this);
}


std::any MySQLParser::AlterViewContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterView(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterViewContext* MySQLParser::alterView() {
  AlterViewContext *_localctx = _tracker.createInstance<AlterViewContext>(_ctx, getState());
  enterRule(_localctx, 70, MySQLParser::RuleAlterView);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2185);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL) {
      setState(2184);
      viewAlgorithm();
    }
    setState(2188);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2187);
      definerClause();
    }
    setState(2191);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SQL_SYMBOL) {
      setState(2190);
      viewSuid();
    }
    setState(2193);
    match(MySQLParser::VIEW_SYMBOL);
    setState(2194);
    viewRef();
    setState(2195);
    viewTail();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewTailContext ------------------------------------------------------------------

MySQLParser::ViewTailContext::ViewTailContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ViewTailContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::ViewQueryBlockContext* MySQLParser::ViewTailContext::viewQueryBlock() {
  return getRuleContext<MySQLParser::ViewQueryBlockContext>(0);
}

MySQLParser::ColumnInternalRefListContext* MySQLParser::ViewTailContext::columnInternalRefList() {
  return getRuleContext<MySQLParser::ColumnInternalRefListContext>(0);
}


size_t MySQLParser::ViewTailContext::getRuleIndex() const {
  return MySQLParser::RuleViewTail;
}

void MySQLParser::ViewTailContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewTail(this);
}

void MySQLParser::ViewTailContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewTail(this);
}


std::any MySQLParser::ViewTailContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewTail(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewTailContext* MySQLParser::viewTail() {
  ViewTailContext *_localctx = _tracker.createInstance<ViewTailContext>(_ctx, getState());
  enterRule(_localctx, 72, MySQLParser::RuleViewTail);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2198);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(2197);
      columnInternalRefList();
    }
    setState(2200);
    match(MySQLParser::AS_SYMBOL);
    setState(2201);
    viewQueryBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewQueryBlockContext ------------------------------------------------------------------

MySQLParser::ViewQueryBlockContext::ViewQueryBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionWithOptLockingClausesContext* MySQLParser::ViewQueryBlockContext::queryExpressionWithOptLockingClauses() {
  return getRuleContext<MySQLParser::QueryExpressionWithOptLockingClausesContext>(0);
}

MySQLParser::ViewCheckOptionContext* MySQLParser::ViewQueryBlockContext::viewCheckOption() {
  return getRuleContext<MySQLParser::ViewCheckOptionContext>(0);
}


size_t MySQLParser::ViewQueryBlockContext::getRuleIndex() const {
  return MySQLParser::RuleViewQueryBlock;
}

void MySQLParser::ViewQueryBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewQueryBlock(this);
}

void MySQLParser::ViewQueryBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewQueryBlock(this);
}


std::any MySQLParser::ViewQueryBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewQueryBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewQueryBlockContext* MySQLParser::viewQueryBlock() {
  ViewQueryBlockContext *_localctx = _tracker.createInstance<ViewQueryBlockContext>(_ctx, getState());
  enterRule(_localctx, 74, MySQLParser::RuleViewQueryBlock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2203);
    queryExpressionWithOptLockingClauses();
    setState(2205);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::WITH_SYMBOL) {
      setState(2204);
      viewCheckOption();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewCheckOptionContext ------------------------------------------------------------------

MySQLParser::ViewCheckOptionContext::ViewCheckOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ViewCheckOptionContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewCheckOptionContext::CHECK_SYMBOL() {
  return getToken(MySQLParser::CHECK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewCheckOptionContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewCheckOptionContext::CASCADED_SYMBOL() {
  return getToken(MySQLParser::CASCADED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewCheckOptionContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}


size_t MySQLParser::ViewCheckOptionContext::getRuleIndex() const {
  return MySQLParser::RuleViewCheckOption;
}

void MySQLParser::ViewCheckOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewCheckOption(this);
}

void MySQLParser::ViewCheckOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewCheckOption(this);
}


std::any MySQLParser::ViewCheckOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewCheckOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewCheckOptionContext* MySQLParser::viewCheckOption() {
  ViewCheckOptionContext *_localctx = _tracker.createInstance<ViewCheckOptionContext>(_ctx, getState());
  enterRule(_localctx, 76, MySQLParser::RuleViewCheckOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2207);
    match(MySQLParser::WITH_SYMBOL);
    setState(2209);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::CASCADED_SYMBOL || _la == MySQLParser::LOCAL_SYMBOL) {
      setState(2208);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CASCADED_SYMBOL || _la == MySQLParser::LOCAL_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(2211);
    match(MySQLParser::CHECK_SYMBOL);
    setState(2212);
    match(MySQLParser::OPTION_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterInstanceStatementContext ------------------------------------------------------------------

MySQLParser::AlterInstanceStatementContext::AlterInstanceStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::INSTANCE_SYMBOL() {
  return getToken(MySQLParser::INSTANCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::ROTATE_SYMBOL() {
  return getToken(MySQLParser::ROTATE_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::AlterInstanceStatementContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::RELOAD_SYMBOL() {
  return getToken(MySQLParser::RELOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::TLS_SYMBOL() {
  return getToken(MySQLParser::TLS_SYMBOL, 0);
}

std::vector<MySQLParser::IdentifierContext *> MySQLParser::AlterInstanceStatementContext::identifier() {
  return getRuleContexts<MySQLParser::IdentifierContext>();
}

MySQLParser::IdentifierContext* MySQLParser::AlterInstanceStatementContext::identifier(size_t i) {
  return getRuleContext<MySQLParser::IdentifierContext>(i);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::KEYRING_SYMBOL() {
  return getToken(MySQLParser::KEYRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::CHANNEL_SYMBOL() {
  return getToken(MySQLParser::CHANNEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::ROLLBACK_SYMBOL() {
  return getToken(MySQLParser::ROLLBACK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterInstanceStatementContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}


size_t MySQLParser::AlterInstanceStatementContext::getRuleIndex() const {
  return MySQLParser::RuleAlterInstanceStatement;
}

void MySQLParser::AlterInstanceStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterInstanceStatement(this);
}

void MySQLParser::AlterInstanceStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterInstanceStatement(this);
}


std::any MySQLParser::AlterInstanceStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterInstanceStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterInstanceStatementContext* MySQLParser::alterInstanceStatement() {
  AlterInstanceStatementContext *_localctx = _tracker.createInstance<AlterInstanceStatementContext>(_ctx, getState());
  enterRule(_localctx, 78, MySQLParser::RuleAlterInstanceStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2247);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 104, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2214);

      if (!(serverVersion >= 50713)) throw FailedPredicateException(this, "serverVersion >= 50713");
      setState(2215);
      match(MySQLParser::INSTANCE_SYMBOL);
      setState(2244);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 103, _ctx)) {
      case 1: {
        setState(2216);
        match(MySQLParser::ROTATE_SYMBOL);
        setState(2217);
        textOrIdentifier();
        setState(2218);
        match(MySQLParser::MASTER_SYMBOL);
        setState(2219);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      case 2: {
        setState(2221);

        if (!(serverVersion >= 80016)) throw FailedPredicateException(this, "serverVersion >= 80016");
        setState(2222);
        match(MySQLParser::RELOAD_SYMBOL);
        setState(2223);
        match(MySQLParser::TLS_SYMBOL);
        setState(2228);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 101, _ctx)) {
        case 1: {
          setState(2224);

          if (!(serverVersion >= 80021)) throw FailedPredicateException(this, "serverVersion >= 80021");
          setState(2225);
          match(MySQLParser::FOR_SYMBOL);
          setState(2226);
          match(MySQLParser::CHANNEL_SYMBOL);
          setState(2227);
          identifier();
          break;
        }

        default:
          break;
        }
        setState(2234);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NO_SYMBOL) {
          setState(2230);
          match(MySQLParser::NO_SYMBOL);
          setState(2231);
          match(MySQLParser::ROLLBACK_SYMBOL);
          setState(2232);
          match(MySQLParser::ON_SYMBOL);
          setState(2233);
          match(MySQLParser::ERROR_SYMBOL);
        }
        break;
      }

      case 3: {
        setState(2236);

        if (!(serverVersion >= 80021)) throw FailedPredicateException(this, "serverVersion >= 80021");
        setState(2237);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::DISABLE_SYMBOL

        || _la == MySQLParser::ENABLE_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(2238);
        identifier();
        setState(2239);
        identifier();
        break;
      }

      case 4: {
        setState(2241);

        if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
        setState(2242);
        match(MySQLParser::RELOAD_SYMBOL);
        setState(2243);
        match(MySQLParser::KEYRING_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);

      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateStatementContext ------------------------------------------------------------------

MySQLParser::CreateStatementContext::CreateStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

MySQLParser::CreateDatabaseContext* MySQLParser::CreateStatementContext::createDatabase() {
  return getRuleContext<MySQLParser::CreateDatabaseContext>(0);
}

MySQLParser::CreateTableContext* MySQLParser::CreateStatementContext::createTable() {
  return getRuleContext<MySQLParser::CreateTableContext>(0);
}

MySQLParser::CreateFunctionContext* MySQLParser::CreateStatementContext::createFunction() {
  return getRuleContext<MySQLParser::CreateFunctionContext>(0);
}

MySQLParser::CreateProcedureContext* MySQLParser::CreateStatementContext::createProcedure() {
  return getRuleContext<MySQLParser::CreateProcedureContext>(0);
}

MySQLParser::CreateUdfContext* MySQLParser::CreateStatementContext::createUdf() {
  return getRuleContext<MySQLParser::CreateUdfContext>(0);
}

MySQLParser::CreateLogfileGroupContext* MySQLParser::CreateStatementContext::createLogfileGroup() {
  return getRuleContext<MySQLParser::CreateLogfileGroupContext>(0);
}

MySQLParser::CreateViewContext* MySQLParser::CreateStatementContext::createView() {
  return getRuleContext<MySQLParser::CreateViewContext>(0);
}

MySQLParser::CreateTriggerContext* MySQLParser::CreateStatementContext::createTrigger() {
  return getRuleContext<MySQLParser::CreateTriggerContext>(0);
}

MySQLParser::CreateIndexContext* MySQLParser::CreateStatementContext::createIndex() {
  return getRuleContext<MySQLParser::CreateIndexContext>(0);
}

MySQLParser::CreateServerContext* MySQLParser::CreateStatementContext::createServer() {
  return getRuleContext<MySQLParser::CreateServerContext>(0);
}

MySQLParser::CreateTablespaceContext* MySQLParser::CreateStatementContext::createTablespace() {
  return getRuleContext<MySQLParser::CreateTablespaceContext>(0);
}

MySQLParser::CreateEventContext* MySQLParser::CreateStatementContext::createEvent() {
  return getRuleContext<MySQLParser::CreateEventContext>(0);
}

MySQLParser::CreateRoleContext* MySQLParser::CreateStatementContext::createRole() {
  return getRuleContext<MySQLParser::CreateRoleContext>(0);
}

MySQLParser::CreateSpatialReferenceContext* MySQLParser::CreateStatementContext::createSpatialReference() {
  return getRuleContext<MySQLParser::CreateSpatialReferenceContext>(0);
}

MySQLParser::CreateUndoTablespaceContext* MySQLParser::CreateStatementContext::createUndoTablespace() {
  return getRuleContext<MySQLParser::CreateUndoTablespaceContext>(0);
}

MySQLParser::CreateLibraryContext* MySQLParser::CreateStatementContext::createLibrary() {
  return getRuleContext<MySQLParser::CreateLibraryContext>(0);
}


size_t MySQLParser::CreateStatementContext::getRuleIndex() const {
  return MySQLParser::RuleCreateStatement;
}

void MySQLParser::CreateStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateStatement(this);
}

void MySQLParser::CreateStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateStatement(this);
}


std::any MySQLParser::CreateStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateStatementContext* MySQLParser::createStatement() {
  CreateStatementContext *_localctx = _tracker.createInstance<CreateStatementContext>(_ctx, getState());
  enterRule(_localctx, 80, MySQLParser::RuleCreateStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2249);
    match(MySQLParser::CREATE_SYMBOL);
    setState(2270);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
    case 1: {
      setState(2250);
      createDatabase();
      break;
    }

    case 2: {
      setState(2251);
      createTable();
      break;
    }

    case 3: {
      setState(2252);
      createFunction();
      break;
    }

    case 4: {
      setState(2253);
      createProcedure();
      break;
    }

    case 5: {
      setState(2254);
      createUdf();
      break;
    }

    case 6: {
      setState(2255);
      createLogfileGroup();
      break;
    }

    case 7: {
      setState(2256);
      createView();
      break;
    }

    case 8: {
      setState(2257);
      createTrigger();
      break;
    }

    case 9: {
      setState(2258);
      createIndex();
      break;
    }

    case 10: {
      setState(2259);
      createServer();
      break;
    }

    case 11: {
      setState(2260);
      createTablespace();
      break;
    }

    case 12: {
      setState(2261);
      createEvent();
      break;
    }

    case 13: {
      setState(2262);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(2263);
      createRole();
      break;
    }

    case 14: {
      setState(2264);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(2265);
      createSpatialReference();
      break;
    }

    case 15: {
      setState(2266);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2267);
      createUndoTablespace();
      break;
    }

    case 16: {
      setState(2268);

      if (!(serverVersion >= 90200)) throw FailedPredicateException(this, "serverVersion >= 90200");
      setState(2269);
      createLibrary();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateDatabaseContext ------------------------------------------------------------------

MySQLParser::CreateDatabaseContext::CreateDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateDatabaseContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

MySQLParser::SchemaNameContext* MySQLParser::CreateDatabaseContext::schemaName() {
  return getRuleContext<MySQLParser::SchemaNameContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateDatabaseContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

std::vector<MySQLParser::CreateDatabaseOptionContext *> MySQLParser::CreateDatabaseContext::createDatabaseOption() {
  return getRuleContexts<MySQLParser::CreateDatabaseOptionContext>();
}

MySQLParser::CreateDatabaseOptionContext* MySQLParser::CreateDatabaseContext::createDatabaseOption(size_t i) {
  return getRuleContext<MySQLParser::CreateDatabaseOptionContext>(i);
}


size_t MySQLParser::CreateDatabaseContext::getRuleIndex() const {
  return MySQLParser::RuleCreateDatabase;
}

void MySQLParser::CreateDatabaseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateDatabase(this);
}

void MySQLParser::CreateDatabaseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateDatabase(this);
}


std::any MySQLParser::CreateDatabaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateDatabase(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateDatabaseContext* MySQLParser::createDatabase() {
  CreateDatabaseContext *_localctx = _tracker.createInstance<CreateDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 82, MySQLParser::RuleCreateDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2272);
    match(MySQLParser::DATABASE_SYMBOL);
    setState(2274);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx)) {
    case 1: {
      setState(2273);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2276);
    schemaName();
    setState(2280);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2277);
        createDatabaseOption(); 
      }
      setState(2282);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateDatabaseOptionContext ------------------------------------------------------------------

MySQLParser::CreateDatabaseOptionContext::CreateDatabaseOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::DefaultCharsetContext* MySQLParser::CreateDatabaseOptionContext::defaultCharset() {
  return getRuleContext<MySQLParser::DefaultCharsetContext>(0);
}

MySQLParser::DefaultCollationContext* MySQLParser::CreateDatabaseOptionContext::defaultCollation() {
  return getRuleContext<MySQLParser::DefaultCollationContext>(0);
}

MySQLParser::DefaultEncryptionContext* MySQLParser::CreateDatabaseOptionContext::defaultEncryption() {
  return getRuleContext<MySQLParser::DefaultEncryptionContext>(0);
}


size_t MySQLParser::CreateDatabaseOptionContext::getRuleIndex() const {
  return MySQLParser::RuleCreateDatabaseOption;
}

void MySQLParser::CreateDatabaseOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateDatabaseOption(this);
}

void MySQLParser::CreateDatabaseOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateDatabaseOption(this);
}


std::any MySQLParser::CreateDatabaseOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateDatabaseOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateDatabaseOptionContext* MySQLParser::createDatabaseOption() {
  CreateDatabaseOptionContext *_localctx = _tracker.createInstance<CreateDatabaseOptionContext>(_ctx, getState());
  enterRule(_localctx, 84, MySQLParser::RuleCreateDatabaseOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2287);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2283);
      defaultCharset();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2284);
      defaultCollation();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2285);

      if (!(serverVersion >= 80016)) throw FailedPredicateException(this, "serverVersion >= 80016");
      setState(2286);
      defaultEncryption();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTableContext ------------------------------------------------------------------

MySQLParser::CreateTableContext::CreateTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateTableContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableNameContext* MySQLParser::CreateTableContext::tableName() {
  return getRuleContext<MySQLParser::TableNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableContext::LIKE_SYMBOL() {
  return getToken(MySQLParser::LIKE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::CreateTableContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableContext::TEMPORARY_SYMBOL() {
  return getToken(MySQLParser::TEMPORARY_SYMBOL, 0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateTableContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

MySQLParser::TableElementListContext* MySQLParser::CreateTableContext::tableElementList() {
  return getRuleContext<MySQLParser::TableElementListContext>(0);
}

MySQLParser::CreateTableOptionsEtcContext* MySQLParser::CreateTableContext::createTableOptionsEtc() {
  return getRuleContext<MySQLParser::CreateTableOptionsEtcContext>(0);
}


size_t MySQLParser::CreateTableContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTable;
}

void MySQLParser::CreateTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTable(this);
}

void MySQLParser::CreateTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTable(this);
}


std::any MySQLParser::CreateTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTableContext* MySQLParser::createTable() {
  CreateTableContext *_localctx = _tracker.createInstance<CreateTableContext>(_ctx, getState());
  enterRule(_localctx, 86, MySQLParser::RuleCreateTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2290);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::TEMPORARY_SYMBOL) {
      setState(2289);
      match(MySQLParser::TEMPORARY_SYMBOL);
    }
    setState(2292);
    match(MySQLParser::TABLE_SYMBOL);
    setState(2294);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
    case 1: {
      setState(2293);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2296);
    tableName();
    setState(2313);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
    case 1: {
      setState(2301);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx)) {
      case 1: {
        setState(2297);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(2298);
        tableElementList();
        setState(2299);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(2304);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx)) {
      case 1: {
        setState(2303);
        createTableOptionsEtc();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(2306);
      match(MySQLParser::LIKE_SYMBOL);
      setState(2307);
      tableRef();
      break;
    }

    case 3: {
      setState(2308);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(2309);
      match(MySQLParser::LIKE_SYMBOL);
      setState(2310);
      tableRef();
      setState(2311);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableElementListContext ------------------------------------------------------------------

MySQLParser::TableElementListContext::TableElementListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TableElementContext *> MySQLParser::TableElementListContext::tableElement() {
  return getRuleContexts<MySQLParser::TableElementContext>();
}

MySQLParser::TableElementContext* MySQLParser::TableElementListContext::tableElement(size_t i) {
  return getRuleContext<MySQLParser::TableElementContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TableElementListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TableElementListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TableElementListContext::getRuleIndex() const {
  return MySQLParser::RuleTableElementList;
}

void MySQLParser::TableElementListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableElementList(this);
}

void MySQLParser::TableElementListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableElementList(this);
}


std::any MySQLParser::TableElementListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableElementList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableElementListContext* MySQLParser::tableElementList() {
  TableElementListContext *_localctx = _tracker.createInstance<TableElementListContext>(_ctx, getState());
  enterRule(_localctx, 88, MySQLParser::RuleTableElementList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2315);
    tableElement();
    setState(2320);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2316);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2317);
      tableElement();
      setState(2322);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableElementContext ------------------------------------------------------------------

MySQLParser::TableElementContext::TableElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ColumnDefinitionContext* MySQLParser::TableElementContext::columnDefinition() {
  return getRuleContext<MySQLParser::ColumnDefinitionContext>(0);
}

MySQLParser::TableConstraintDefContext* MySQLParser::TableElementContext::tableConstraintDef() {
  return getRuleContext<MySQLParser::TableConstraintDefContext>(0);
}


size_t MySQLParser::TableElementContext::getRuleIndex() const {
  return MySQLParser::RuleTableElement;
}

void MySQLParser::TableElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableElement(this);
}

void MySQLParser::TableElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableElement(this);
}


std::any MySQLParser::TableElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableElement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableElementContext* MySQLParser::tableElement() {
  TableElementContext *_localctx = _tracker.createInstance<TableElementContext>(_ctx, getState());
  enterRule(_localctx, 90, MySQLParser::RuleTableElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2325);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2323);
      columnDefinition();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2324);
      tableConstraintDef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DuplicateAsQeContext ------------------------------------------------------------------

MySQLParser::DuplicateAsQeContext::DuplicateAsQeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AsCreateQueryExpressionContext* MySQLParser::DuplicateAsQeContext::asCreateQueryExpression() {
  return getRuleContext<MySQLParser::AsCreateQueryExpressionContext>(0);
}

tree::TerminalNode* MySQLParser::DuplicateAsQeContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DuplicateAsQeContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}


size_t MySQLParser::DuplicateAsQeContext::getRuleIndex() const {
  return MySQLParser::RuleDuplicateAsQe;
}

void MySQLParser::DuplicateAsQeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDuplicateAsQe(this);
}

void MySQLParser::DuplicateAsQeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDuplicateAsQe(this);
}


std::any MySQLParser::DuplicateAsQeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDuplicateAsQe(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DuplicateAsQeContext* MySQLParser::duplicateAsQe() {
  DuplicateAsQeContext *_localctx = _tracker.createInstance<DuplicateAsQeContext>(_ctx, getState());
  enterRule(_localctx, 92, MySQLParser::RuleDuplicateAsQe);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2328);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx)) {
    case 1: {
      setState(2327);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::REPLACE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
    setState(2330);
    asCreateQueryExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AsCreateQueryExpressionContext ------------------------------------------------------------------

MySQLParser::AsCreateQueryExpressionContext::AsCreateQueryExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionWithOptLockingClausesContext* MySQLParser::AsCreateQueryExpressionContext::queryExpressionWithOptLockingClauses() {
  return getRuleContext<MySQLParser::QueryExpressionWithOptLockingClausesContext>(0);
}

tree::TerminalNode* MySQLParser::AsCreateQueryExpressionContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}


size_t MySQLParser::AsCreateQueryExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleAsCreateQueryExpression;
}

void MySQLParser::AsCreateQueryExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAsCreateQueryExpression(this);
}

void MySQLParser::AsCreateQueryExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAsCreateQueryExpression(this);
}


std::any MySQLParser::AsCreateQueryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAsCreateQueryExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AsCreateQueryExpressionContext* MySQLParser::asCreateQueryExpression() {
  AsCreateQueryExpressionContext *_localctx = _tracker.createInstance<AsCreateQueryExpressionContext>(_ctx, getState());
  enterRule(_localctx, 94, MySQLParser::RuleAsCreateQueryExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2333);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 117, _ctx)) {
    case 1: {
      setState(2332);
      match(MySQLParser::AS_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(2335);
    queryExpressionWithOptLockingClauses();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryExpressionOrParensContext ------------------------------------------------------------------

MySQLParser::QueryExpressionOrParensContext::QueryExpressionOrParensContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionContext* MySQLParser::QueryExpressionOrParensContext::queryExpression() {
  return getRuleContext<MySQLParser::QueryExpressionContext>(0);
}

MySQLParser::LockingClauseListContext* MySQLParser::QueryExpressionOrParensContext::lockingClauseList() {
  return getRuleContext<MySQLParser::LockingClauseListContext>(0);
}

MySQLParser::QueryExpressionParensContext* MySQLParser::QueryExpressionOrParensContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}


size_t MySQLParser::QueryExpressionOrParensContext::getRuleIndex() const {
  return MySQLParser::RuleQueryExpressionOrParens;
}

void MySQLParser::QueryExpressionOrParensContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQueryExpressionOrParens(this);
}

void MySQLParser::QueryExpressionOrParensContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQueryExpressionOrParens(this);
}


std::any MySQLParser::QueryExpressionOrParensContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQueryExpressionOrParens(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryExpressionOrParensContext* MySQLParser::queryExpressionOrParens() {
  QueryExpressionOrParensContext *_localctx = _tracker.createInstance<QueryExpressionOrParensContext>(_ctx, getState());
  enterRule(_localctx, 96, MySQLParser::RuleQueryExpressionOrParens);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2342);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2337);
      queryExpression();
      setState(2339);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 118, _ctx)) {
      case 1: {
        setState(2338);
        lockingClauseList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2341);
      queryExpressionParens();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryExpressionWithOptLockingClausesContext ------------------------------------------------------------------

MySQLParser::QueryExpressionWithOptLockingClausesContext::QueryExpressionWithOptLockingClausesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionContext* MySQLParser::QueryExpressionWithOptLockingClausesContext::queryExpression() {
  return getRuleContext<MySQLParser::QueryExpressionContext>(0);
}

MySQLParser::LockingClauseListContext* MySQLParser::QueryExpressionWithOptLockingClausesContext::lockingClauseList() {
  return getRuleContext<MySQLParser::LockingClauseListContext>(0);
}


size_t MySQLParser::QueryExpressionWithOptLockingClausesContext::getRuleIndex() const {
  return MySQLParser::RuleQueryExpressionWithOptLockingClauses;
}

void MySQLParser::QueryExpressionWithOptLockingClausesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQueryExpressionWithOptLockingClauses(this);
}

void MySQLParser::QueryExpressionWithOptLockingClausesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQueryExpressionWithOptLockingClauses(this);
}


std::any MySQLParser::QueryExpressionWithOptLockingClausesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQueryExpressionWithOptLockingClauses(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryExpressionWithOptLockingClausesContext* MySQLParser::queryExpressionWithOptLockingClauses() {
  QueryExpressionWithOptLockingClausesContext *_localctx = _tracker.createInstance<QueryExpressionWithOptLockingClausesContext>(_ctx, getState());
  enterRule(_localctx, 98, MySQLParser::RuleQueryExpressionWithOptLockingClauses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2344);
    queryExpression();
    setState(2346);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx)) {
    case 1: {
      setState(2345);
      lockingClauseList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateRoutineContext ------------------------------------------------------------------

MySQLParser::CreateRoutineContext::CreateRoutineContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateRoutineContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateRoutineContext::EOF() {
  return getToken(MySQLParser::EOF, 0);
}

MySQLParser::CreateProcedureContext* MySQLParser::CreateRoutineContext::createProcedure() {
  return getRuleContext<MySQLParser::CreateProcedureContext>(0);
}

MySQLParser::CreateFunctionContext* MySQLParser::CreateRoutineContext::createFunction() {
  return getRuleContext<MySQLParser::CreateFunctionContext>(0);
}

MySQLParser::CreateUdfContext* MySQLParser::CreateRoutineContext::createUdf() {
  return getRuleContext<MySQLParser::CreateUdfContext>(0);
}

tree::TerminalNode* MySQLParser::CreateRoutineContext::SEMICOLON_SYMBOL() {
  return getToken(MySQLParser::SEMICOLON_SYMBOL, 0);
}


size_t MySQLParser::CreateRoutineContext::getRuleIndex() const {
  return MySQLParser::RuleCreateRoutine;
}

void MySQLParser::CreateRoutineContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateRoutine(this);
}

void MySQLParser::CreateRoutineContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateRoutine(this);
}


std::any MySQLParser::CreateRoutineContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateRoutine(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateRoutineContext* MySQLParser::createRoutine() {
  CreateRoutineContext *_localctx = _tracker.createInstance<CreateRoutineContext>(_ctx, getState());
  enterRule(_localctx, 100, MySQLParser::RuleCreateRoutine);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2348);
    match(MySQLParser::CREATE_SYMBOL);
    setState(2352);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 121, _ctx)) {
    case 1: {
      setState(2349);
      createProcedure();
      break;
    }

    case 2: {
      setState(2350);
      createFunction();
      break;
    }

    case 3: {
      setState(2351);
      createUdf();
      break;
    }

    default:
      break;
    }
    setState(2355);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SEMICOLON_SYMBOL) {
      setState(2354);
      match(MySQLParser::SEMICOLON_SYMBOL);
    }
    setState(2357);
    match(MySQLParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateProcedureContext ------------------------------------------------------------------

MySQLParser::CreateProcedureContext::CreateProcedureContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateProcedureContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

MySQLParser::ProcedureNameContext* MySQLParser::CreateProcedureContext::procedureName() {
  return getRuleContext<MySQLParser::ProcedureNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateProcedureContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateProcedureContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::StoredRoutineBodyContext* MySQLParser::CreateProcedureContext::storedRoutineBody() {
  return getRuleContext<MySQLParser::StoredRoutineBodyContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateProcedureContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateProcedureContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

std::vector<MySQLParser::ProcedureParameterContext *> MySQLParser::CreateProcedureContext::procedureParameter() {
  return getRuleContexts<MySQLParser::ProcedureParameterContext>();
}

MySQLParser::ProcedureParameterContext* MySQLParser::CreateProcedureContext::procedureParameter(size_t i) {
  return getRuleContext<MySQLParser::ProcedureParameterContext>(i);
}

std::vector<MySQLParser::RoutineCreateOptionContext *> MySQLParser::CreateProcedureContext::routineCreateOption() {
  return getRuleContexts<MySQLParser::RoutineCreateOptionContext>();
}

MySQLParser::RoutineCreateOptionContext* MySQLParser::CreateProcedureContext::routineCreateOption(size_t i) {
  return getRuleContext<MySQLParser::RoutineCreateOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::CreateProcedureContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::CreateProcedureContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::CreateProcedureContext::getRuleIndex() const {
  return MySQLParser::RuleCreateProcedure;
}

void MySQLParser::CreateProcedureContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateProcedure(this);
}

void MySQLParser::CreateProcedureContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateProcedure(this);
}


std::any MySQLParser::CreateProcedureContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateProcedure(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateProcedureContext* MySQLParser::createProcedure() {
  CreateProcedureContext *_localctx = _tracker.createInstance<CreateProcedureContext>(_ctx, getState());
  enterRule(_localctx, 102, MySQLParser::RuleCreateProcedure);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2360);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2359);
      definerClause();
    }
    setState(2362);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(2365);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
    case 1: {
      setState(2363);

      if (!(serverVersion >= 80029)) throw FailedPredicateException(this, "serverVersion >= 80029");
      setState(2364);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2367);
    procedureName();
    setState(2368);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(2377);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 126, _ctx)) {
    case 1: {
      setState(2369);
      procedureParameter();
      setState(2374);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(2370);
        match(MySQLParser::COMMA_SYMBOL);
        setState(2371);
        procedureParameter();
        setState(2376);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
    setState(2379);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(2383);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2380);
        routineCreateOption(); 
      }
      setState(2385);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx);
    }
    setState(2386);
    storedRoutineBody();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoutineStringContext ------------------------------------------------------------------

MySQLParser::RoutineStringContext::RoutineStringContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringLiteralContext* MySQLParser::RoutineStringContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::RoutineStringContext::DOLLAR_QUOTED_STRING_TEXT() {
  return getToken(MySQLParser::DOLLAR_QUOTED_STRING_TEXT, 0);
}


size_t MySQLParser::RoutineStringContext::getRuleIndex() const {
  return MySQLParser::RuleRoutineString;
}

void MySQLParser::RoutineStringContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoutineString(this);
}

void MySQLParser::RoutineStringContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoutineString(this);
}


std::any MySQLParser::RoutineStringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoutineString(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoutineStringContext* MySQLParser::routineString() {
  RoutineStringContext *_localctx = _tracker.createInstance<RoutineStringContext>(_ctx, getState());
  enterRule(_localctx, 104, MySQLParser::RuleRoutineString);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2390);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2388);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2389);
      match(MySQLParser::DOLLAR_QUOTED_STRING_TEXT);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StoredRoutineBodyContext ------------------------------------------------------------------

MySQLParser::StoredRoutineBodyContext::StoredRoutineBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CompoundStatementContext* MySQLParser::StoredRoutineBodyContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

tree::TerminalNode* MySQLParser::StoredRoutineBodyContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::RoutineStringContext* MySQLParser::StoredRoutineBodyContext::routineString() {
  return getRuleContext<MySQLParser::RoutineStringContext>(0);
}


size_t MySQLParser::StoredRoutineBodyContext::getRuleIndex() const {
  return MySQLParser::RuleStoredRoutineBody;
}

void MySQLParser::StoredRoutineBodyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStoredRoutineBody(this);
}

void MySQLParser::StoredRoutineBodyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStoredRoutineBody(this);
}


std::any MySQLParser::StoredRoutineBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStoredRoutineBody(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StoredRoutineBodyContext* MySQLParser::storedRoutineBody() {
  StoredRoutineBodyContext *_localctx = _tracker.createInstance<StoredRoutineBodyContext>(_ctx, getState());
  enterRule(_localctx, 106, MySQLParser::RuleStoredRoutineBody);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2396);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2392);
      compoundStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2393);

      if (!(serverVersion >= 80032 && supportMle)) throw FailedPredicateException(this, "serverVersion >= 80032 && supportMle");
      setState(2394);
      match(MySQLParser::AS_SYMBOL);
      setState(2395);
      routineString();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateFunctionContext ------------------------------------------------------------------

MySQLParser::CreateFunctionContext::CreateFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateFunctionContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

MySQLParser::FunctionNameContext* MySQLParser::CreateFunctionContext::functionName() {
  return getRuleContext<MySQLParser::FunctionNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateFunctionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateFunctionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateFunctionContext::RETURNS_SYMBOL() {
  return getToken(MySQLParser::RETURNS_SYMBOL, 0);
}

MySQLParser::TypeWithOptCollateContext* MySQLParser::CreateFunctionContext::typeWithOptCollate() {
  return getRuleContext<MySQLParser::TypeWithOptCollateContext>(0);
}

MySQLParser::StoredRoutineBodyContext* MySQLParser::CreateFunctionContext::storedRoutineBody() {
  return getRuleContext<MySQLParser::StoredRoutineBodyContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateFunctionContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateFunctionContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

std::vector<MySQLParser::FunctionParameterContext *> MySQLParser::CreateFunctionContext::functionParameter() {
  return getRuleContexts<MySQLParser::FunctionParameterContext>();
}

MySQLParser::FunctionParameterContext* MySQLParser::CreateFunctionContext::functionParameter(size_t i) {
  return getRuleContext<MySQLParser::FunctionParameterContext>(i);
}

std::vector<MySQLParser::RoutineCreateOptionContext *> MySQLParser::CreateFunctionContext::routineCreateOption() {
  return getRuleContexts<MySQLParser::RoutineCreateOptionContext>();
}

MySQLParser::RoutineCreateOptionContext* MySQLParser::CreateFunctionContext::routineCreateOption(size_t i) {
  return getRuleContext<MySQLParser::RoutineCreateOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::CreateFunctionContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::CreateFunctionContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::CreateFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleCreateFunction;
}

void MySQLParser::CreateFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateFunction(this);
}

void MySQLParser::CreateFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateFunction(this);
}


std::any MySQLParser::CreateFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateFunctionContext* MySQLParser::createFunction() {
  CreateFunctionContext *_localctx = _tracker.createInstance<CreateFunctionContext>(_ctx, getState());
  enterRule(_localctx, 108, MySQLParser::RuleCreateFunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2399);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2398);
      definerClause();
    }
    setState(2401);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(2404);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 131, _ctx)) {
    case 1: {
      setState(2402);

      if (!(serverVersion >= 80029)) throw FailedPredicateException(this, "serverVersion >= 80029");
      setState(2403);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2406);
    functionName();
    setState(2407);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(2416);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx)) {
    case 1: {
      setState(2408);
      functionParameter();
      setState(2413);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(2409);
        match(MySQLParser::COMMA_SYMBOL);
        setState(2410);
        functionParameter();
        setState(2415);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
    setState(2418);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(2419);
    match(MySQLParser::RETURNS_SYMBOL);
    setState(2420);
    typeWithOptCollate();
    setState(2424);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2421);
        routineCreateOption(); 
      }
      setState(2426);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx);
    }
    setState(2427);
    storedRoutineBody();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUdfContext ------------------------------------------------------------------

MySQLParser::CreateUdfContext::CreateUdfContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateUdfContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

MySQLParser::UdfNameContext* MySQLParser::CreateUdfContext::udfName() {
  return getRuleContext<MySQLParser::UdfNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::RETURNS_SYMBOL() {
  return getToken(MySQLParser::RETURNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::SONAME_SYMBOL() {
  return getToken(MySQLParser::SONAME_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::CreateUdfContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::STRING_SYMBOL() {
  return getToken(MySQLParser::STRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::INT_SYMBOL() {
  return getToken(MySQLParser::INT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::REAL_SYMBOL() {
  return getToken(MySQLParser::REAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::DECIMAL_SYMBOL() {
  return getToken(MySQLParser::DECIMAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUdfContext::AGGREGATE_SYMBOL() {
  return getToken(MySQLParser::AGGREGATE_SYMBOL, 0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateUdfContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::CreateUdfContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUdf;
}

void MySQLParser::CreateUdfContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUdf(this);
}

void MySQLParser::CreateUdfContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUdf(this);
}


std::any MySQLParser::CreateUdfContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUdf(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUdfContext* MySQLParser::createUdf() {
  CreateUdfContext *_localctx = _tracker.createInstance<CreateUdfContext>(_ctx, getState());
  enterRule(_localctx, 110, MySQLParser::RuleCreateUdf);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2430);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::AGGREGATE_SYMBOL) {
      setState(2429);
      match(MySQLParser::AGGREGATE_SYMBOL);
    }
    setState(2432);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(2435);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 136, _ctx)) {
    case 1: {
      setState(2433);

      if (!(serverVersion >= 80029)) throw FailedPredicateException(this, "serverVersion >= 80029");
      setState(2434);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2437);
    udfName();
    setState(2438);
    match(MySQLParser::RETURNS_SYMBOL);
    setState(2439);
    antlrcpp::downCast<CreateUdfContext *>(_localctx)->type = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DECIMAL_SYMBOL || _la == MySQLParser::INT_SYMBOL || _la == MySQLParser::REAL_SYMBOL || _la == MySQLParser::STRING_SYMBOL)) {
      antlrcpp::downCast<CreateUdfContext *>(_localctx)->type = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2440);
    match(MySQLParser::SONAME_SYMBOL);
    setState(2441);
    textLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoutineCreateOptionContext ------------------------------------------------------------------

MySQLParser::RoutineCreateOptionContext::RoutineCreateOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoutineOptionContext* MySQLParser::RoutineCreateOptionContext::routineOption() {
  return getRuleContext<MySQLParser::RoutineOptionContext>(0);
}

tree::TerminalNode* MySQLParser::RoutineCreateOptionContext::DETERMINISTIC_SYMBOL() {
  return getToken(MySQLParser::DETERMINISTIC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineCreateOptionContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineCreateOptionContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineCreateOptionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::LibraryListContext* MySQLParser::RoutineCreateOptionContext::libraryList() {
  return getRuleContext<MySQLParser::LibraryListContext>(0);
}

tree::TerminalNode* MySQLParser::RoutineCreateOptionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::RoutineCreateOptionContext::getRuleIndex() const {
  return MySQLParser::RuleRoutineCreateOption;
}

void MySQLParser::RoutineCreateOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoutineCreateOption(this);
}

void MySQLParser::RoutineCreateOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoutineCreateOption(this);
}


std::any MySQLParser::RoutineCreateOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoutineCreateOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoutineCreateOptionContext* MySQLParser::routineCreateOption() {
  RoutineCreateOptionContext *_localctx = _tracker.createInstance<RoutineCreateOptionContext>(_ctx, getState());
  enterRule(_localctx, 112, MySQLParser::RuleRoutineCreateOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2454);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2443);
      routineOption();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2445);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(2444);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(2447);
      match(MySQLParser::DETERMINISTIC_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2448);

      if (!(serverVersion >= 90200)) throw FailedPredicateException(this, "serverVersion >= 90200");
      setState(2449);
      match(MySQLParser::USING_SYMBOL);
      setState(2450);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(2451);
      libraryList();
      setState(2452);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LibraryListContext ------------------------------------------------------------------

MySQLParser::LibraryListContext::LibraryListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::LibraryNameWithAliasContext *> MySQLParser::LibraryListContext::libraryNameWithAlias() {
  return getRuleContexts<MySQLParser::LibraryNameWithAliasContext>();
}

MySQLParser::LibraryNameWithAliasContext* MySQLParser::LibraryListContext::libraryNameWithAlias(size_t i) {
  return getRuleContext<MySQLParser::LibraryNameWithAliasContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::LibraryListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::LibraryListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::LibraryListContext::getRuleIndex() const {
  return MySQLParser::RuleLibraryList;
}

void MySQLParser::LibraryListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLibraryList(this);
}

void MySQLParser::LibraryListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLibraryList(this);
}


std::any MySQLParser::LibraryListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLibraryList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LibraryListContext* MySQLParser::libraryList() {
  LibraryListContext *_localctx = _tracker.createInstance<LibraryListContext>(_ctx, getState());
  enterRule(_localctx, 114, MySQLParser::RuleLibraryList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2456);
    libraryNameWithAlias();
    setState(2461);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2457);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2458);
      libraryNameWithAlias();
      setState(2463);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LibraryNameWithAliasContext ------------------------------------------------------------------

MySQLParser::LibraryNameWithAliasContext::LibraryNameWithAliasContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LibraryNameContext* MySQLParser::LibraryNameWithAliasContext::libraryName() {
  return getRuleContext<MySQLParser::LibraryNameContext>(0);
}

MySQLParser::IdentifierContext* MySQLParser::LibraryNameWithAliasContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::LibraryNameWithAliasContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}


size_t MySQLParser::LibraryNameWithAliasContext::getRuleIndex() const {
  return MySQLParser::RuleLibraryNameWithAlias;
}

void MySQLParser::LibraryNameWithAliasContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLibraryNameWithAlias(this);
}

void MySQLParser::LibraryNameWithAliasContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLibraryNameWithAlias(this);
}


std::any MySQLParser::LibraryNameWithAliasContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLibraryNameWithAlias(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LibraryNameWithAliasContext* MySQLParser::libraryNameWithAlias() {
  LibraryNameWithAliasContext *_localctx = _tracker.createInstance<LibraryNameWithAliasContext>(_ctx, getState());
  enterRule(_localctx, 116, MySQLParser::RuleLibraryNameWithAlias);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2464);
    libraryName();
    setState(2469);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx)) {
    case 1: {
      setState(2466);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx)) {
      case 1: {
        setState(2465);
        match(MySQLParser::AS_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(2468);
      identifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoutineAlterOptionsContext ------------------------------------------------------------------

MySQLParser::RoutineAlterOptionsContext::RoutineAlterOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::RoutineOptionContext *> MySQLParser::RoutineAlterOptionsContext::routineOption() {
  return getRuleContexts<MySQLParser::RoutineOptionContext>();
}

MySQLParser::RoutineOptionContext* MySQLParser::RoutineAlterOptionsContext::routineOption(size_t i) {
  return getRuleContext<MySQLParser::RoutineOptionContext>(i);
}


size_t MySQLParser::RoutineAlterOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleRoutineAlterOptions;
}

void MySQLParser::RoutineAlterOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoutineAlterOptions(this);
}

void MySQLParser::RoutineAlterOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoutineAlterOptions(this);
}


std::any MySQLParser::RoutineAlterOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoutineAlterOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoutineAlterOptionsContext* MySQLParser::routineAlterOptions() {
  RoutineAlterOptionsContext *_localctx = _tracker.createInstance<RoutineAlterOptionsContext>(_ctx, getState());
  enterRule(_localctx, 118, MySQLParser::RuleRoutineAlterOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2472); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(2471);
      routineOption();
      setState(2474); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == MySQLParser::COMMENT_SYMBOL

    || _la == MySQLParser::CONTAINS_SYMBOL || _la == MySQLParser::LANGUAGE_SYMBOL || _la == MySQLParser::MODIFIES_SYMBOL

    || _la == MySQLParser::NO_SYMBOL || _la == MySQLParser::READS_SYMBOL || _la == MySQLParser::SQL_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoutineOptionContext ------------------------------------------------------------------

MySQLParser::RoutineOptionContext::RoutineOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextLiteralContext* MySQLParser::RoutineOptionContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::LANGUAGE_SYMBOL() {
  return getToken(MySQLParser::LANGUAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::SQL_SYMBOL() {
  return getToken(MySQLParser::SQL_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::RoutineOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::CONTAINS_SYMBOL() {
  return getToken(MySQLParser::CONTAINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::READS_SYMBOL() {
  return getToken(MySQLParser::READS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::MODIFIES_SYMBOL() {
  return getToken(MySQLParser::MODIFIES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::SECURITY_SYMBOL() {
  return getToken(MySQLParser::SECURITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::DEFINER_SYMBOL() {
  return getToken(MySQLParser::DEFINER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::INVOKER_SYMBOL() {
  return getToken(MySQLParser::INVOKER_SYMBOL, 0);
}


size_t MySQLParser::RoutineOptionContext::getRuleIndex() const {
  return MySQLParser::RuleRoutineOption;
}

void MySQLParser::RoutineOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoutineOption(this);
}

void MySQLParser::RoutineOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoutineOption(this);
}


std::any MySQLParser::RoutineOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoutineOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoutineOptionContext* MySQLParser::routineOption() {
  RoutineOptionContext *_localctx = _tracker.createInstance<RoutineOptionContext>(_ctx, getState());
  enterRule(_localctx, 120, MySQLParser::RuleRoutineOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2497);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2476);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::COMMENT_SYMBOL);
        setState(2477);
        textLiteral();
        break;
      }

      case MySQLParser::LANGUAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2478);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::LANGUAGE_SYMBOL);
        setState(2482);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 143, _ctx)) {
        case 1: {
          setState(2479);
          match(MySQLParser::SQL_SYMBOL);
          break;
        }

        case 2: {
          setState(2480);

          if (!(serverVersion >= 80032)) throw FailedPredicateException(this, "serverVersion >= 80032");
          setState(2481);
          identifier();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::NO_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2484);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::NO_SYMBOL);
        setState(2485);
        match(MySQLParser::SQL_SYMBOL);
        break;
      }

      case MySQLParser::CONTAINS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2486);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::CONTAINS_SYMBOL);
        setState(2487);
        match(MySQLParser::SQL_SYMBOL);
        break;
      }

      case MySQLParser::READS_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(2488);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::READS_SYMBOL);
        setState(2489);
        match(MySQLParser::SQL_SYMBOL);
        setState(2490);
        match(MySQLParser::DATA_SYMBOL);
        break;
      }

      case MySQLParser::MODIFIES_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(2491);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::MODIFIES_SYMBOL);
        setState(2492);
        match(MySQLParser::SQL_SYMBOL);
        setState(2493);
        match(MySQLParser::DATA_SYMBOL);
        break;
      }

      case MySQLParser::SQL_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(2494);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::SQL_SYMBOL);
        setState(2495);
        match(MySQLParser::SECURITY_SYMBOL);
        setState(2496);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->security = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::DEFINER_SYMBOL || _la == MySQLParser::INVOKER_SYMBOL)) {
          antlrcpp::downCast<RoutineOptionContext *>(_localctx)->security = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateIndexContext ------------------------------------------------------------------

MySQLParser::CreateIndexContext::CreateIndexContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IndexNameContext* MySQLParser::CreateIndexContext::indexName() {
  return getRuleContext<MySQLParser::IndexNameContext>(0);
}

MySQLParser::CreateIndexTargetContext* MySQLParser::CreateIndexContext::createIndexTarget() {
  return getRuleContext<MySQLParser::CreateIndexTargetContext>(0);
}

tree::TerminalNode* MySQLParser::CreateIndexContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

MySQLParser::OnlineOptionContext* MySQLParser::CreateIndexContext::onlineOption() {
  return getRuleContext<MySQLParser::OnlineOptionContext>(0);
}

tree::TerminalNode* MySQLParser::CreateIndexContext::FULLTEXT_SYMBOL() {
  return getToken(MySQLParser::FULLTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateIndexContext::SPATIAL_SYMBOL() {
  return getToken(MySQLParser::SPATIAL_SYMBOL, 0);
}

MySQLParser::IndexLockAndAlgorithmContext* MySQLParser::CreateIndexContext::indexLockAndAlgorithm() {
  return getRuleContext<MySQLParser::IndexLockAndAlgorithmContext>(0);
}

tree::TerminalNode* MySQLParser::CreateIndexContext::UNIQUE_SYMBOL() {
  return getToken(MySQLParser::UNIQUE_SYMBOL, 0);
}

MySQLParser::IndexTypeClauseContext* MySQLParser::CreateIndexContext::indexTypeClause() {
  return getRuleContext<MySQLParser::IndexTypeClauseContext>(0);
}

std::vector<MySQLParser::IndexOptionContext *> MySQLParser::CreateIndexContext::indexOption() {
  return getRuleContexts<MySQLParser::IndexOptionContext>();
}

MySQLParser::IndexOptionContext* MySQLParser::CreateIndexContext::indexOption(size_t i) {
  return getRuleContext<MySQLParser::IndexOptionContext>(i);
}

std::vector<MySQLParser::FulltextIndexOptionContext *> MySQLParser::CreateIndexContext::fulltextIndexOption() {
  return getRuleContexts<MySQLParser::FulltextIndexOptionContext>();
}

MySQLParser::FulltextIndexOptionContext* MySQLParser::CreateIndexContext::fulltextIndexOption(size_t i) {
  return getRuleContext<MySQLParser::FulltextIndexOptionContext>(i);
}

std::vector<MySQLParser::SpatialIndexOptionContext *> MySQLParser::CreateIndexContext::spatialIndexOption() {
  return getRuleContexts<MySQLParser::SpatialIndexOptionContext>();
}

MySQLParser::SpatialIndexOptionContext* MySQLParser::CreateIndexContext::spatialIndexOption(size_t i) {
  return getRuleContext<MySQLParser::SpatialIndexOptionContext>(i);
}


size_t MySQLParser::CreateIndexContext::getRuleIndex() const {
  return MySQLParser::RuleCreateIndex;
}

void MySQLParser::CreateIndexContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateIndex(this);
}

void MySQLParser::CreateIndexContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateIndex(this);
}


std::any MySQLParser::CreateIndexContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateIndex(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateIndexContext* MySQLParser::createIndex() {
  CreateIndexContext *_localctx = _tracker.createInstance<CreateIndexContext>(_ctx, getState());
  enterRule(_localctx, 122, MySQLParser::RuleCreateIndex);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2500);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OFFLINE_SYMBOL

    || _la == MySQLParser::ONLINE_SYMBOL) {
      setState(2499);
      onlineOption();
    }
    setState(2537);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INDEX_SYMBOL:
      case MySQLParser::UNIQUE_SYMBOL: {
        setState(2503);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::UNIQUE_SYMBOL) {
          setState(2502);
          match(MySQLParser::UNIQUE_SYMBOL);
        }
        setState(2505);
        antlrcpp::downCast<CreateIndexContext *>(_localctx)->type = match(MySQLParser::INDEX_SYMBOL);
        setState(2506);
        indexName();
        setState(2508);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::TYPE_SYMBOL

        || _la == MySQLParser::USING_SYMBOL) {
          setState(2507);
          indexTypeClause();
        }
        setState(2510);
        createIndexTarget();
        setState(2514);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 148, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2511);
            indexOption(); 
          }
          setState(2516);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 148, _ctx);
        }
        break;
      }

      case MySQLParser::FULLTEXT_SYMBOL: {
        setState(2517);
        antlrcpp::downCast<CreateIndexContext *>(_localctx)->type = match(MySQLParser::FULLTEXT_SYMBOL);
        setState(2518);
        match(MySQLParser::INDEX_SYMBOL);
        setState(2519);
        indexName();
        setState(2520);
        createIndexTarget();
        setState(2524);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 149, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2521);
            fulltextIndexOption(); 
          }
          setState(2526);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 149, _ctx);
        }
        break;
      }

      case MySQLParser::SPATIAL_SYMBOL: {
        setState(2527);
        antlrcpp::downCast<CreateIndexContext *>(_localctx)->type = match(MySQLParser::SPATIAL_SYMBOL);
        setState(2528);
        match(MySQLParser::INDEX_SYMBOL);
        setState(2529);
        indexName();
        setState(2530);
        createIndexTarget();
        setState(2534);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2531);
            spatialIndexOption(); 
          }
          setState(2536);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 150, _ctx);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2540);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
      setState(2539);
      indexLockAndAlgorithm();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexNameAndTypeContext ------------------------------------------------------------------

MySQLParser::IndexNameAndTypeContext::IndexNameAndTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IndexNameContext* MySQLParser::IndexNameAndTypeContext::indexName() {
  return getRuleContext<MySQLParser::IndexNameContext>(0);
}

tree::TerminalNode* MySQLParser::IndexNameAndTypeContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::IndexTypeContext* MySQLParser::IndexNameAndTypeContext::indexType() {
  return getRuleContext<MySQLParser::IndexTypeContext>(0);
}

tree::TerminalNode* MySQLParser::IndexNameAndTypeContext::TYPE_SYMBOL() {
  return getToken(MySQLParser::TYPE_SYMBOL, 0);
}


size_t MySQLParser::IndexNameAndTypeContext::getRuleIndex() const {
  return MySQLParser::RuleIndexNameAndType;
}

void MySQLParser::IndexNameAndTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexNameAndType(this);
}

void MySQLParser::IndexNameAndTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexNameAndType(this);
}


std::any MySQLParser::IndexNameAndTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexNameAndType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexNameAndTypeContext* MySQLParser::indexNameAndType() {
  IndexNameAndTypeContext *_localctx = _tracker.createInstance<IndexNameAndTypeContext>(_ctx, getState());
  enterRule(_localctx, 124, MySQLParser::RuleIndexNameAndType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2552);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2542);
      indexName();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2544);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx)) {
      case 1: {
        setState(2543);
        indexName();
        break;
      }

      default:
        break;
      }
      setState(2546);
      match(MySQLParser::USING_SYMBOL);
      setState(2547);
      indexType();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2548);
      indexName();
      setState(2549);
      match(MySQLParser::TYPE_SYMBOL);
      setState(2550);
      indexType();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateIndexTargetContext ------------------------------------------------------------------

MySQLParser::CreateIndexTargetContext::CreateIndexTargetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateIndexTargetContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::CreateIndexTargetContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::KeyListWithExpressionContext* MySQLParser::CreateIndexTargetContext::keyListWithExpression() {
  return getRuleContext<MySQLParser::KeyListWithExpressionContext>(0);
}


size_t MySQLParser::CreateIndexTargetContext::getRuleIndex() const {
  return MySQLParser::RuleCreateIndexTarget;
}

void MySQLParser::CreateIndexTargetContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateIndexTarget(this);
}

void MySQLParser::CreateIndexTargetContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateIndexTarget(this);
}


std::any MySQLParser::CreateIndexTargetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateIndexTarget(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateIndexTargetContext* MySQLParser::createIndexTarget() {
  CreateIndexTargetContext *_localctx = _tracker.createInstance<CreateIndexTargetContext>(_ctx, getState());
  enterRule(_localctx, 126, MySQLParser::RuleCreateIndexTarget);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2554);
    match(MySQLParser::ON_SYMBOL);
    setState(2555);
    tableRef();
    setState(2556);
    keyListWithExpression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateLogfileGroupContext ------------------------------------------------------------------

MySQLParser::CreateLogfileGroupContext::CreateLogfileGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateLogfileGroupContext::LOGFILE_SYMBOL() {
  return getToken(MySQLParser::LOGFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateLogfileGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::LogfileGroupNameContext* MySQLParser::CreateLogfileGroupContext::logfileGroupName() {
  return getRuleContext<MySQLParser::LogfileGroupNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateLogfileGroupContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateLogfileGroupContext::UNDOFILE_SYMBOL() {
  return getToken(MySQLParser::UNDOFILE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::CreateLogfileGroupContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::LogfileGroupOptionsContext* MySQLParser::CreateLogfileGroupContext::logfileGroupOptions() {
  return getRuleContext<MySQLParser::LogfileGroupOptionsContext>(0);
}


size_t MySQLParser::CreateLogfileGroupContext::getRuleIndex() const {
  return MySQLParser::RuleCreateLogfileGroup;
}

void MySQLParser::CreateLogfileGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateLogfileGroup(this);
}

void MySQLParser::CreateLogfileGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateLogfileGroup(this);
}


std::any MySQLParser::CreateLogfileGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateLogfileGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateLogfileGroupContext* MySQLParser::createLogfileGroup() {
  CreateLogfileGroupContext *_localctx = _tracker.createInstance<CreateLogfileGroupContext>(_ctx, getState());
  enterRule(_localctx, 128, MySQLParser::RuleCreateLogfileGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2558);
    match(MySQLParser::LOGFILE_SYMBOL);
    setState(2559);
    match(MySQLParser::GROUP_SYMBOL);
    setState(2560);
    logfileGroupName();
    setState(2561);
    match(MySQLParser::ADD_SYMBOL);
    setState(2562);
    match(MySQLParser::UNDOFILE_SYMBOL);
    setState(2563);
    textLiteral();
    setState(2565);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMENT_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::NODEGROUP_SYMBOL

    || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::REDO_BUFFER_SIZE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL

    || _la == MySQLParser::UNDO_BUFFER_SIZE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
      setState(2564);
      logfileGroupOptions();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogfileGroupOptionsContext ------------------------------------------------------------------

MySQLParser::LogfileGroupOptionsContext::LogfileGroupOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::LogfileGroupOptionContext *> MySQLParser::LogfileGroupOptionsContext::logfileGroupOption() {
  return getRuleContexts<MySQLParser::LogfileGroupOptionContext>();
}

MySQLParser::LogfileGroupOptionContext* MySQLParser::LogfileGroupOptionsContext::logfileGroupOption(size_t i) {
  return getRuleContext<MySQLParser::LogfileGroupOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::LogfileGroupOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::LogfileGroupOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::LogfileGroupOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleLogfileGroupOptions;
}

void MySQLParser::LogfileGroupOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLogfileGroupOptions(this);
}

void MySQLParser::LogfileGroupOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLogfileGroupOptions(this);
}


std::any MySQLParser::LogfileGroupOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLogfileGroupOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LogfileGroupOptionsContext* MySQLParser::logfileGroupOptions() {
  LogfileGroupOptionsContext *_localctx = _tracker.createInstance<LogfileGroupOptionsContext>(_ctx, getState());
  enterRule(_localctx, 130, MySQLParser::RuleLogfileGroupOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2567);
    logfileGroupOption();
    setState(2574);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL || _la == MySQLParser::COMMENT_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::NODEGROUP_SYMBOL

    || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::REDO_BUFFER_SIZE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL

    || _la == MySQLParser::UNDO_BUFFER_SIZE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
      setState(2569);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(2568);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(2571);
      logfileGroupOption();
      setState(2576);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogfileGroupOptionContext ------------------------------------------------------------------

MySQLParser::LogfileGroupOptionContext::LogfileGroupOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TsOptionInitialSizeContext* MySQLParser::LogfileGroupOptionContext::tsOptionInitialSize() {
  return getRuleContext<MySQLParser::TsOptionInitialSizeContext>(0);
}

MySQLParser::TsOptionUndoRedoBufferSizeContext* MySQLParser::LogfileGroupOptionContext::tsOptionUndoRedoBufferSize() {
  return getRuleContext<MySQLParser::TsOptionUndoRedoBufferSizeContext>(0);
}

MySQLParser::TsOptionNodegroupContext* MySQLParser::LogfileGroupOptionContext::tsOptionNodegroup() {
  return getRuleContext<MySQLParser::TsOptionNodegroupContext>(0);
}

MySQLParser::TsOptionEngineContext* MySQLParser::LogfileGroupOptionContext::tsOptionEngine() {
  return getRuleContext<MySQLParser::TsOptionEngineContext>(0);
}

MySQLParser::TsOptionWaitContext* MySQLParser::LogfileGroupOptionContext::tsOptionWait() {
  return getRuleContext<MySQLParser::TsOptionWaitContext>(0);
}

MySQLParser::TsOptionCommentContext* MySQLParser::LogfileGroupOptionContext::tsOptionComment() {
  return getRuleContext<MySQLParser::TsOptionCommentContext>(0);
}


size_t MySQLParser::LogfileGroupOptionContext::getRuleIndex() const {
  return MySQLParser::RuleLogfileGroupOption;
}

void MySQLParser::LogfileGroupOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLogfileGroupOption(this);
}

void MySQLParser::LogfileGroupOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLogfileGroupOption(this);
}


std::any MySQLParser::LogfileGroupOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLogfileGroupOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LogfileGroupOptionContext* MySQLParser::logfileGroupOption() {
  LogfileGroupOptionContext *_localctx = _tracker.createInstance<LogfileGroupOptionContext>(_ctx, getState());
  enterRule(_localctx, 132, MySQLParser::RuleLogfileGroupOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2583);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INITIAL_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2577);
        tsOptionInitialSize();
        break;
      }

      case MySQLParser::REDO_BUFFER_SIZE_SYMBOL:
      case MySQLParser::UNDO_BUFFER_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2578);
        tsOptionUndoRedoBufferSize();
        break;
      }

      case MySQLParser::NODEGROUP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2579);
        tsOptionNodegroup();
        break;
      }

      case MySQLParser::ENGINE_SYMBOL:
      case MySQLParser::STORAGE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2580);
        tsOptionEngine();
        break;
      }

      case MySQLParser::NO_WAIT_SYMBOL:
      case MySQLParser::WAIT_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(2581);
        tsOptionWait();
        break;
      }

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(2582);
        tsOptionComment();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateServerContext ------------------------------------------------------------------

MySQLParser::CreateServerContext::CreateServerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateServerContext::SERVER_SYMBOL() {
  return getToken(MySQLParser::SERVER_SYMBOL, 0);
}

MySQLParser::ServerNameContext* MySQLParser::CreateServerContext::serverName() {
  return getRuleContext<MySQLParser::ServerNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateServerContext::FOREIGN_SYMBOL() {
  return getToken(MySQLParser::FOREIGN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateServerContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateServerContext::WRAPPER_SYMBOL() {
  return getToken(MySQLParser::WRAPPER_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::CreateServerContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::ServerOptionsContext* MySQLParser::CreateServerContext::serverOptions() {
  return getRuleContext<MySQLParser::ServerOptionsContext>(0);
}


size_t MySQLParser::CreateServerContext::getRuleIndex() const {
  return MySQLParser::RuleCreateServer;
}

void MySQLParser::CreateServerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateServer(this);
}

void MySQLParser::CreateServerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateServer(this);
}


std::any MySQLParser::CreateServerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateServer(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateServerContext* MySQLParser::createServer() {
  CreateServerContext *_localctx = _tracker.createInstance<CreateServerContext>(_ctx, getState());
  enterRule(_localctx, 134, MySQLParser::RuleCreateServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2585);
    match(MySQLParser::SERVER_SYMBOL);
    setState(2586);
    serverName();
    setState(2587);
    match(MySQLParser::FOREIGN_SYMBOL);
    setState(2588);
    match(MySQLParser::DATA_SYMBOL);
    setState(2589);
    match(MySQLParser::WRAPPER_SYMBOL);
    setState(2590);
    textOrIdentifier();
    setState(2591);
    serverOptions();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ServerOptionsContext ------------------------------------------------------------------

MySQLParser::ServerOptionsContext::ServerOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ServerOptionsContext::OPTIONS_SYMBOL() {
  return getToken(MySQLParser::OPTIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerOptionsContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::ServerOptionContext *> MySQLParser::ServerOptionsContext::serverOption() {
  return getRuleContexts<MySQLParser::ServerOptionContext>();
}

MySQLParser::ServerOptionContext* MySQLParser::ServerOptionsContext::serverOption(size_t i) {
  return getRuleContext<MySQLParser::ServerOptionContext>(i);
}

tree::TerminalNode* MySQLParser::ServerOptionsContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ServerOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ServerOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ServerOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleServerOptions;
}

void MySQLParser::ServerOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterServerOptions(this);
}

void MySQLParser::ServerOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitServerOptions(this);
}


std::any MySQLParser::ServerOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitServerOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ServerOptionsContext* MySQLParser::serverOptions() {
  ServerOptionsContext *_localctx = _tracker.createInstance<ServerOptionsContext>(_ctx, getState());
  enterRule(_localctx, 136, MySQLParser::RuleServerOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2593);
    match(MySQLParser::OPTIONS_SYMBOL);
    setState(2594);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(2595);
    serverOption();
    setState(2600);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2596);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2597);
      serverOption();
      setState(2602);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2603);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ServerOptionContext ------------------------------------------------------------------

MySQLParser::ServerOptionContext::ServerOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextLiteralContext* MySQLParser::ServerOptionContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::HOST_SYMBOL() {
  return getToken(MySQLParser::HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::SOCKET_SYMBOL() {
  return getToken(MySQLParser::SOCKET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::OWNER_SYMBOL() {
  return getToken(MySQLParser::OWNER_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::ServerOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::ServerOptionContext::PORT_SYMBOL() {
  return getToken(MySQLParser::PORT_SYMBOL, 0);
}


size_t MySQLParser::ServerOptionContext::getRuleIndex() const {
  return MySQLParser::RuleServerOption;
}

void MySQLParser::ServerOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterServerOption(this);
}

void MySQLParser::ServerOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitServerOption(this);
}


std::any MySQLParser::ServerOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitServerOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ServerOptionContext* MySQLParser::serverOption() {
  ServerOptionContext *_localctx = _tracker.createInstance<ServerOptionContext>(_ctx, getState());
  enterRule(_localctx, 138, MySQLParser::RuleServerOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2619);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::HOST_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2605);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::HOST_SYMBOL);
        setState(2606);
        textLiteral();
        break;
      }

      case MySQLParser::DATABASE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2607);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::DATABASE_SYMBOL);
        setState(2608);
        textLiteral();
        break;
      }

      case MySQLParser::USER_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2609);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::USER_SYMBOL);
        setState(2610);
        textLiteral();
        break;
      }

      case MySQLParser::PASSWORD_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2611);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::PASSWORD_SYMBOL);
        setState(2612);
        textLiteral();
        break;
      }

      case MySQLParser::SOCKET_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(2613);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::SOCKET_SYMBOL);
        setState(2614);
        textLiteral();
        break;
      }

      case MySQLParser::OWNER_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(2615);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::OWNER_SYMBOL);
        setState(2616);
        textLiteral();
        break;
      }

      case MySQLParser::PORT_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(2617);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::PORT_SYMBOL);
        setState(2618);
        ulong_number();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTablespaceContext ------------------------------------------------------------------

MySQLParser::CreateTablespaceContext::CreateTablespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateTablespaceContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

MySQLParser::TablespaceNameContext* MySQLParser::CreateTablespaceContext::tablespaceName() {
  return getRuleContext<MySQLParser::TablespaceNameContext>(0);
}

MySQLParser::TsDataFileNameContext* MySQLParser::CreateTablespaceContext::tsDataFileName() {
  return getRuleContext<MySQLParser::TsDataFileNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTablespaceContext::USE_SYMBOL() {
  return getToken(MySQLParser::USE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTablespaceContext::LOGFILE_SYMBOL() {
  return getToken(MySQLParser::LOGFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTablespaceContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::LogfileGroupRefContext* MySQLParser::CreateTablespaceContext::logfileGroupRef() {
  return getRuleContext<MySQLParser::LogfileGroupRefContext>(0);
}

MySQLParser::TablespaceOptionsContext* MySQLParser::CreateTablespaceContext::tablespaceOptions() {
  return getRuleContext<MySQLParser::TablespaceOptionsContext>(0);
}


size_t MySQLParser::CreateTablespaceContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTablespace;
}

void MySQLParser::CreateTablespaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTablespace(this);
}

void MySQLParser::CreateTablespaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTablespace(this);
}


std::any MySQLParser::CreateTablespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTablespace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTablespaceContext* MySQLParser::createTablespace() {
  CreateTablespaceContext *_localctx = _tracker.createInstance<CreateTablespaceContext>(_ctx, getState());
  enterRule(_localctx, 140, MySQLParser::RuleCreateTablespace);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2621);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2622);
    tablespaceName();
    setState(2623);
    tsDataFileName();
    setState(2628);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 161, _ctx)) {
    case 1: {
      setState(2624);
      match(MySQLParser::USE_SYMBOL);
      setState(2625);
      match(MySQLParser::LOGFILE_SYMBOL);
      setState(2626);
      match(MySQLParser::GROUP_SYMBOL);
      setState(2627);
      logfileGroupRef();
      break;
    }

    default:
      break;
    }
    setState(2631);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 162, _ctx)) {
    case 1: {
      setState(2630);
      tablespaceOptions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUndoTablespaceContext ------------------------------------------------------------------

MySQLParser::CreateUndoTablespaceContext::CreateUndoTablespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateUndoTablespaceContext::UNDO_SYMBOL() {
  return getToken(MySQLParser::UNDO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUndoTablespaceContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

MySQLParser::TablespaceNameContext* MySQLParser::CreateUndoTablespaceContext::tablespaceName() {
  return getRuleContext<MySQLParser::TablespaceNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateUndoTablespaceContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

MySQLParser::TsDataFileContext* MySQLParser::CreateUndoTablespaceContext::tsDataFile() {
  return getRuleContext<MySQLParser::TsDataFileContext>(0);
}

MySQLParser::UndoTableSpaceOptionsContext* MySQLParser::CreateUndoTablespaceContext::undoTableSpaceOptions() {
  return getRuleContext<MySQLParser::UndoTableSpaceOptionsContext>(0);
}


size_t MySQLParser::CreateUndoTablespaceContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUndoTablespace;
}

void MySQLParser::CreateUndoTablespaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUndoTablespace(this);
}

void MySQLParser::CreateUndoTablespaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUndoTablespace(this);
}


std::any MySQLParser::CreateUndoTablespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUndoTablespace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUndoTablespaceContext* MySQLParser::createUndoTablespace() {
  CreateUndoTablespaceContext *_localctx = _tracker.createInstance<CreateUndoTablespaceContext>(_ctx, getState());
  enterRule(_localctx, 142, MySQLParser::RuleCreateUndoTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2633);
    match(MySQLParser::UNDO_SYMBOL);
    setState(2634);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2635);
    tablespaceName();
    setState(2636);
    match(MySQLParser::ADD_SYMBOL);
    setState(2637);
    tsDataFile();
    setState(2639);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(2638);
      undoTableSpaceOptions();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateLibraryContext ------------------------------------------------------------------

MySQLParser::CreateLibraryContext::CreateLibraryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateLibraryContext::LIBRARY_SYMBOL() {
  return getToken(MySQLParser::LIBRARY_SYMBOL, 0);
}

MySQLParser::LibraryNameContext* MySQLParser::CreateLibraryContext::libraryName() {
  return getRuleContext<MySQLParser::LibraryNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateLibraryContext::LANGUAGE_SYMBOL() {
  return getToken(MySQLParser::LANGUAGE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CreateLibraryContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CreateLibraryContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::RoutineStringContext* MySQLParser::CreateLibraryContext::routineString() {
  return getRuleContext<MySQLParser::RoutineStringContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateLibraryContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::CreateLibraryContext::getRuleIndex() const {
  return MySQLParser::RuleCreateLibrary;
}

void MySQLParser::CreateLibraryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateLibrary(this);
}

void MySQLParser::CreateLibraryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateLibrary(this);
}


std::any MySQLParser::CreateLibraryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateLibrary(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateLibraryContext* MySQLParser::createLibrary() {
  CreateLibraryContext *_localctx = _tracker.createInstance<CreateLibraryContext>(_ctx, getState());
  enterRule(_localctx, 144, MySQLParser::RuleCreateLibrary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2641);
    match(MySQLParser::LIBRARY_SYMBOL);
    setState(2643);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 164, _ctx)) {
    case 1: {
      setState(2642);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2645);
    libraryName();
    setState(2646);
    match(MySQLParser::LANGUAGE_SYMBOL);
    setState(2647);
    identifier();
    setState(2648);
    match(MySQLParser::AS_SYMBOL);
    setState(2649);
    routineString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsDataFileNameContext ------------------------------------------------------------------

MySQLParser::TsDataFileNameContext::TsDataFileNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsDataFileNameContext::ADD_SYMBOL() {
  return getToken(MySQLParser::ADD_SYMBOL, 0);
}

MySQLParser::TsDataFileContext* MySQLParser::TsDataFileNameContext::tsDataFile() {
  return getRuleContext<MySQLParser::TsDataFileContext>(0);
}


size_t MySQLParser::TsDataFileNameContext::getRuleIndex() const {
  return MySQLParser::RuleTsDataFileName;
}

void MySQLParser::TsDataFileNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsDataFileName(this);
}

void MySQLParser::TsDataFileNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsDataFileName(this);
}


std::any MySQLParser::TsDataFileNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsDataFileName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsDataFileNameContext* MySQLParser::tsDataFileName() {
  TsDataFileNameContext *_localctx = _tracker.createInstance<TsDataFileNameContext>(_ctx, getState());
  enterRule(_localctx, 146, MySQLParser::RuleTsDataFileName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2658);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 166, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2651);
      match(MySQLParser::ADD_SYMBOL);
      setState(2652);
      tsDataFile();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2653);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2656);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 165, _ctx)) {
      case 1: {
        setState(2654);
        match(MySQLParser::ADD_SYMBOL);
        setState(2655);
        tsDataFile();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsDataFileContext ------------------------------------------------------------------

MySQLParser::TsDataFileContext::TsDataFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsDataFileContext::DATAFILE_SYMBOL() {
  return getToken(MySQLParser::DATAFILE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::TsDataFileContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}


size_t MySQLParser::TsDataFileContext::getRuleIndex() const {
  return MySQLParser::RuleTsDataFile;
}

void MySQLParser::TsDataFileContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsDataFile(this);
}

void MySQLParser::TsDataFileContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsDataFile(this);
}


std::any MySQLParser::TsDataFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsDataFile(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsDataFileContext* MySQLParser::tsDataFile() {
  TsDataFileContext *_localctx = _tracker.createInstance<TsDataFileContext>(_ctx, getState());
  enterRule(_localctx, 148, MySQLParser::RuleTsDataFile);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2660);
    match(MySQLParser::DATAFILE_SYMBOL);
    setState(2661);
    textLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablespaceOptionsContext ------------------------------------------------------------------

MySQLParser::TablespaceOptionsContext::TablespaceOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TablespaceOptionContext *> MySQLParser::TablespaceOptionsContext::tablespaceOption() {
  return getRuleContexts<MySQLParser::TablespaceOptionContext>();
}

MySQLParser::TablespaceOptionContext* MySQLParser::TablespaceOptionsContext::tablespaceOption(size_t i) {
  return getRuleContext<MySQLParser::TablespaceOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TablespaceOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TablespaceOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TablespaceOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleTablespaceOptions;
}

void MySQLParser::TablespaceOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTablespaceOptions(this);
}

void MySQLParser::TablespaceOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTablespaceOptions(this);
}


std::any MySQLParser::TablespaceOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTablespaceOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TablespaceOptionsContext* MySQLParser::tablespaceOptions() {
  TablespaceOptionsContext *_localctx = _tracker.createInstance<TablespaceOptionsContext>(_ctx, getState());
  enterRule(_localctx, 150, MySQLParser::RuleTablespaceOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2663);
    tablespaceOption();
    setState(2670);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 168, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2665);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 167, _ctx)) {
        case 1: {
          setState(2664);
          match(MySQLParser::COMMA_SYMBOL);
          break;
        }

        default:
          break;
        }
        setState(2667);
        tablespaceOption(); 
      }
      setState(2672);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 168, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablespaceOptionContext ------------------------------------------------------------------

MySQLParser::TablespaceOptionContext::TablespaceOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TsOptionInitialSizeContext* MySQLParser::TablespaceOptionContext::tsOptionInitialSize() {
  return getRuleContext<MySQLParser::TsOptionInitialSizeContext>(0);
}

MySQLParser::TsOptionAutoextendSizeContext* MySQLParser::TablespaceOptionContext::tsOptionAutoextendSize() {
  return getRuleContext<MySQLParser::TsOptionAutoextendSizeContext>(0);
}

MySQLParser::TsOptionMaxSizeContext* MySQLParser::TablespaceOptionContext::tsOptionMaxSize() {
  return getRuleContext<MySQLParser::TsOptionMaxSizeContext>(0);
}

MySQLParser::TsOptionExtentSizeContext* MySQLParser::TablespaceOptionContext::tsOptionExtentSize() {
  return getRuleContext<MySQLParser::TsOptionExtentSizeContext>(0);
}

MySQLParser::TsOptionNodegroupContext* MySQLParser::TablespaceOptionContext::tsOptionNodegroup() {
  return getRuleContext<MySQLParser::TsOptionNodegroupContext>(0);
}

MySQLParser::TsOptionEngineContext* MySQLParser::TablespaceOptionContext::tsOptionEngine() {
  return getRuleContext<MySQLParser::TsOptionEngineContext>(0);
}

MySQLParser::TsOptionWaitContext* MySQLParser::TablespaceOptionContext::tsOptionWait() {
  return getRuleContext<MySQLParser::TsOptionWaitContext>(0);
}

MySQLParser::TsOptionCommentContext* MySQLParser::TablespaceOptionContext::tsOptionComment() {
  return getRuleContext<MySQLParser::TsOptionCommentContext>(0);
}

MySQLParser::TsOptionFileblockSizeContext* MySQLParser::TablespaceOptionContext::tsOptionFileblockSize() {
  return getRuleContext<MySQLParser::TsOptionFileblockSizeContext>(0);
}

MySQLParser::TsOptionEncryptionContext* MySQLParser::TablespaceOptionContext::tsOptionEncryption() {
  return getRuleContext<MySQLParser::TsOptionEncryptionContext>(0);
}


size_t MySQLParser::TablespaceOptionContext::getRuleIndex() const {
  return MySQLParser::RuleTablespaceOption;
}

void MySQLParser::TablespaceOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTablespaceOption(this);
}

void MySQLParser::TablespaceOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTablespaceOption(this);
}


std::any MySQLParser::TablespaceOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTablespaceOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TablespaceOptionContext* MySQLParser::tablespaceOption() {
  TablespaceOptionContext *_localctx = _tracker.createInstance<TablespaceOptionContext>(_ctx, getState());
  enterRule(_localctx, 152, MySQLParser::RuleTablespaceOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2685);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 169, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2673);
      tsOptionInitialSize();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2674);
      tsOptionAutoextendSize();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2675);
      tsOptionMaxSize();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2676);
      tsOptionExtentSize();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2677);
      tsOptionNodegroup();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2678);
      tsOptionEngine();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2679);
      tsOptionWait();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2680);
      tsOptionComment();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(2681);

      if (!(serverVersion >= 50707)) throw FailedPredicateException(this, "serverVersion >= 50707");
      setState(2682);
      tsOptionFileblockSize();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(2683);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2684);
      tsOptionEncryption();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionInitialSizeContext ------------------------------------------------------------------

MySQLParser::TsOptionInitialSizeContext::TsOptionInitialSizeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionInitialSizeContext::INITIAL_SIZE_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::TsOptionInitialSizeContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionInitialSizeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionInitialSizeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionInitialSize;
}

void MySQLParser::TsOptionInitialSizeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionInitialSize(this);
}

void MySQLParser::TsOptionInitialSizeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionInitialSize(this);
}


std::any MySQLParser::TsOptionInitialSizeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionInitialSize(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionInitialSizeContext* MySQLParser::tsOptionInitialSize() {
  TsOptionInitialSizeContext *_localctx = _tracker.createInstance<TsOptionInitialSizeContext>(_ctx, getState());
  enterRule(_localctx, 154, MySQLParser::RuleTsOptionInitialSize);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2687);
    match(MySQLParser::INITIAL_SIZE_SYMBOL);
    setState(2689);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 170, _ctx)) {
    case 1: {
      setState(2688);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2691);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionUndoRedoBufferSizeContext ------------------------------------------------------------------

MySQLParser::TsOptionUndoRedoBufferSizeContext::TsOptionUndoRedoBufferSizeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SizeNumberContext* MySQLParser::TsOptionUndoRedoBufferSizeContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionUndoRedoBufferSizeContext::UNDO_BUFFER_SIZE_SYMBOL() {
  return getToken(MySQLParser::UNDO_BUFFER_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TsOptionUndoRedoBufferSizeContext::REDO_BUFFER_SIZE_SYMBOL() {
  return getToken(MySQLParser::REDO_BUFFER_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TsOptionUndoRedoBufferSizeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionUndoRedoBufferSizeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionUndoRedoBufferSize;
}

void MySQLParser::TsOptionUndoRedoBufferSizeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionUndoRedoBufferSize(this);
}

void MySQLParser::TsOptionUndoRedoBufferSizeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionUndoRedoBufferSize(this);
}


std::any MySQLParser::TsOptionUndoRedoBufferSizeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionUndoRedoBufferSize(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionUndoRedoBufferSizeContext* MySQLParser::tsOptionUndoRedoBufferSize() {
  TsOptionUndoRedoBufferSizeContext *_localctx = _tracker.createInstance<TsOptionUndoRedoBufferSizeContext>(_ctx, getState());
  enterRule(_localctx, 156, MySQLParser::RuleTsOptionUndoRedoBufferSize);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2693);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::REDO_BUFFER_SIZE_SYMBOL || _la == MySQLParser::UNDO_BUFFER_SIZE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2695);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 171, _ctx)) {
    case 1: {
      setState(2694);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2697);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionAutoextendSizeContext ------------------------------------------------------------------

MySQLParser::TsOptionAutoextendSizeContext::TsOptionAutoextendSizeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionAutoextendSizeContext::AUTOEXTEND_SIZE_SYMBOL() {
  return getToken(MySQLParser::AUTOEXTEND_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::TsOptionAutoextendSizeContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionAutoextendSizeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionAutoextendSizeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionAutoextendSize;
}

void MySQLParser::TsOptionAutoextendSizeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionAutoextendSize(this);
}

void MySQLParser::TsOptionAutoextendSizeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionAutoextendSize(this);
}


std::any MySQLParser::TsOptionAutoextendSizeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionAutoextendSize(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionAutoextendSizeContext* MySQLParser::tsOptionAutoextendSize() {
  TsOptionAutoextendSizeContext *_localctx = _tracker.createInstance<TsOptionAutoextendSizeContext>(_ctx, getState());
  enterRule(_localctx, 158, MySQLParser::RuleTsOptionAutoextendSize);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2699);
    match(MySQLParser::AUTOEXTEND_SIZE_SYMBOL);
    setState(2701);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx)) {
    case 1: {
      setState(2700);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2703);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionMaxSizeContext ------------------------------------------------------------------

MySQLParser::TsOptionMaxSizeContext::TsOptionMaxSizeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionMaxSizeContext::MAX_SIZE_SYMBOL() {
  return getToken(MySQLParser::MAX_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::TsOptionMaxSizeContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionMaxSizeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionMaxSizeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionMaxSize;
}

void MySQLParser::TsOptionMaxSizeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionMaxSize(this);
}

void MySQLParser::TsOptionMaxSizeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionMaxSize(this);
}


std::any MySQLParser::TsOptionMaxSizeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionMaxSize(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionMaxSizeContext* MySQLParser::tsOptionMaxSize() {
  TsOptionMaxSizeContext *_localctx = _tracker.createInstance<TsOptionMaxSizeContext>(_ctx, getState());
  enterRule(_localctx, 160, MySQLParser::RuleTsOptionMaxSize);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2705);
    match(MySQLParser::MAX_SIZE_SYMBOL);
    setState(2707);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 173, _ctx)) {
    case 1: {
      setState(2706);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2709);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionExtentSizeContext ------------------------------------------------------------------

MySQLParser::TsOptionExtentSizeContext::TsOptionExtentSizeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionExtentSizeContext::EXTENT_SIZE_SYMBOL() {
  return getToken(MySQLParser::EXTENT_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::TsOptionExtentSizeContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionExtentSizeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionExtentSizeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionExtentSize;
}

void MySQLParser::TsOptionExtentSizeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionExtentSize(this);
}

void MySQLParser::TsOptionExtentSizeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionExtentSize(this);
}


std::any MySQLParser::TsOptionExtentSizeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionExtentSize(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionExtentSizeContext* MySQLParser::tsOptionExtentSize() {
  TsOptionExtentSizeContext *_localctx = _tracker.createInstance<TsOptionExtentSizeContext>(_ctx, getState());
  enterRule(_localctx, 162, MySQLParser::RuleTsOptionExtentSize);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2711);
    match(MySQLParser::EXTENT_SIZE_SYMBOL);
    setState(2713);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 174, _ctx)) {
    case 1: {
      setState(2712);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2715);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionNodegroupContext ------------------------------------------------------------------

MySQLParser::TsOptionNodegroupContext::TsOptionNodegroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionNodegroupContext::NODEGROUP_SYMBOL() {
  return getToken(MySQLParser::NODEGROUP_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::TsOptionNodegroupContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionNodegroupContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionNodegroupContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionNodegroup;
}

void MySQLParser::TsOptionNodegroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionNodegroup(this);
}

void MySQLParser::TsOptionNodegroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionNodegroup(this);
}


std::any MySQLParser::TsOptionNodegroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionNodegroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionNodegroupContext* MySQLParser::tsOptionNodegroup() {
  TsOptionNodegroupContext *_localctx = _tracker.createInstance<TsOptionNodegroupContext>(_ctx, getState());
  enterRule(_localctx, 164, MySQLParser::RuleTsOptionNodegroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2717);
    match(MySQLParser::NODEGROUP_SYMBOL);
    setState(2719);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::EQUAL_OPERATOR) {
      setState(2718);
      match(MySQLParser::EQUAL_OPERATOR);
    }
    setState(2721);
    real_ulong_number();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionEngineContext ------------------------------------------------------------------

MySQLParser::TsOptionEngineContext::TsOptionEngineContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionEngineContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

MySQLParser::EngineRefContext* MySQLParser::TsOptionEngineContext::engineRef() {
  return getRuleContext<MySQLParser::EngineRefContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionEngineContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TsOptionEngineContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionEngineContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionEngine;
}

void MySQLParser::TsOptionEngineContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionEngine(this);
}

void MySQLParser::TsOptionEngineContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionEngine(this);
}


std::any MySQLParser::TsOptionEngineContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionEngine(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionEngineContext* MySQLParser::tsOptionEngine() {
  TsOptionEngineContext *_localctx = _tracker.createInstance<TsOptionEngineContext>(_ctx, getState());
  enterRule(_localctx, 166, MySQLParser::RuleTsOptionEngine);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2724);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::STORAGE_SYMBOL) {
      setState(2723);
      match(MySQLParser::STORAGE_SYMBOL);
    }
    setState(2726);
    match(MySQLParser::ENGINE_SYMBOL);
    setState(2728);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 177, _ctx)) {
    case 1: {
      setState(2727);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2730);
    engineRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionWaitContext ------------------------------------------------------------------

MySQLParser::TsOptionWaitContext::TsOptionWaitContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionWaitContext::WAIT_SYMBOL() {
  return getToken(MySQLParser::WAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TsOptionWaitContext::NO_WAIT_SYMBOL() {
  return getToken(MySQLParser::NO_WAIT_SYMBOL, 0);
}


size_t MySQLParser::TsOptionWaitContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionWait;
}

void MySQLParser::TsOptionWaitContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionWait(this);
}

void MySQLParser::TsOptionWaitContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionWait(this);
}


std::any MySQLParser::TsOptionWaitContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionWait(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionWaitContext* MySQLParser::tsOptionWait() {
  TsOptionWaitContext *_localctx = _tracker.createInstance<TsOptionWaitContext>(_ctx, getState());
  enterRule(_localctx, 168, MySQLParser::RuleTsOptionWait);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2732);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::WAIT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionCommentContext ------------------------------------------------------------------

MySQLParser::TsOptionCommentContext::TsOptionCommentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionCommentContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::TsOptionCommentContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionCommentContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionCommentContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionComment;
}

void MySQLParser::TsOptionCommentContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionComment(this);
}

void MySQLParser::TsOptionCommentContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionComment(this);
}


std::any MySQLParser::TsOptionCommentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionComment(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionCommentContext* MySQLParser::tsOptionComment() {
  TsOptionCommentContext *_localctx = _tracker.createInstance<TsOptionCommentContext>(_ctx, getState());
  enterRule(_localctx, 170, MySQLParser::RuleTsOptionComment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2734);
    match(MySQLParser::COMMENT_SYMBOL);
    setState(2736);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 178, _ctx)) {
    case 1: {
      setState(2735);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2738);
    textLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionFileblockSizeContext ------------------------------------------------------------------

MySQLParser::TsOptionFileblockSizeContext::TsOptionFileblockSizeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionFileblockSizeContext::FILE_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::FILE_BLOCK_SIZE_SYMBOL, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::TsOptionFileblockSizeContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionFileblockSizeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionFileblockSizeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionFileblockSize;
}

void MySQLParser::TsOptionFileblockSizeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionFileblockSize(this);
}

void MySQLParser::TsOptionFileblockSizeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionFileblockSize(this);
}


std::any MySQLParser::TsOptionFileblockSizeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionFileblockSize(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionFileblockSizeContext* MySQLParser::tsOptionFileblockSize() {
  TsOptionFileblockSizeContext *_localctx = _tracker.createInstance<TsOptionFileblockSizeContext>(_ctx, getState());
  enterRule(_localctx, 172, MySQLParser::RuleTsOptionFileblockSize);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2740);
    match(MySQLParser::FILE_BLOCK_SIZE_SYMBOL);
    setState(2742);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 179, _ctx)) {
    case 1: {
      setState(2741);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2744);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionEncryptionContext ------------------------------------------------------------------

MySQLParser::TsOptionEncryptionContext::TsOptionEncryptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionEncryptionContext::ENCRYPTION_SYMBOL() {
  return getToken(MySQLParser::ENCRYPTION_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::TsOptionEncryptionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionEncryptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionEncryptionContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionEncryption;
}

void MySQLParser::TsOptionEncryptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionEncryption(this);
}

void MySQLParser::TsOptionEncryptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionEncryption(this);
}


std::any MySQLParser::TsOptionEncryptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionEncryption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionEncryptionContext* MySQLParser::tsOptionEncryption() {
  TsOptionEncryptionContext *_localctx = _tracker.createInstance<TsOptionEncryptionContext>(_ctx, getState());
  enterRule(_localctx, 174, MySQLParser::RuleTsOptionEncryption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2746);
    match(MySQLParser::ENCRYPTION_SYMBOL);
    setState(2748);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
    case 1: {
      setState(2747);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2750);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TsOptionEngineAttributeContext ------------------------------------------------------------------

MySQLParser::TsOptionEngineAttributeContext::TsOptionEngineAttributeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TsOptionEngineAttributeContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

MySQLParser::JsonAttributeContext* MySQLParser::TsOptionEngineAttributeContext::jsonAttribute() {
  return getRuleContext<MySQLParser::JsonAttributeContext>(0);
}

tree::TerminalNode* MySQLParser::TsOptionEngineAttributeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TsOptionEngineAttributeContext::getRuleIndex() const {
  return MySQLParser::RuleTsOptionEngineAttribute;
}

void MySQLParser::TsOptionEngineAttributeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTsOptionEngineAttribute(this);
}

void MySQLParser::TsOptionEngineAttributeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTsOptionEngineAttribute(this);
}


std::any MySQLParser::TsOptionEngineAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTsOptionEngineAttribute(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TsOptionEngineAttributeContext* MySQLParser::tsOptionEngineAttribute() {
  TsOptionEngineAttributeContext *_localctx = _tracker.createInstance<TsOptionEngineAttributeContext>(_ctx, getState());
  enterRule(_localctx, 176, MySQLParser::RuleTsOptionEngineAttribute);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2752);
    match(MySQLParser::ENGINE_SYMBOL);
    setState(2754);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx)) {
    case 1: {
      setState(2753);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(2756);
    jsonAttribute();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateViewContext ------------------------------------------------------------------

MySQLParser::CreateViewContext::CreateViewContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateViewContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

MySQLParser::ViewNameContext* MySQLParser::CreateViewContext::viewName() {
  return getRuleContext<MySQLParser::ViewNameContext>(0);
}

MySQLParser::ViewTailContext* MySQLParser::CreateViewContext::viewTail() {
  return getRuleContext<MySQLParser::ViewTailContext>(0);
}

MySQLParser::ViewReplaceOrAlgorithmContext* MySQLParser::CreateViewContext::viewReplaceOrAlgorithm() {
  return getRuleContext<MySQLParser::ViewReplaceOrAlgorithmContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateViewContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

MySQLParser::ViewSuidContext* MySQLParser::CreateViewContext::viewSuid() {
  return getRuleContext<MySQLParser::ViewSuidContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateViewContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::CreateViewContext::getRuleIndex() const {
  return MySQLParser::RuleCreateView;
}

void MySQLParser::CreateViewContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateView(this);
}

void MySQLParser::CreateViewContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateView(this);
}


std::any MySQLParser::CreateViewContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateView(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateViewContext* MySQLParser::createView() {
  CreateViewContext *_localctx = _tracker.createInstance<CreateViewContext>(_ctx, getState());
  enterRule(_localctx, 178, MySQLParser::RuleCreateView);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2759);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL || _la == MySQLParser::OR_SYMBOL) {
      setState(2758);
      viewReplaceOrAlgorithm();
    }
    setState(2762);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2761);
      definerClause();
    }
    setState(2765);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SQL_SYMBOL) {
      setState(2764);
      viewSuid();
    }
    setState(2767);
    match(MySQLParser::VIEW_SYMBOL);
    setState(2770);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 185, _ctx)) {
    case 1: {
      setState(2768);

      if (!(serverVersion >= 90100)) throw FailedPredicateException(this, "serverVersion >= 90100");
      setState(2769);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2772);
    viewName();
    setState(2773);
    viewTail();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewReplaceOrAlgorithmContext ------------------------------------------------------------------

MySQLParser::ViewReplaceOrAlgorithmContext::ViewReplaceOrAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ViewReplaceOrAlgorithmContext::OR_SYMBOL() {
  return getToken(MySQLParser::OR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewReplaceOrAlgorithmContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

MySQLParser::ViewAlgorithmContext* MySQLParser::ViewReplaceOrAlgorithmContext::viewAlgorithm() {
  return getRuleContext<MySQLParser::ViewAlgorithmContext>(0);
}


size_t MySQLParser::ViewReplaceOrAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RuleViewReplaceOrAlgorithm;
}

void MySQLParser::ViewReplaceOrAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewReplaceOrAlgorithm(this);
}

void MySQLParser::ViewReplaceOrAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewReplaceOrAlgorithm(this);
}


std::any MySQLParser::ViewReplaceOrAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewReplaceOrAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewReplaceOrAlgorithmContext* MySQLParser::viewReplaceOrAlgorithm() {
  ViewReplaceOrAlgorithmContext *_localctx = _tracker.createInstance<ViewReplaceOrAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 180, MySQLParser::RuleViewReplaceOrAlgorithm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2781);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::OR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2775);
        match(MySQLParser::OR_SYMBOL);
        setState(2776);
        match(MySQLParser::REPLACE_SYMBOL);
        setState(2778);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ALGORITHM_SYMBOL) {
          setState(2777);
          viewAlgorithm();
        }
        break;
      }

      case MySQLParser::ALGORITHM_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2780);
        viewAlgorithm();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewAlgorithmContext ------------------------------------------------------------------

MySQLParser::ViewAlgorithmContext::ViewAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ViewAlgorithmContext::ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewAlgorithmContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::ViewAlgorithmContext::UNDEFINED_SYMBOL() {
  return getToken(MySQLParser::UNDEFINED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewAlgorithmContext::MERGE_SYMBOL() {
  return getToken(MySQLParser::MERGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewAlgorithmContext::TEMPTABLE_SYMBOL() {
  return getToken(MySQLParser::TEMPTABLE_SYMBOL, 0);
}


size_t MySQLParser::ViewAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RuleViewAlgorithm;
}

void MySQLParser::ViewAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewAlgorithm(this);
}

void MySQLParser::ViewAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewAlgorithm(this);
}


std::any MySQLParser::ViewAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewAlgorithmContext* MySQLParser::viewAlgorithm() {
  ViewAlgorithmContext *_localctx = _tracker.createInstance<ViewAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 182, MySQLParser::RuleViewAlgorithm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2783);
    match(MySQLParser::ALGORITHM_SYMBOL);
    setState(2784);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(2785);
    antlrcpp::downCast<ViewAlgorithmContext *>(_localctx)->algorithm = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MERGE_SYMBOL || _la == MySQLParser::TEMPTABLE_SYMBOL

    || _la == MySQLParser::UNDEFINED_SYMBOL)) {
      antlrcpp::downCast<ViewAlgorithmContext *>(_localctx)->algorithm = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewSuidContext ------------------------------------------------------------------

MySQLParser::ViewSuidContext::ViewSuidContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ViewSuidContext::SQL_SYMBOL() {
  return getToken(MySQLParser::SQL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewSuidContext::SECURITY_SYMBOL() {
  return getToken(MySQLParser::SECURITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewSuidContext::DEFINER_SYMBOL() {
  return getToken(MySQLParser::DEFINER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ViewSuidContext::INVOKER_SYMBOL() {
  return getToken(MySQLParser::INVOKER_SYMBOL, 0);
}


size_t MySQLParser::ViewSuidContext::getRuleIndex() const {
  return MySQLParser::RuleViewSuid;
}

void MySQLParser::ViewSuidContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewSuid(this);
}

void MySQLParser::ViewSuidContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewSuid(this);
}


std::any MySQLParser::ViewSuidContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewSuid(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewSuidContext* MySQLParser::viewSuid() {
  ViewSuidContext *_localctx = _tracker.createInstance<ViewSuidContext>(_ctx, getState());
  enterRule(_localctx, 184, MySQLParser::RuleViewSuid);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2787);
    match(MySQLParser::SQL_SYMBOL);
    setState(2788);
    match(MySQLParser::SECURITY_SYMBOL);
    setState(2789);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DEFINER_SYMBOL || _la == MySQLParser::INVOKER_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTriggerContext ------------------------------------------------------------------

MySQLParser::CreateTriggerContext::CreateTriggerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::TRIGGER_SYMBOL() {
  return getToken(MySQLParser::TRIGGER_SYMBOL, 0);
}

MySQLParser::TriggerNameContext* MySQLParser::CreateTriggerContext::triggerName() {
  return getRuleContext<MySQLParser::TriggerNameContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::CreateTriggerContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::EACH_SYMBOL() {
  return getToken(MySQLParser::EACH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}

MySQLParser::CompoundStatementContext* MySQLParser::CreateTriggerContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::BEFORE_SYMBOL() {
  return getToken(MySQLParser::BEFORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::AFTER_SYMBOL() {
  return getToken(MySQLParser::AFTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::INSERT_SYMBOL() {
  return getToken(MySQLParser::INSERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTriggerContext::DELETE_SYMBOL() {
  return getToken(MySQLParser::DELETE_SYMBOL, 0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateTriggerContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateTriggerContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

MySQLParser::TriggerFollowsPrecedesClauseContext* MySQLParser::CreateTriggerContext::triggerFollowsPrecedesClause() {
  return getRuleContext<MySQLParser::TriggerFollowsPrecedesClauseContext>(0);
}


size_t MySQLParser::CreateTriggerContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTrigger;
}

void MySQLParser::CreateTriggerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTrigger(this);
}

void MySQLParser::CreateTriggerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTrigger(this);
}


std::any MySQLParser::CreateTriggerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTrigger(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTriggerContext* MySQLParser::createTrigger() {
  CreateTriggerContext *_localctx = _tracker.createInstance<CreateTriggerContext>(_ctx, getState());
  enterRule(_localctx, 186, MySQLParser::RuleCreateTrigger);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2792);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2791);
      definerClause();
    }
    setState(2794);
    match(MySQLParser::TRIGGER_SYMBOL);
    setState(2797);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 189, _ctx)) {
    case 1: {
      setState(2795);

      if (!(serverVersion >= 80029)) throw FailedPredicateException(this, "serverVersion >= 80029");
      setState(2796);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2799);
    triggerName();
    setState(2800);
    antlrcpp::downCast<CreateTriggerContext *>(_localctx)->timing = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::AFTER_SYMBOL

    || _la == MySQLParser::BEFORE_SYMBOL)) {
      antlrcpp::downCast<CreateTriggerContext *>(_localctx)->timing = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2801);
    antlrcpp::downCast<CreateTriggerContext *>(_localctx)->event = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DELETE_SYMBOL || _la == MySQLParser::INSERT_SYMBOL || _la == MySQLParser::UPDATE_SYMBOL)) {
      antlrcpp::downCast<CreateTriggerContext *>(_localctx)->event = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2802);
    match(MySQLParser::ON_SYMBOL);
    setState(2803);
    tableRef();
    setState(2804);
    match(MySQLParser::FOR_SYMBOL);
    setState(2805);
    match(MySQLParser::EACH_SYMBOL);
    setState(2806);
    match(MySQLParser::ROW_SYMBOL);
    setState(2808);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 190, _ctx)) {
    case 1: {
      setState(2807);
      triggerFollowsPrecedesClause();
      break;
    }

    default:
      break;
    }
    setState(2810);
    compoundStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TriggerFollowsPrecedesClauseContext ------------------------------------------------------------------

MySQLParser::TriggerFollowsPrecedesClauseContext::TriggerFollowsPrecedesClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::TriggerFollowsPrecedesClauseContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::TriggerFollowsPrecedesClauseContext::FOLLOWS_SYMBOL() {
  return getToken(MySQLParser::FOLLOWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TriggerFollowsPrecedesClauseContext::PRECEDES_SYMBOL() {
  return getToken(MySQLParser::PRECEDES_SYMBOL, 0);
}


size_t MySQLParser::TriggerFollowsPrecedesClauseContext::getRuleIndex() const {
  return MySQLParser::RuleTriggerFollowsPrecedesClause;
}

void MySQLParser::TriggerFollowsPrecedesClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTriggerFollowsPrecedesClause(this);
}

void MySQLParser::TriggerFollowsPrecedesClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTriggerFollowsPrecedesClause(this);
}


std::any MySQLParser::TriggerFollowsPrecedesClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTriggerFollowsPrecedesClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TriggerFollowsPrecedesClauseContext* MySQLParser::triggerFollowsPrecedesClause() {
  TriggerFollowsPrecedesClauseContext *_localctx = _tracker.createInstance<TriggerFollowsPrecedesClauseContext>(_ctx, getState());
  enterRule(_localctx, 188, MySQLParser::RuleTriggerFollowsPrecedesClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2812);
    antlrcpp::downCast<TriggerFollowsPrecedesClauseContext *>(_localctx)->ordering = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::FOLLOWS_SYMBOL || _la == MySQLParser::PRECEDES_SYMBOL)) {
      antlrcpp::downCast<TriggerFollowsPrecedesClauseContext *>(_localctx)->ordering = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2813);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateEventContext ------------------------------------------------------------------

MySQLParser::CreateEventContext::CreateEventContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateEventContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

MySQLParser::EventNameContext* MySQLParser::CreateEventContext::eventName() {
  return getRuleContext<MySQLParser::EventNameContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::CreateEventContext::ON_SYMBOL() {
  return getTokens(MySQLParser::ON_SYMBOL);
}

tree::TerminalNode* MySQLParser::CreateEventContext::ON_SYMBOL(size_t i) {
  return getToken(MySQLParser::ON_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::CreateEventContext::SCHEDULE_SYMBOL() {
  return getToken(MySQLParser::SCHEDULE_SYMBOL, 0);
}

MySQLParser::ScheduleContext* MySQLParser::CreateEventContext::schedule() {
  return getRuleContext<MySQLParser::ScheduleContext>(0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::DO_SYMBOL() {
  return getToken(MySQLParser::DO_SYMBOL, 0);
}

MySQLParser::CompoundStatementContext* MySQLParser::CreateEventContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateEventContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateEventContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::COMPLETION_SYMBOL() {
  return getToken(MySQLParser::COMPLETION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::PRESERVE_SYMBOL() {
  return getToken(MySQLParser::PRESERVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::CreateEventContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::CreateEventContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::CreateEventContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}


size_t MySQLParser::CreateEventContext::getRuleIndex() const {
  return MySQLParser::RuleCreateEvent;
}

void MySQLParser::CreateEventContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateEvent(this);
}

void MySQLParser::CreateEventContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateEvent(this);
}


std::any MySQLParser::CreateEventContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateEvent(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateEventContext* MySQLParser::createEvent() {
  CreateEventContext *_localctx = _tracker.createInstance<CreateEventContext>(_ctx, getState());
  enterRule(_localctx, 190, MySQLParser::RuleCreateEvent);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2816);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2815);
      definerClause();
    }
    setState(2818);
    match(MySQLParser::EVENT_SYMBOL);
    setState(2820);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _ctx)) {
    case 1: {
      setState(2819);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2822);
    eventName();
    setState(2823);
    match(MySQLParser::ON_SYMBOL);
    setState(2824);
    match(MySQLParser::SCHEDULE_SYMBOL);
    setState(2825);
    schedule();
    setState(2832);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ON_SYMBOL) {
      setState(2826);
      match(MySQLParser::ON_SYMBOL);
      setState(2827);
      match(MySQLParser::COMPLETION_SYMBOL);
      setState(2829);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(2828);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(2831);
      match(MySQLParser::PRESERVE_SYMBOL);
    }
    setState(2840);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ENABLE_SYMBOL: {
        setState(2834);
        match(MySQLParser::ENABLE_SYMBOL);
        break;
      }

      case MySQLParser::DISABLE_SYMBOL: {
        setState(2835);
        match(MySQLParser::DISABLE_SYMBOL);
        setState(2838);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ON_SYMBOL) {
          setState(2836);
          match(MySQLParser::ON_SYMBOL);
          setState(2837);
          replica();
        }
        break;
      }

      case MySQLParser::COMMENT_SYMBOL:
      case MySQLParser::DO_SYMBOL: {
        break;
      }

    default:
      break;
    }
    setState(2844);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMENT_SYMBOL) {
      setState(2842);
      match(MySQLParser::COMMENT_SYMBOL);
      setState(2843);
      textLiteral();
    }
    setState(2846);
    match(MySQLParser::DO_SYMBOL);
    setState(2847);
    compoundStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateRoleContext ------------------------------------------------------------------

MySQLParser::CreateRoleContext::CreateRoleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateRoleContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::CreateRoleContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateRoleContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::CreateRoleContext::getRuleIndex() const {
  return MySQLParser::RuleCreateRole;
}

void MySQLParser::CreateRoleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateRole(this);
}

void MySQLParser::CreateRoleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateRole(this);
}


std::any MySQLParser::CreateRoleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateRole(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateRoleContext* MySQLParser::createRole() {
  CreateRoleContext *_localctx = _tracker.createInstance<CreateRoleContext>(_ctx, getState());
  enterRule(_localctx, 192, MySQLParser::RuleCreateRole);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2849);
    match(MySQLParser::ROLE_SYMBOL);
    setState(2851);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 198, _ctx)) {
    case 1: {
      setState(2850);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2853);
    roleList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateSpatialReferenceContext ------------------------------------------------------------------

MySQLParser::CreateSpatialReferenceContext::CreateSpatialReferenceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateSpatialReferenceContext::OR_SYMBOL() {
  return getToken(MySQLParser::OR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateSpatialReferenceContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateSpatialReferenceContext::SPATIAL_SYMBOL() {
  return getToken(MySQLParser::SPATIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateSpatialReferenceContext::REFERENCE_SYMBOL() {
  return getToken(MySQLParser::REFERENCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateSpatialReferenceContext::SYSTEM_SYMBOL() {
  return getToken(MySQLParser::SYSTEM_SYMBOL, 0);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::CreateSpatialReferenceContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}

std::vector<MySQLParser::SrsAttributeContext *> MySQLParser::CreateSpatialReferenceContext::srsAttribute() {
  return getRuleContexts<MySQLParser::SrsAttributeContext>();
}

MySQLParser::SrsAttributeContext* MySQLParser::CreateSpatialReferenceContext::srsAttribute(size_t i) {
  return getRuleContext<MySQLParser::SrsAttributeContext>(i);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateSpatialReferenceContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::CreateSpatialReferenceContext::getRuleIndex() const {
  return MySQLParser::RuleCreateSpatialReference;
}

void MySQLParser::CreateSpatialReferenceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateSpatialReference(this);
}

void MySQLParser::CreateSpatialReferenceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateSpatialReference(this);
}


std::any MySQLParser::CreateSpatialReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateSpatialReference(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateSpatialReferenceContext* MySQLParser::createSpatialReference() {
  CreateSpatialReferenceContext *_localctx = _tracker.createInstance<CreateSpatialReferenceContext>(_ctx, getState());
  enterRule(_localctx, 194, MySQLParser::RuleCreateSpatialReference);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2880);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::OR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2855);
        match(MySQLParser::OR_SYMBOL);
        setState(2856);
        match(MySQLParser::REPLACE_SYMBOL);
        setState(2857);
        match(MySQLParser::SPATIAL_SYMBOL);
        setState(2858);
        match(MySQLParser::REFERENCE_SYMBOL);
        setState(2859);
        match(MySQLParser::SYSTEM_SYMBOL);
        setState(2860);
        real_ulonglong_number();
        setState(2864);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::NAME_SYMBOL || ((((_la - 740) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 740)) & ((1ULL << (MySQLParser::DEFINITION_SYMBOL - 740))
          | (1ULL << (MySQLParser::DESCRIPTION_SYMBOL - 740))
          | (1ULL << (MySQLParser::ORGANIZATION_SYMBOL - 740)))) != 0)) {
          setState(2861);
          srsAttribute();
          setState(2866);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case MySQLParser::SPATIAL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2867);
        match(MySQLParser::SPATIAL_SYMBOL);
        setState(2868);
        match(MySQLParser::REFERENCE_SYMBOL);
        setState(2869);
        match(MySQLParser::SYSTEM_SYMBOL);
        setState(2871);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 200, _ctx)) {
        case 1: {
          setState(2870);
          ifNotExists();
          break;
        }

        default:
          break;
        }
        setState(2873);
        real_ulonglong_number();
        setState(2877);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::NAME_SYMBOL || ((((_la - 740) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 740)) & ((1ULL << (MySQLParser::DEFINITION_SYMBOL - 740))
          | (1ULL << (MySQLParser::DESCRIPTION_SYMBOL - 740))
          | (1ULL << (MySQLParser::ORGANIZATION_SYMBOL - 740)))) != 0)) {
          setState(2874);
          srsAttribute();
          setState(2879);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SrsAttributeContext ------------------------------------------------------------------

MySQLParser::SrsAttributeContext::SrsAttributeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::NAME_SYMBOL() {
  return getToken(MySQLParser::NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::TEXT_SYMBOL() {
  return getToken(MySQLParser::TEXT_SYMBOL, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::SrsAttributeContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::DEFINITION_SYMBOL() {
  return getToken(MySQLParser::DEFINITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::ORGANIZATION_SYMBOL() {
  return getToken(MySQLParser::ORGANIZATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::SrsAttributeContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::SrsAttributeContext::DESCRIPTION_SYMBOL() {
  return getToken(MySQLParser::DESCRIPTION_SYMBOL, 0);
}


size_t MySQLParser::SrsAttributeContext::getRuleIndex() const {
  return MySQLParser::RuleSrsAttribute;
}

void MySQLParser::SrsAttributeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSrsAttribute(this);
}

void MySQLParser::SrsAttributeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSrsAttribute(this);
}


std::any MySQLParser::SrsAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSrsAttribute(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SrsAttributeContext* MySQLParser::srsAttribute() {
  SrsAttributeContext *_localctx = _tracker.createInstance<SrsAttributeContext>(_ctx, getState());
  enterRule(_localctx, 196, MySQLParser::RuleSrsAttribute);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2897);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::NAME_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2882);
        match(MySQLParser::NAME_SYMBOL);
        setState(2883);
        match(MySQLParser::TEXT_SYMBOL);
        setState(2884);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::DEFINITION_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2885);
        match(MySQLParser::DEFINITION_SYMBOL);
        setState(2886);
        match(MySQLParser::TEXT_SYMBOL);
        setState(2887);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::ORGANIZATION_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2888);
        match(MySQLParser::ORGANIZATION_SYMBOL);
        setState(2889);
        textStringNoLinebreak();
        setState(2890);
        match(MySQLParser::IDENTIFIED_SYMBOL);
        setState(2891);
        match(MySQLParser::BY_SYMBOL);
        setState(2892);
        real_ulonglong_number();
        break;
      }

      case MySQLParser::DESCRIPTION_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2894);
        match(MySQLParser::DESCRIPTION_SYMBOL);
        setState(2895);
        match(MySQLParser::TEXT_SYMBOL);
        setState(2896);
        textStringNoLinebreak();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropStatementContext ------------------------------------------------------------------

MySQLParser::DropStatementContext::DropStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropStatementContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

MySQLParser::DropDatabaseContext* MySQLParser::DropStatementContext::dropDatabase() {
  return getRuleContext<MySQLParser::DropDatabaseContext>(0);
}

MySQLParser::DropEventContext* MySQLParser::DropStatementContext::dropEvent() {
  return getRuleContext<MySQLParser::DropEventContext>(0);
}

MySQLParser::DropFunctionContext* MySQLParser::DropStatementContext::dropFunction() {
  return getRuleContext<MySQLParser::DropFunctionContext>(0);
}

MySQLParser::DropProcedureContext* MySQLParser::DropStatementContext::dropProcedure() {
  return getRuleContext<MySQLParser::DropProcedureContext>(0);
}

MySQLParser::DropIndexContext* MySQLParser::DropStatementContext::dropIndex() {
  return getRuleContext<MySQLParser::DropIndexContext>(0);
}

MySQLParser::DropLogfileGroupContext* MySQLParser::DropStatementContext::dropLogfileGroup() {
  return getRuleContext<MySQLParser::DropLogfileGroupContext>(0);
}

MySQLParser::DropServerContext* MySQLParser::DropStatementContext::dropServer() {
  return getRuleContext<MySQLParser::DropServerContext>(0);
}

MySQLParser::DropTableContext* MySQLParser::DropStatementContext::dropTable() {
  return getRuleContext<MySQLParser::DropTableContext>(0);
}

MySQLParser::DropTableSpaceContext* MySQLParser::DropStatementContext::dropTableSpace() {
  return getRuleContext<MySQLParser::DropTableSpaceContext>(0);
}

MySQLParser::DropTriggerContext* MySQLParser::DropStatementContext::dropTrigger() {
  return getRuleContext<MySQLParser::DropTriggerContext>(0);
}

MySQLParser::DropViewContext* MySQLParser::DropStatementContext::dropView() {
  return getRuleContext<MySQLParser::DropViewContext>(0);
}

MySQLParser::DropRoleContext* MySQLParser::DropStatementContext::dropRole() {
  return getRuleContext<MySQLParser::DropRoleContext>(0);
}

MySQLParser::DropSpatialReferenceContext* MySQLParser::DropStatementContext::dropSpatialReference() {
  return getRuleContext<MySQLParser::DropSpatialReferenceContext>(0);
}

MySQLParser::DropUndoTablespaceContext* MySQLParser::DropStatementContext::dropUndoTablespace() {
  return getRuleContext<MySQLParser::DropUndoTablespaceContext>(0);
}

MySQLParser::DropLibraryContext* MySQLParser::DropStatementContext::dropLibrary() {
  return getRuleContext<MySQLParser::DropLibraryContext>(0);
}


size_t MySQLParser::DropStatementContext::getRuleIndex() const {
  return MySQLParser::RuleDropStatement;
}

void MySQLParser::DropStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropStatement(this);
}

void MySQLParser::DropStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropStatement(this);
}


std::any MySQLParser::DropStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropStatementContext* MySQLParser::dropStatement() {
  DropStatementContext *_localctx = _tracker.createInstance<DropStatementContext>(_ctx, getState());
  enterRule(_localctx, 198, MySQLParser::RuleDropStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2899);
    match(MySQLParser::DROP_SYMBOL);
    setState(2919);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 204, _ctx)) {
    case 1: {
      setState(2900);
      dropDatabase();
      break;
    }

    case 2: {
      setState(2901);
      dropEvent();
      break;
    }

    case 3: {
      setState(2902);
      dropFunction();
      break;
    }

    case 4: {
      setState(2903);
      dropProcedure();
      break;
    }

    case 5: {
      setState(2904);
      dropIndex();
      break;
    }

    case 6: {
      setState(2905);
      dropLogfileGroup();
      break;
    }

    case 7: {
      setState(2906);
      dropServer();
      break;
    }

    case 8: {
      setState(2907);
      dropTable();
      break;
    }

    case 9: {
      setState(2908);
      dropTableSpace();
      break;
    }

    case 10: {
      setState(2909);
      dropTrigger();
      break;
    }

    case 11: {
      setState(2910);
      dropView();
      break;
    }

    case 12: {
      setState(2911);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(2912);
      dropRole();
      break;
    }

    case 13: {
      setState(2913);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(2914);
      dropSpatialReference();
      break;
    }

    case 14: {
      setState(2915);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2916);
      dropUndoTablespace();
      break;
    }

    case 15: {
      setState(2917);

      if (!(serverVersion >= 90200)) throw FailedPredicateException(this, "serverVersion >= 90200");
      setState(2918);
      dropLibrary();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropDatabaseContext ------------------------------------------------------------------

MySQLParser::DropDatabaseContext::DropDatabaseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropDatabaseContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

MySQLParser::SchemaRefContext* MySQLParser::DropDatabaseContext::schemaRef() {
  return getRuleContext<MySQLParser::SchemaRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropDatabaseContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropDatabaseContext::getRuleIndex() const {
  return MySQLParser::RuleDropDatabase;
}

void MySQLParser::DropDatabaseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropDatabase(this);
}

void MySQLParser::DropDatabaseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropDatabase(this);
}


std::any MySQLParser::DropDatabaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropDatabase(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropDatabaseContext* MySQLParser::dropDatabase() {
  DropDatabaseContext *_localctx = _tracker.createInstance<DropDatabaseContext>(_ctx, getState());
  enterRule(_localctx, 200, MySQLParser::RuleDropDatabase);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2921);
    match(MySQLParser::DATABASE_SYMBOL);
    setState(2923);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
    case 1: {
      setState(2922);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2925);
    schemaRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropEventContext ------------------------------------------------------------------

MySQLParser::DropEventContext::DropEventContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropEventContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

MySQLParser::EventRefContext* MySQLParser::DropEventContext::eventRef() {
  return getRuleContext<MySQLParser::EventRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropEventContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropEventContext::getRuleIndex() const {
  return MySQLParser::RuleDropEvent;
}

void MySQLParser::DropEventContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropEvent(this);
}

void MySQLParser::DropEventContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropEvent(this);
}


std::any MySQLParser::DropEventContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropEvent(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropEventContext* MySQLParser::dropEvent() {
  DropEventContext *_localctx = _tracker.createInstance<DropEventContext>(_ctx, getState());
  enterRule(_localctx, 202, MySQLParser::RuleDropEvent);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2927);
    match(MySQLParser::EVENT_SYMBOL);
    setState(2929);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 206, _ctx)) {
    case 1: {
      setState(2928);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2931);
    eventRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropFunctionContext ------------------------------------------------------------------

MySQLParser::DropFunctionContext::DropFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropFunctionContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

MySQLParser::FunctionRefContext* MySQLParser::DropFunctionContext::functionRef() {
  return getRuleContext<MySQLParser::FunctionRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropFunctionContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleDropFunction;
}

void MySQLParser::DropFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropFunction(this);
}

void MySQLParser::DropFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropFunction(this);
}


std::any MySQLParser::DropFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropFunctionContext* MySQLParser::dropFunction() {
  DropFunctionContext *_localctx = _tracker.createInstance<DropFunctionContext>(_ctx, getState());
  enterRule(_localctx, 204, MySQLParser::RuleDropFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2933);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(2935);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 207, _ctx)) {
    case 1: {
      setState(2934);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2937);
    functionRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropProcedureContext ------------------------------------------------------------------

MySQLParser::DropProcedureContext::DropProcedureContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropProcedureContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

MySQLParser::ProcedureRefContext* MySQLParser::DropProcedureContext::procedureRef() {
  return getRuleContext<MySQLParser::ProcedureRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropProcedureContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropProcedureContext::getRuleIndex() const {
  return MySQLParser::RuleDropProcedure;
}

void MySQLParser::DropProcedureContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropProcedure(this);
}

void MySQLParser::DropProcedureContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropProcedure(this);
}


std::any MySQLParser::DropProcedureContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropProcedure(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropProcedureContext* MySQLParser::dropProcedure() {
  DropProcedureContext *_localctx = _tracker.createInstance<DropProcedureContext>(_ctx, getState());
  enterRule(_localctx, 206, MySQLParser::RuleDropProcedure);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2939);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(2941);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 208, _ctx)) {
    case 1: {
      setState(2940);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2943);
    procedureRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropIndexContext ------------------------------------------------------------------

MySQLParser::DropIndexContext::DropIndexContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IndexRefContext* MySQLParser::DropIndexContext::indexRef() {
  return getRuleContext<MySQLParser::IndexRefContext>(0);
}

tree::TerminalNode* MySQLParser::DropIndexContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::DropIndexContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::DropIndexContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

MySQLParser::OnlineOptionContext* MySQLParser::DropIndexContext::onlineOption() {
  return getRuleContext<MySQLParser::OnlineOptionContext>(0);
}

MySQLParser::IndexLockAndAlgorithmContext* MySQLParser::DropIndexContext::indexLockAndAlgorithm() {
  return getRuleContext<MySQLParser::IndexLockAndAlgorithmContext>(0);
}


size_t MySQLParser::DropIndexContext::getRuleIndex() const {
  return MySQLParser::RuleDropIndex;
}

void MySQLParser::DropIndexContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropIndex(this);
}

void MySQLParser::DropIndexContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropIndex(this);
}


std::any MySQLParser::DropIndexContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropIndex(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropIndexContext* MySQLParser::dropIndex() {
  DropIndexContext *_localctx = _tracker.createInstance<DropIndexContext>(_ctx, getState());
  enterRule(_localctx, 208, MySQLParser::RuleDropIndex);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2946);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OFFLINE_SYMBOL

    || _la == MySQLParser::ONLINE_SYMBOL) {
      setState(2945);
      onlineOption();
    }
    setState(2948);
    antlrcpp::downCast<DropIndexContext *>(_localctx)->type = match(MySQLParser::INDEX_SYMBOL);
    setState(2949);
    indexRef();
    setState(2950);
    match(MySQLParser::ON_SYMBOL);
    setState(2951);
    tableRef();
    setState(2953);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
      setState(2952);
      indexLockAndAlgorithm();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropLogfileGroupContext ------------------------------------------------------------------

MySQLParser::DropLogfileGroupContext::DropLogfileGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropLogfileGroupContext::LOGFILE_SYMBOL() {
  return getToken(MySQLParser::LOGFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropLogfileGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::LogfileGroupRefContext* MySQLParser::DropLogfileGroupContext::logfileGroupRef() {
  return getRuleContext<MySQLParser::LogfileGroupRefContext>(0);
}

std::vector<MySQLParser::DropLogfileGroupOptionContext *> MySQLParser::DropLogfileGroupContext::dropLogfileGroupOption() {
  return getRuleContexts<MySQLParser::DropLogfileGroupOptionContext>();
}

MySQLParser::DropLogfileGroupOptionContext* MySQLParser::DropLogfileGroupContext::dropLogfileGroupOption(size_t i) {
  return getRuleContext<MySQLParser::DropLogfileGroupOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::DropLogfileGroupContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::DropLogfileGroupContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::DropLogfileGroupContext::getRuleIndex() const {
  return MySQLParser::RuleDropLogfileGroup;
}

void MySQLParser::DropLogfileGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropLogfileGroup(this);
}

void MySQLParser::DropLogfileGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropLogfileGroup(this);
}


std::any MySQLParser::DropLogfileGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropLogfileGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropLogfileGroupContext* MySQLParser::dropLogfileGroup() {
  DropLogfileGroupContext *_localctx = _tracker.createInstance<DropLogfileGroupContext>(_ctx, getState());
  enterRule(_localctx, 210, MySQLParser::RuleDropLogfileGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2955);
    match(MySQLParser::LOGFILE_SYMBOL);
    setState(2956);
    match(MySQLParser::GROUP_SYMBOL);
    setState(2957);
    logfileGroupRef();
    setState(2968);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
      setState(2958);
      dropLogfileGroupOption();
      setState(2965);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
        setState(2960);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(2959);
          match(MySQLParser::COMMA_SYMBOL);
        }
        setState(2962);
        dropLogfileGroupOption();
        setState(2967);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropLogfileGroupOptionContext ------------------------------------------------------------------

MySQLParser::DropLogfileGroupOptionContext::DropLogfileGroupOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TsOptionWaitContext* MySQLParser::DropLogfileGroupOptionContext::tsOptionWait() {
  return getRuleContext<MySQLParser::TsOptionWaitContext>(0);
}

MySQLParser::TsOptionEngineContext* MySQLParser::DropLogfileGroupOptionContext::tsOptionEngine() {
  return getRuleContext<MySQLParser::TsOptionEngineContext>(0);
}


size_t MySQLParser::DropLogfileGroupOptionContext::getRuleIndex() const {
  return MySQLParser::RuleDropLogfileGroupOption;
}

void MySQLParser::DropLogfileGroupOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropLogfileGroupOption(this);
}

void MySQLParser::DropLogfileGroupOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropLogfileGroupOption(this);
}


std::any MySQLParser::DropLogfileGroupOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropLogfileGroupOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropLogfileGroupOptionContext* MySQLParser::dropLogfileGroupOption() {
  DropLogfileGroupOptionContext *_localctx = _tracker.createInstance<DropLogfileGroupOptionContext>(_ctx, getState());
  enterRule(_localctx, 212, MySQLParser::RuleDropLogfileGroupOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2972);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::NO_WAIT_SYMBOL:
      case MySQLParser::WAIT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2970);
        tsOptionWait();
        break;
      }

      case MySQLParser::ENGINE_SYMBOL:
      case MySQLParser::STORAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2971);
        tsOptionEngine();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropServerContext ------------------------------------------------------------------

MySQLParser::DropServerContext::DropServerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropServerContext::SERVER_SYMBOL() {
  return getToken(MySQLParser::SERVER_SYMBOL, 0);
}

MySQLParser::ServerRefContext* MySQLParser::DropServerContext::serverRef() {
  return getRuleContext<MySQLParser::ServerRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropServerContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropServerContext::getRuleIndex() const {
  return MySQLParser::RuleDropServer;
}

void MySQLParser::DropServerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropServer(this);
}

void MySQLParser::DropServerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropServer(this);
}


std::any MySQLParser::DropServerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropServer(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropServerContext* MySQLParser::dropServer() {
  DropServerContext *_localctx = _tracker.createInstance<DropServerContext>(_ctx, getState());
  enterRule(_localctx, 214, MySQLParser::RuleDropServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2974);
    match(MySQLParser::SERVER_SYMBOL);
    setState(2976);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 215, _ctx)) {
    case 1: {
      setState(2975);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2978);
    serverRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropTableContext ------------------------------------------------------------------

MySQLParser::DropTableContext::DropTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefListContext* MySQLParser::DropTableContext::tableRefList() {
  return getRuleContext<MySQLParser::TableRefListContext>(0);
}

tree::TerminalNode* MySQLParser::DropTableContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropTableContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropTableContext::TEMPORARY_SYMBOL() {
  return getToken(MySQLParser::TEMPORARY_SYMBOL, 0);
}

MySQLParser::IfExistsContext* MySQLParser::DropTableContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}

tree::TerminalNode* MySQLParser::DropTableContext::RESTRICT_SYMBOL() {
  return getToken(MySQLParser::RESTRICT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropTableContext::CASCADE_SYMBOL() {
  return getToken(MySQLParser::CASCADE_SYMBOL, 0);
}


size_t MySQLParser::DropTableContext::getRuleIndex() const {
  return MySQLParser::RuleDropTable;
}

void MySQLParser::DropTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropTable(this);
}

void MySQLParser::DropTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropTable(this);
}


std::any MySQLParser::DropTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropTableContext* MySQLParser::dropTable() {
  DropTableContext *_localctx = _tracker.createInstance<DropTableContext>(_ctx, getState());
  enterRule(_localctx, 216, MySQLParser::RuleDropTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2981);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::TEMPORARY_SYMBOL) {
      setState(2980);
      match(MySQLParser::TEMPORARY_SYMBOL);
    }
    setState(2983);
    antlrcpp::downCast<DropTableContext *>(_localctx)->type = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TABLES_SYMBOL

    || _la == MySQLParser::TABLE_SYMBOL)) {
      antlrcpp::downCast<DropTableContext *>(_localctx)->type = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2985);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 217, _ctx)) {
    case 1: {
      setState(2984);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2987);
    tableRefList();
    setState(2989);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL) {
      setState(2988);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropTableSpaceContext ------------------------------------------------------------------

MySQLParser::DropTableSpaceContext::DropTableSpaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropTableSpaceContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

MySQLParser::TablespaceRefContext* MySQLParser::DropTableSpaceContext::tablespaceRef() {
  return getRuleContext<MySQLParser::TablespaceRefContext>(0);
}

std::vector<MySQLParser::DropLogfileGroupOptionContext *> MySQLParser::DropTableSpaceContext::dropLogfileGroupOption() {
  return getRuleContexts<MySQLParser::DropLogfileGroupOptionContext>();
}

MySQLParser::DropLogfileGroupOptionContext* MySQLParser::DropTableSpaceContext::dropLogfileGroupOption(size_t i) {
  return getRuleContext<MySQLParser::DropLogfileGroupOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::DropTableSpaceContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::DropTableSpaceContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::DropTableSpaceContext::getRuleIndex() const {
  return MySQLParser::RuleDropTableSpace;
}

void MySQLParser::DropTableSpaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropTableSpace(this);
}

void MySQLParser::DropTableSpaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropTableSpace(this);
}


std::any MySQLParser::DropTableSpaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropTableSpace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropTableSpaceContext* MySQLParser::dropTableSpace() {
  DropTableSpaceContext *_localctx = _tracker.createInstance<DropTableSpaceContext>(_ctx, getState());
  enterRule(_localctx, 218, MySQLParser::RuleDropTableSpace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2991);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2992);
    tablespaceRef();
    setState(3003);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
      setState(2993);
      dropLogfileGroupOption();
      setState(3000);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
        setState(2995);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(2994);
          match(MySQLParser::COMMA_SYMBOL);
        }
        setState(2997);
        dropLogfileGroupOption();
        setState(3002);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropTriggerContext ------------------------------------------------------------------

MySQLParser::DropTriggerContext::DropTriggerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropTriggerContext::TRIGGER_SYMBOL() {
  return getToken(MySQLParser::TRIGGER_SYMBOL, 0);
}

MySQLParser::TriggerRefContext* MySQLParser::DropTriggerContext::triggerRef() {
  return getRuleContext<MySQLParser::TriggerRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropTriggerContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropTriggerContext::getRuleIndex() const {
  return MySQLParser::RuleDropTrigger;
}

void MySQLParser::DropTriggerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropTrigger(this);
}

void MySQLParser::DropTriggerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropTrigger(this);
}


std::any MySQLParser::DropTriggerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropTrigger(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropTriggerContext* MySQLParser::dropTrigger() {
  DropTriggerContext *_localctx = _tracker.createInstance<DropTriggerContext>(_ctx, getState());
  enterRule(_localctx, 220, MySQLParser::RuleDropTrigger);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3005);
    match(MySQLParser::TRIGGER_SYMBOL);
    setState(3007);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 222, _ctx)) {
    case 1: {
      setState(3006);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(3009);
    triggerRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropViewContext ------------------------------------------------------------------

MySQLParser::DropViewContext::DropViewContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropViewContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

MySQLParser::ViewRefListContext* MySQLParser::DropViewContext::viewRefList() {
  return getRuleContext<MySQLParser::ViewRefListContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropViewContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}

tree::TerminalNode* MySQLParser::DropViewContext::RESTRICT_SYMBOL() {
  return getToken(MySQLParser::RESTRICT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropViewContext::CASCADE_SYMBOL() {
  return getToken(MySQLParser::CASCADE_SYMBOL, 0);
}


size_t MySQLParser::DropViewContext::getRuleIndex() const {
  return MySQLParser::RuleDropView;
}

void MySQLParser::DropViewContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropView(this);
}

void MySQLParser::DropViewContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropView(this);
}


std::any MySQLParser::DropViewContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropView(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropViewContext* MySQLParser::dropView() {
  DropViewContext *_localctx = _tracker.createInstance<DropViewContext>(_ctx, getState());
  enterRule(_localctx, 222, MySQLParser::RuleDropView);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3011);
    match(MySQLParser::VIEW_SYMBOL);
    setState(3013);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 223, _ctx)) {
    case 1: {
      setState(3012);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(3015);
    viewRefList();
    setState(3017);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL) {
      setState(3016);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropRoleContext ------------------------------------------------------------------

MySQLParser::DropRoleContext::DropRoleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropRoleContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::DropRoleContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropRoleContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropRoleContext::getRuleIndex() const {
  return MySQLParser::RuleDropRole;
}

void MySQLParser::DropRoleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropRole(this);
}

void MySQLParser::DropRoleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropRole(this);
}


std::any MySQLParser::DropRoleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropRole(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropRoleContext* MySQLParser::dropRole() {
  DropRoleContext *_localctx = _tracker.createInstance<DropRoleContext>(_ctx, getState());
  enterRule(_localctx, 224, MySQLParser::RuleDropRole);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3019);
    match(MySQLParser::ROLE_SYMBOL);
    setState(3021);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 225, _ctx)) {
    case 1: {
      setState(3020);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(3023);
    roleList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropSpatialReferenceContext ------------------------------------------------------------------

MySQLParser::DropSpatialReferenceContext::DropSpatialReferenceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropSpatialReferenceContext::SPATIAL_SYMBOL() {
  return getToken(MySQLParser::SPATIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropSpatialReferenceContext::REFERENCE_SYMBOL() {
  return getToken(MySQLParser::REFERENCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropSpatialReferenceContext::SYSTEM_SYMBOL() {
  return getToken(MySQLParser::SYSTEM_SYMBOL, 0);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::DropSpatialReferenceContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropSpatialReferenceContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropSpatialReferenceContext::getRuleIndex() const {
  return MySQLParser::RuleDropSpatialReference;
}

void MySQLParser::DropSpatialReferenceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropSpatialReference(this);
}

void MySQLParser::DropSpatialReferenceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropSpatialReference(this);
}


std::any MySQLParser::DropSpatialReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropSpatialReference(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropSpatialReferenceContext* MySQLParser::dropSpatialReference() {
  DropSpatialReferenceContext *_localctx = _tracker.createInstance<DropSpatialReferenceContext>(_ctx, getState());
  enterRule(_localctx, 226, MySQLParser::RuleDropSpatialReference);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3025);
    match(MySQLParser::SPATIAL_SYMBOL);
    setState(3026);
    match(MySQLParser::REFERENCE_SYMBOL);
    setState(3027);
    match(MySQLParser::SYSTEM_SYMBOL);
    setState(3029);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 226, _ctx)) {
    case 1: {
      setState(3028);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(3031);
    real_ulonglong_number();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropUndoTablespaceContext ------------------------------------------------------------------

MySQLParser::DropUndoTablespaceContext::DropUndoTablespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropUndoTablespaceContext::UNDO_SYMBOL() {
  return getToken(MySQLParser::UNDO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropUndoTablespaceContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

MySQLParser::TablespaceRefContext* MySQLParser::DropUndoTablespaceContext::tablespaceRef() {
  return getRuleContext<MySQLParser::TablespaceRefContext>(0);
}

MySQLParser::UndoTableSpaceOptionsContext* MySQLParser::DropUndoTablespaceContext::undoTableSpaceOptions() {
  return getRuleContext<MySQLParser::UndoTableSpaceOptionsContext>(0);
}


size_t MySQLParser::DropUndoTablespaceContext::getRuleIndex() const {
  return MySQLParser::RuleDropUndoTablespace;
}

void MySQLParser::DropUndoTablespaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropUndoTablespace(this);
}

void MySQLParser::DropUndoTablespaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropUndoTablespace(this);
}


std::any MySQLParser::DropUndoTablespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropUndoTablespace(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropUndoTablespaceContext* MySQLParser::dropUndoTablespace() {
  DropUndoTablespaceContext *_localctx = _tracker.createInstance<DropUndoTablespaceContext>(_ctx, getState());
  enterRule(_localctx, 228, MySQLParser::RuleDropUndoTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3033);
    match(MySQLParser::UNDO_SYMBOL);
    setState(3034);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(3035);
    tablespaceRef();
    setState(3037);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(3036);
      undoTableSpaceOptions();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropLibraryContext ------------------------------------------------------------------

MySQLParser::DropLibraryContext::DropLibraryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropLibraryContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropLibraryContext::LIBRARY_SYMBOL() {
  return getToken(MySQLParser::LIBRARY_SYMBOL, 0);
}

MySQLParser::LibraryRefContext* MySQLParser::DropLibraryContext::libraryRef() {
  return getRuleContext<MySQLParser::LibraryRefContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropLibraryContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropLibraryContext::getRuleIndex() const {
  return MySQLParser::RuleDropLibrary;
}

void MySQLParser::DropLibraryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropLibrary(this);
}

void MySQLParser::DropLibraryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropLibrary(this);
}


std::any MySQLParser::DropLibraryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropLibrary(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropLibraryContext* MySQLParser::dropLibrary() {
  DropLibraryContext *_localctx = _tracker.createInstance<DropLibraryContext>(_ctx, getState());
  enterRule(_localctx, 230, MySQLParser::RuleDropLibrary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3039);
    match(MySQLParser::DROP_SYMBOL);
    setState(3040);
    match(MySQLParser::LIBRARY_SYMBOL);
    setState(3042);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 228, _ctx)) {
    case 1: {
      setState(3041);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(3044);
    libraryRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RenameTableStatementContext ------------------------------------------------------------------

MySQLParser::RenameTableStatementContext::RenameTableStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RenameTableStatementContext::RENAME_SYMBOL() {
  return getToken(MySQLParser::RENAME_SYMBOL, 0);
}

std::vector<MySQLParser::RenamePairContext *> MySQLParser::RenameTableStatementContext::renamePair() {
  return getRuleContexts<MySQLParser::RenamePairContext>();
}

MySQLParser::RenamePairContext* MySQLParser::RenameTableStatementContext::renamePair(size_t i) {
  return getRuleContext<MySQLParser::RenamePairContext>(i);
}

tree::TerminalNode* MySQLParser::RenameTableStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RenameTableStatementContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::RenameTableStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::RenameTableStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::RenameTableStatementContext::getRuleIndex() const {
  return MySQLParser::RuleRenameTableStatement;
}

void MySQLParser::RenameTableStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRenameTableStatement(this);
}

void MySQLParser::RenameTableStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRenameTableStatement(this);
}


std::any MySQLParser::RenameTableStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRenameTableStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RenameTableStatementContext* MySQLParser::renameTableStatement() {
  RenameTableStatementContext *_localctx = _tracker.createInstance<RenameTableStatementContext>(_ctx, getState());
  enterRule(_localctx, 232, MySQLParser::RuleRenameTableStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3046);
    match(MySQLParser::RENAME_SYMBOL);
    setState(3047);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TABLES_SYMBOL

    || _la == MySQLParser::TABLE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(3048);
    renamePair();
    setState(3053);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3049);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3050);
      renamePair();
      setState(3055);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RenamePairContext ------------------------------------------------------------------

MySQLParser::RenamePairContext::RenamePairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::RenamePairContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::RenamePairContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::TableNameContext* MySQLParser::RenamePairContext::tableName() {
  return getRuleContext<MySQLParser::TableNameContext>(0);
}


size_t MySQLParser::RenamePairContext::getRuleIndex() const {
  return MySQLParser::RuleRenamePair;
}

void MySQLParser::RenamePairContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRenamePair(this);
}

void MySQLParser::RenamePairContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRenamePair(this);
}


std::any MySQLParser::RenamePairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRenamePair(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RenamePairContext* MySQLParser::renamePair() {
  RenamePairContext *_localctx = _tracker.createInstance<RenamePairContext>(_ctx, getState());
  enterRule(_localctx, 234, MySQLParser::RuleRenamePair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3056);
    tableRef();
    setState(3057);
    match(MySQLParser::TO_SYMBOL);
    setState(3058);
    tableName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TruncateTableStatementContext ------------------------------------------------------------------

MySQLParser::TruncateTableStatementContext::TruncateTableStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TruncateTableStatementContext::TRUNCATE_SYMBOL() {
  return getToken(MySQLParser::TRUNCATE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::TruncateTableStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::TruncateTableStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}


size_t MySQLParser::TruncateTableStatementContext::getRuleIndex() const {
  return MySQLParser::RuleTruncateTableStatement;
}

void MySQLParser::TruncateTableStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTruncateTableStatement(this);
}

void MySQLParser::TruncateTableStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTruncateTableStatement(this);
}


std::any MySQLParser::TruncateTableStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTruncateTableStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TruncateTableStatementContext* MySQLParser::truncateTableStatement() {
  TruncateTableStatementContext *_localctx = _tracker.createInstance<TruncateTableStatementContext>(_ctx, getState());
  enterRule(_localctx, 236, MySQLParser::RuleTruncateTableStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3060);
    match(MySQLParser::TRUNCATE_SYMBOL);
    setState(3062);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx)) {
    case 1: {
      setState(3061);
      match(MySQLParser::TABLE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3064);
    tableRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ImportStatementContext ------------------------------------------------------------------

MySQLParser::ImportStatementContext::ImportStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ImportStatementContext::IMPORT_SYMBOL() {
  return getToken(MySQLParser::IMPORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ImportStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ImportStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::TextStringLiteralListContext* MySQLParser::ImportStatementContext::textStringLiteralList() {
  return getRuleContext<MySQLParser::TextStringLiteralListContext>(0);
}


size_t MySQLParser::ImportStatementContext::getRuleIndex() const {
  return MySQLParser::RuleImportStatement;
}

void MySQLParser::ImportStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterImportStatement(this);
}

void MySQLParser::ImportStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitImportStatement(this);
}


std::any MySQLParser::ImportStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitImportStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ImportStatementContext* MySQLParser::importStatement() {
  ImportStatementContext *_localctx = _tracker.createInstance<ImportStatementContext>(_ctx, getState());
  enterRule(_localctx, 238, MySQLParser::RuleImportStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3066);
    match(MySQLParser::IMPORT_SYMBOL);
    setState(3067);
    match(MySQLParser::TABLE_SYMBOL);
    setState(3068);
    match(MySQLParser::FROM_SYMBOL);
    setState(3069);
    textStringLiteralList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CallStatementContext ------------------------------------------------------------------

MySQLParser::CallStatementContext::CallStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CallStatementContext::CALL_SYMBOL() {
  return getToken(MySQLParser::CALL_SYMBOL, 0);
}

MySQLParser::ProcedureRefContext* MySQLParser::CallStatementContext::procedureRef() {
  return getRuleContext<MySQLParser::ProcedureRefContext>(0);
}

tree::TerminalNode* MySQLParser::CallStatementContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CallStatementContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::CallStatementContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}


size_t MySQLParser::CallStatementContext::getRuleIndex() const {
  return MySQLParser::RuleCallStatement;
}

void MySQLParser::CallStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCallStatement(this);
}

void MySQLParser::CallStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCallStatement(this);
}


std::any MySQLParser::CallStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCallStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CallStatementContext* MySQLParser::callStatement() {
  CallStatementContext *_localctx = _tracker.createInstance<CallStatementContext>(_ctx, getState());
  enterRule(_localctx, 240, MySQLParser::RuleCallStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3071);
    match(MySQLParser::CALL_SYMBOL);
    setState(3072);
    procedureRef();
    setState(3078);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(3073);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(3075);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 231, _ctx)) {
      case 1: {
        setState(3074);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(3077);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeleteStatementContext ------------------------------------------------------------------

MySQLParser::DeleteStatementContext::DeleteStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DeleteStatementContext::DELETE_SYMBOL() {
  return getToken(MySQLParser::DELETE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::TableAliasRefListContext* MySQLParser::DeleteStatementContext::tableAliasRefList() {
  return getRuleContext<MySQLParser::TableAliasRefListContext>(0);
}

MySQLParser::TableReferenceListContext* MySQLParser::DeleteStatementContext::tableReferenceList() {
  return getRuleContext<MySQLParser::TableReferenceListContext>(0);
}

MySQLParser::WithClauseContext* MySQLParser::DeleteStatementContext::withClause() {
  return getRuleContext<MySQLParser::WithClauseContext>(0);
}

std::vector<MySQLParser::DeleteStatementOptionContext *> MySQLParser::DeleteStatementContext::deleteStatementOption() {
  return getRuleContexts<MySQLParser::DeleteStatementOptionContext>();
}

MySQLParser::DeleteStatementOptionContext* MySQLParser::DeleteStatementContext::deleteStatementOption(size_t i) {
  return getRuleContext<MySQLParser::DeleteStatementOptionContext>(i);
}

tree::TerminalNode* MySQLParser::DeleteStatementContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::DeleteStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::WhereClauseContext* MySQLParser::DeleteStatementContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}

MySQLParser::TableAliasContext* MySQLParser::DeleteStatementContext::tableAlias() {
  return getRuleContext<MySQLParser::TableAliasContext>(0);
}

MySQLParser::PartitionDeleteContext* MySQLParser::DeleteStatementContext::partitionDelete() {
  return getRuleContext<MySQLParser::PartitionDeleteContext>(0);
}

MySQLParser::OrderClauseContext* MySQLParser::DeleteStatementContext::orderClause() {
  return getRuleContext<MySQLParser::OrderClauseContext>(0);
}

MySQLParser::SimpleLimitClauseContext* MySQLParser::DeleteStatementContext::simpleLimitClause() {
  return getRuleContext<MySQLParser::SimpleLimitClauseContext>(0);
}


size_t MySQLParser::DeleteStatementContext::getRuleIndex() const {
  return MySQLParser::RuleDeleteStatement;
}

void MySQLParser::DeleteStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDeleteStatement(this);
}

void MySQLParser::DeleteStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDeleteStatement(this);
}


std::any MySQLParser::DeleteStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDeleteStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DeleteStatementContext* MySQLParser::deleteStatement() {
  DeleteStatementContext *_localctx = _tracker.createInstance<DeleteStatementContext>(_ctx, getState());
  enterRule(_localctx, 242, MySQLParser::RuleDeleteStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3082);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 233, _ctx)) {
    case 1: {
      setState(3080);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3081);
      withClause();
      break;
    }

    default:
      break;
    }
    setState(3084);
    match(MySQLParser::DELETE_SYMBOL);
    setState(3088);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3085);
        deleteStatementOption(); 
      }
      setState(3090);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx);
    }
    setState(3123);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 243, _ctx)) {
    case 1: {
      setState(3091);
      match(MySQLParser::FROM_SYMBOL);
      setState(3115);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 241, _ctx)) {
      case 1: {
        setState(3092);
        tableAliasRefList();
        setState(3093);
        match(MySQLParser::USING_SYMBOL);
        setState(3094);
        tableReferenceList();
        setState(3096);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WHERE_SYMBOL) {
          setState(3095);
          whereClause();
        }
        break;
      }

      case 2: {
        setState(3098);
        tableRef();
        setState(3101);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 236, _ctx)) {
        case 1: {
          setState(3099);

          if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
          setState(3100);
          tableAlias();
          break;
        }

        default:
          break;
        }
        setState(3104);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::PARTITION_SYMBOL) {
          setState(3103);
          partitionDelete();
        }
        setState(3107);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WHERE_SYMBOL) {
          setState(3106);
          whereClause();
        }
        setState(3110);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ORDER_SYMBOL) {
          setState(3109);
          orderClause();
        }
        setState(3113);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LIMIT_SYMBOL) {
          setState(3112);
          simpleLimitClause();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(3117);
      tableAliasRefList();
      setState(3118);
      match(MySQLParser::FROM_SYMBOL);
      setState(3119);
      tableReferenceList();
      setState(3121);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WHERE_SYMBOL) {
        setState(3120);
        whereClause();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionDeleteContext ------------------------------------------------------------------

MySQLParser::PartitionDeleteContext::PartitionDeleteContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PartitionDeleteContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDeleteContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::PartitionDeleteContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionDeleteContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::PartitionDeleteContext::getRuleIndex() const {
  return MySQLParser::RulePartitionDelete;
}

void MySQLParser::PartitionDeleteContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionDelete(this);
}

void MySQLParser::PartitionDeleteContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionDelete(this);
}


std::any MySQLParser::PartitionDeleteContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionDelete(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionDeleteContext* MySQLParser::partitionDelete() {
  PartitionDeleteContext *_localctx = _tracker.createInstance<PartitionDeleteContext>(_ctx, getState());
  enterRule(_localctx, 244, MySQLParser::RulePartitionDelete);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3125);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(3126);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3127);
    identifierList();
    setState(3128);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeleteStatementOptionContext ------------------------------------------------------------------

MySQLParser::DeleteStatementOptionContext::DeleteStatementOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DeleteStatementOptionContext::QUICK_SYMBOL() {
  return getToken(MySQLParser::QUICK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteStatementOptionContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteStatementOptionContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}


size_t MySQLParser::DeleteStatementOptionContext::getRuleIndex() const {
  return MySQLParser::RuleDeleteStatementOption;
}

void MySQLParser::DeleteStatementOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDeleteStatementOption(this);
}

void MySQLParser::DeleteStatementOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDeleteStatementOption(this);
}


std::any MySQLParser::DeleteStatementOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDeleteStatementOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DeleteStatementOptionContext* MySQLParser::deleteStatementOption() {
  DeleteStatementOptionContext *_localctx = _tracker.createInstance<DeleteStatementOptionContext>(_ctx, getState());
  enterRule(_localctx, 246, MySQLParser::RuleDeleteStatementOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3130);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::IGNORE_SYMBOL

    || _la == MySQLParser::LOW_PRIORITY_SYMBOL || _la == MySQLParser::QUICK_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DoStatementContext ------------------------------------------------------------------

MySQLParser::DoStatementContext::DoStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DoStatementContext::DO_SYMBOL() {
  return getToken(MySQLParser::DO_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::DoStatementContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

MySQLParser::SelectItemListContext* MySQLParser::DoStatementContext::selectItemList() {
  return getRuleContext<MySQLParser::SelectItemListContext>(0);
}


size_t MySQLParser::DoStatementContext::getRuleIndex() const {
  return MySQLParser::RuleDoStatement;
}

void MySQLParser::DoStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDoStatement(this);
}

void MySQLParser::DoStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDoStatement(this);
}


std::any MySQLParser::DoStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDoStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DoStatementContext* MySQLParser::doStatement() {
  DoStatementContext *_localctx = _tracker.createInstance<DoStatementContext>(_ctx, getState());
  enterRule(_localctx, 248, MySQLParser::RuleDoStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3132);
    match(MySQLParser::DO_SYMBOL);
    setState(3137);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 244, _ctx)) {
    case 1: {
      setState(3133);

      if (!(serverVersion < 50709)) throw FailedPredicateException(this, "serverVersion < 50709");
      setState(3134);
      exprList();
      break;
    }

    case 2: {
      setState(3135);

      if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
      setState(3136);
      selectItemList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HandlerStatementContext ------------------------------------------------------------------

MySQLParser::HandlerStatementContext::HandlerStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HandlerStatementContext::HANDLER_SYMBOL() {
  return getToken(MySQLParser::HANDLER_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::HandlerStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerStatementContext::OPEN_SYMBOL() {
  return getToken(MySQLParser::OPEN_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::HandlerStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerStatementContext::CLOSE_SYMBOL() {
  return getToken(MySQLParser::CLOSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerStatementContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

MySQLParser::HandlerReadOrScanContext* MySQLParser::HandlerStatementContext::handlerReadOrScan() {
  return getRuleContext<MySQLParser::HandlerReadOrScanContext>(0);
}

MySQLParser::TableAliasContext* MySQLParser::HandlerStatementContext::tableAlias() {
  return getRuleContext<MySQLParser::TableAliasContext>(0);
}

MySQLParser::WhereClauseContext* MySQLParser::HandlerStatementContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}

MySQLParser::LimitClauseContext* MySQLParser::HandlerStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}


size_t MySQLParser::HandlerStatementContext::getRuleIndex() const {
  return MySQLParser::RuleHandlerStatement;
}

void MySQLParser::HandlerStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHandlerStatement(this);
}

void MySQLParser::HandlerStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHandlerStatement(this);
}


std::any MySQLParser::HandlerStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHandlerStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HandlerStatementContext* MySQLParser::handlerStatement() {
  HandlerStatementContext *_localctx = _tracker.createInstance<HandlerStatementContext>(_ctx, getState());
  enterRule(_localctx, 250, MySQLParser::RuleHandlerStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3139);
    match(MySQLParser::HANDLER_SYMBOL);
    setState(3157);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 249, _ctx)) {
    case 1: {
      setState(3140);
      tableRef();
      setState(3141);
      match(MySQLParser::OPEN_SYMBOL);
      setState(3143);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx)) {
      case 1: {
        setState(3142);
        tableAlias();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(3145);
      identifier();
      setState(3155);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::CLOSE_SYMBOL: {
          setState(3146);
          match(MySQLParser::CLOSE_SYMBOL);
          break;
        }

        case MySQLParser::READ_SYMBOL: {
          setState(3147);
          match(MySQLParser::READ_SYMBOL);
          setState(3148);
          handlerReadOrScan();
          setState(3150);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::WHERE_SYMBOL) {
            setState(3149);
            whereClause();
          }
          setState(3153);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::LIMIT_SYMBOL) {
            setState(3152);
            limitClause();
          }
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HandlerReadOrScanContext ------------------------------------------------------------------

MySQLParser::HandlerReadOrScanContext::HandlerReadOrScanContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::FIRST_SYMBOL() {
  return getToken(MySQLParser::FIRST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::NEXT_SYMBOL() {
  return getToken(MySQLParser::NEXT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::HandlerReadOrScanContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ValuesContext* MySQLParser::HandlerReadOrScanContext::values() {
  return getRuleContext<MySQLParser::ValuesContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::PREV_SYMBOL() {
  return getToken(MySQLParser::PREV_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::LAST_SYMBOL() {
  return getToken(MySQLParser::LAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::LESS_THAN_OPERATOR() {
  return getToken(MySQLParser::LESS_THAN_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::GREATER_THAN_OPERATOR() {
  return getToken(MySQLParser::GREATER_THAN_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::LESS_OR_EQUAL_OPERATOR() {
  return getToken(MySQLParser::LESS_OR_EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::HandlerReadOrScanContext::GREATER_OR_EQUAL_OPERATOR() {
  return getToken(MySQLParser::GREATER_OR_EQUAL_OPERATOR, 0);
}


size_t MySQLParser::HandlerReadOrScanContext::getRuleIndex() const {
  return MySQLParser::RuleHandlerReadOrScan;
}

void MySQLParser::HandlerReadOrScanContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHandlerReadOrScan(this);
}

void MySQLParser::HandlerReadOrScanContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHandlerReadOrScan(this);
}


std::any MySQLParser::HandlerReadOrScanContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHandlerReadOrScan(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HandlerReadOrScanContext* MySQLParser::handlerReadOrScan() {
  HandlerReadOrScanContext *_localctx = _tracker.createInstance<HandlerReadOrScanContext>(_ctx, getState());
  enterRule(_localctx, 252, MySQLParser::RuleHandlerReadOrScan);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3169);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3159);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::FIRST_SYMBOL || _la == MySQLParser::NEXT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3160);
      identifier();
      setState(3167);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::FIRST_SYMBOL:
        case MySQLParser::LAST_SYMBOL:
        case MySQLParser::NEXT_SYMBOL:
        case MySQLParser::PREV_SYMBOL: {
          setState(3161);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::FIRST_SYMBOL || _la == MySQLParser::LAST_SYMBOL || _la == MySQLParser::NEXT_SYMBOL

          || _la == MySQLParser::PREV_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          break;
        }

        case MySQLParser::EQUAL_OPERATOR:
        case MySQLParser::GREATER_OR_EQUAL_OPERATOR:
        case MySQLParser::GREATER_THAN_OPERATOR:
        case MySQLParser::LESS_OR_EQUAL_OPERATOR:
        case MySQLParser::LESS_THAN_OPERATOR: {
          setState(3162);
          _la = _input->LA(1);
          if (!((((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & ((1ULL << MySQLParser::EQUAL_OPERATOR)
            | (1ULL << MySQLParser::GREATER_OR_EQUAL_OPERATOR)
            | (1ULL << MySQLParser::GREATER_THAN_OPERATOR)
            | (1ULL << MySQLParser::LESS_OR_EQUAL_OPERATOR)
            | (1ULL << MySQLParser::LESS_THAN_OPERATOR))) != 0))) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(3163);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(3164);
          values();
          setState(3165);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertStatementContext ------------------------------------------------------------------

MySQLParser::InsertStatementContext::InsertStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InsertStatementContext::INSERT_SYMBOL() {
  return getToken(MySQLParser::INSERT_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::InsertStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::InsertFromConstructorContext* MySQLParser::InsertStatementContext::insertFromConstructor() {
  return getRuleContext<MySQLParser::InsertFromConstructorContext>(0);
}

tree::TerminalNode* MySQLParser::InsertStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

MySQLParser::UpdateListContext* MySQLParser::InsertStatementContext::updateList() {
  return getRuleContext<MySQLParser::UpdateListContext>(0);
}

MySQLParser::InsertQueryExpressionContext* MySQLParser::InsertStatementContext::insertQueryExpression() {
  return getRuleContext<MySQLParser::InsertQueryExpressionContext>(0);
}

MySQLParser::InsertLockOptionContext* MySQLParser::InsertStatementContext::insertLockOption() {
  return getRuleContext<MySQLParser::InsertLockOptionContext>(0);
}

tree::TerminalNode* MySQLParser::InsertStatementContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertStatementContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

MySQLParser::UsePartitionContext* MySQLParser::InsertStatementContext::usePartition() {
  return getRuleContext<MySQLParser::UsePartitionContext>(0);
}

MySQLParser::InsertUpdateListContext* MySQLParser::InsertStatementContext::insertUpdateList() {
  return getRuleContext<MySQLParser::InsertUpdateListContext>(0);
}

MySQLParser::ValuesReferenceContext* MySQLParser::InsertStatementContext::valuesReference() {
  return getRuleContext<MySQLParser::ValuesReferenceContext>(0);
}


size_t MySQLParser::InsertStatementContext::getRuleIndex() const {
  return MySQLParser::RuleInsertStatement;
}

void MySQLParser::InsertStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertStatement(this);
}

void MySQLParser::InsertStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertStatement(this);
}


std::any MySQLParser::InsertStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertStatementContext* MySQLParser::insertStatement() {
  InsertStatementContext *_localctx = _tracker.createInstance<InsertStatementContext>(_ctx, getState());
  enterRule(_localctx, 254, MySQLParser::RuleInsertStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3171);
    match(MySQLParser::INSERT_SYMBOL);
    setState(3173);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      setState(3172);
      insertLockOption();
      break;
    }

    default:
      break;
    }
    setState(3176);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx)) {
    case 1: {
      setState(3175);
      match(MySQLParser::IGNORE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3179);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 254, _ctx)) {
    case 1: {
      setState(3178);
      match(MySQLParser::INTO_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3181);
    tableRef();
    setState(3183);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 255, _ctx)) {
    case 1: {
      setState(3182);
      usePartition();
      break;
    }

    default:
      break;
    }
    setState(3195);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 258, _ctx)) {
    case 1: {
      setState(3185);
      insertFromConstructor();
      setState(3187);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 256, _ctx)) {
      case 1: {
        setState(3186);
        valuesReference();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(3189);
      match(MySQLParser::SET_SYMBOL);
      setState(3190);
      updateList();
      setState(3192);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 257, _ctx)) {
      case 1: {
        setState(3191);
        valuesReference();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      setState(3194);
      insertQueryExpression();
      break;
    }

    default:
      break;
    }
    setState(3198);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ON_SYMBOL) {
      setState(3197);
      insertUpdateList();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertLockOptionContext ------------------------------------------------------------------

MySQLParser::InsertLockOptionContext::InsertLockOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InsertLockOptionContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertLockOptionContext::DELAYED_SYMBOL() {
  return getToken(MySQLParser::DELAYED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertLockOptionContext::HIGH_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::HIGH_PRIORITY_SYMBOL, 0);
}


size_t MySQLParser::InsertLockOptionContext::getRuleIndex() const {
  return MySQLParser::RuleInsertLockOption;
}

void MySQLParser::InsertLockOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertLockOption(this);
}

void MySQLParser::InsertLockOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertLockOption(this);
}


std::any MySQLParser::InsertLockOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertLockOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertLockOptionContext* MySQLParser::insertLockOption() {
  InsertLockOptionContext *_localctx = _tracker.createInstance<InsertLockOptionContext>(_ctx, getState());
  enterRule(_localctx, 256, MySQLParser::RuleInsertLockOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3200);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DELAYED_SYMBOL || _la == MySQLParser::HIGH_PRIORITY_SYMBOL || _la == MySQLParser::LOW_PRIORITY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertFromConstructorContext ------------------------------------------------------------------

MySQLParser::InsertFromConstructorContext::InsertFromConstructorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::InsertValuesContext* MySQLParser::InsertFromConstructorContext::insertValues() {
  return getRuleContext<MySQLParser::InsertValuesContext>(0);
}

tree::TerminalNode* MySQLParser::InsertFromConstructorContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertFromConstructorContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::FieldsContext* MySQLParser::InsertFromConstructorContext::fields() {
  return getRuleContext<MySQLParser::FieldsContext>(0);
}


size_t MySQLParser::InsertFromConstructorContext::getRuleIndex() const {
  return MySQLParser::RuleInsertFromConstructor;
}

void MySQLParser::InsertFromConstructorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertFromConstructor(this);
}

void MySQLParser::InsertFromConstructorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertFromConstructor(this);
}


std::any MySQLParser::InsertFromConstructorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertFromConstructor(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertFromConstructorContext* MySQLParser::insertFromConstructor() {
  InsertFromConstructorContext *_localctx = _tracker.createInstance<InsertFromConstructorContext>(_ctx, getState());
  enterRule(_localctx, 258, MySQLParser::RuleInsertFromConstructor);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3207);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(3202);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(3204);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 260, _ctx)) {
      case 1: {
        setState(3203);
        fields();
        break;
      }

      default:
        break;
      }
      setState(3206);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
    }
    setState(3209);
    insertValues();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldsContext ------------------------------------------------------------------

MySQLParser::FieldsContext::FieldsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::InsertIdentifierContext *> MySQLParser::FieldsContext::insertIdentifier() {
  return getRuleContexts<MySQLParser::InsertIdentifierContext>();
}

MySQLParser::InsertIdentifierContext* MySQLParser::FieldsContext::insertIdentifier(size_t i) {
  return getRuleContext<MySQLParser::InsertIdentifierContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::FieldsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::FieldsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::FieldsContext::getRuleIndex() const {
  return MySQLParser::RuleFields;
}

void MySQLParser::FieldsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFields(this);
}

void MySQLParser::FieldsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFields(this);
}


std::any MySQLParser::FieldsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFields(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldsContext* MySQLParser::fields() {
  FieldsContext *_localctx = _tracker.createInstance<FieldsContext>(_ctx, getState());
  enterRule(_localctx, 260, MySQLParser::RuleFields);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3211);
    insertIdentifier();
    setState(3216);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3212);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3213);
      insertIdentifier();
      setState(3218);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertValuesContext ------------------------------------------------------------------

MySQLParser::InsertValuesContext::InsertValuesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ValueListContext* MySQLParser::InsertValuesContext::valueList() {
  return getRuleContext<MySQLParser::ValueListContext>(0);
}

tree::TerminalNode* MySQLParser::InsertValuesContext::VALUES_SYMBOL() {
  return getToken(MySQLParser::VALUES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertValuesContext::VALUE_SYMBOL() {
  return getToken(MySQLParser::VALUE_SYMBOL, 0);
}


size_t MySQLParser::InsertValuesContext::getRuleIndex() const {
  return MySQLParser::RuleInsertValues;
}

void MySQLParser::InsertValuesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertValues(this);
}

void MySQLParser::InsertValuesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertValues(this);
}


std::any MySQLParser::InsertValuesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertValues(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertValuesContext* MySQLParser::insertValues() {
  InsertValuesContext *_localctx = _tracker.createInstance<InsertValuesContext>(_ctx, getState());
  enterRule(_localctx, 262, MySQLParser::RuleInsertValues);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3219);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::VALUES_SYMBOL

    || _la == MySQLParser::VALUE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(3220);
    valueList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertQueryExpressionContext ------------------------------------------------------------------

MySQLParser::InsertQueryExpressionContext::InsertQueryExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionContext* MySQLParser::InsertQueryExpressionContext::queryExpression() {
  return getRuleContext<MySQLParser::QueryExpressionContext>(0);
}

MySQLParser::QueryExpressionParensContext* MySQLParser::InsertQueryExpressionContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}

MySQLParser::QueryExpressionWithOptLockingClausesContext* MySQLParser::InsertQueryExpressionContext::queryExpressionWithOptLockingClauses() {
  return getRuleContext<MySQLParser::QueryExpressionWithOptLockingClausesContext>(0);
}

tree::TerminalNode* MySQLParser::InsertQueryExpressionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertQueryExpressionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::FieldsContext* MySQLParser::InsertQueryExpressionContext::fields() {
  return getRuleContext<MySQLParser::FieldsContext>(0);
}


size_t MySQLParser::InsertQueryExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleInsertQueryExpression;
}

void MySQLParser::InsertQueryExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertQueryExpression(this);
}

void MySQLParser::InsertQueryExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertQueryExpression(this);
}


std::any MySQLParser::InsertQueryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertQueryExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertQueryExpressionContext* MySQLParser::insertQueryExpression() {
  InsertQueryExpressionContext *_localctx = _tracker.createInstance<InsertQueryExpressionContext>(_ctx, getState());
  enterRule(_localctx, 264, MySQLParser::RuleInsertQueryExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3232);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 265, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3222);
      queryExpression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3223);
      queryExpressionParens();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3229);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 264, _ctx)) {
      case 1: {
        setState(3224);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(3226);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 263, _ctx)) {
        case 1: {
          setState(3225);
          fields();
          break;
        }

        default:
          break;
        }
        setState(3228);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(3231);
      queryExpressionWithOptLockingClauses();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ValueListContext ------------------------------------------------------------------

MySQLParser::ValueListContext::ValueListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::ValueListContext::OPEN_PAR_SYMBOL() {
  return getTokens(MySQLParser::OPEN_PAR_SYMBOL);
}

tree::TerminalNode* MySQLParser::ValueListContext::OPEN_PAR_SYMBOL(size_t i) {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::ValueListContext::CLOSE_PAR_SYMBOL() {
  return getTokens(MySQLParser::CLOSE_PAR_SYMBOL);
}

tree::TerminalNode* MySQLParser::ValueListContext::CLOSE_PAR_SYMBOL(size_t i) {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, i);
}

std::vector<MySQLParser::ValuesContext *> MySQLParser::ValueListContext::values() {
  return getRuleContexts<MySQLParser::ValuesContext>();
}

MySQLParser::ValuesContext* MySQLParser::ValueListContext::values(size_t i) {
  return getRuleContext<MySQLParser::ValuesContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ValueListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ValueListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ValueListContext::getRuleIndex() const {
  return MySQLParser::RuleValueList;
}

void MySQLParser::ValueListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterValueList(this);
}

void MySQLParser::ValueListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitValueList(this);
}


std::any MySQLParser::ValueListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitValueList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ValueListContext* MySQLParser::valueList() {
  ValueListContext *_localctx = _tracker.createInstance<ValueListContext>(_ctx, getState());
  enterRule(_localctx, 266, MySQLParser::RuleValueList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3234);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3236);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 266, _ctx)) {
    case 1: {
      setState(3235);
      values();
      break;
    }

    default:
      break;
    }
    setState(3238);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(3247);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 268, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3239);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3240);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(3242);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 267, _ctx)) {
        case 1: {
          setState(3241);
          values();
          break;
        }

        default:
          break;
        }
        setState(3244);
        match(MySQLParser::CLOSE_PAR_SYMBOL); 
      }
      setState(3249);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 268, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ValuesContext ------------------------------------------------------------------

MySQLParser::ValuesContext::ValuesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::ExprContext *> MySQLParser::ValuesContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::ValuesContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ValuesContext::DEFAULT_SYMBOL() {
  return getTokens(MySQLParser::DEFAULT_SYMBOL);
}

tree::TerminalNode* MySQLParser::ValuesContext::DEFAULT_SYMBOL(size_t i) {
  return getToken(MySQLParser::DEFAULT_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::ValuesContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ValuesContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ValuesContext::getRuleIndex() const {
  return MySQLParser::RuleValues;
}

void MySQLParser::ValuesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterValues(this);
}

void MySQLParser::ValuesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitValues(this);
}


std::any MySQLParser::ValuesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitValues(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ValuesContext* MySQLParser::values() {
  ValuesContext *_localctx = _tracker.createInstance<ValuesContext>(_ctx, getState());
  enterRule(_localctx, 268, MySQLParser::RuleValues);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3252);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 269, _ctx)) {
    case 1: {
      setState(3250);
      expr(0);
      break;
    }

    case 2: {
      setState(3251);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3261);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3254);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3257);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 270, _ctx)) {
      case 1: {
        setState(3255);
        expr(0);
        break;
      }

      case 2: {
        setState(3256);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(3263);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ValuesReferenceContext ------------------------------------------------------------------

MySQLParser::ValuesReferenceContext::ValuesReferenceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ValuesReferenceContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::ValuesReferenceContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::ColumnInternalRefListContext* MySQLParser::ValuesReferenceContext::columnInternalRefList() {
  return getRuleContext<MySQLParser::ColumnInternalRefListContext>(0);
}


size_t MySQLParser::ValuesReferenceContext::getRuleIndex() const {
  return MySQLParser::RuleValuesReference;
}

void MySQLParser::ValuesReferenceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterValuesReference(this);
}

void MySQLParser::ValuesReferenceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitValuesReference(this);
}


std::any MySQLParser::ValuesReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitValuesReference(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ValuesReferenceContext* MySQLParser::valuesReference() {
  ValuesReferenceContext *_localctx = _tracker.createInstance<ValuesReferenceContext>(_ctx, getState());
  enterRule(_localctx, 270, MySQLParser::RuleValuesReference);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3264);

    if (!( serverVersion >= 80018)) throw FailedPredicateException(this, " serverVersion >= 80018");
    setState(3265);
    match(MySQLParser::AS_SYMBOL);
    setState(3266);
    identifier();
    setState(3268);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(3267);
      columnInternalRefList();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertUpdateListContext ------------------------------------------------------------------

MySQLParser::InsertUpdateListContext::InsertUpdateListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InsertUpdateListContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertUpdateListContext::DUPLICATE_SYMBOL() {
  return getToken(MySQLParser::DUPLICATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertUpdateListContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InsertUpdateListContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

MySQLParser::UpdateListContext* MySQLParser::InsertUpdateListContext::updateList() {
  return getRuleContext<MySQLParser::UpdateListContext>(0);
}


size_t MySQLParser::InsertUpdateListContext::getRuleIndex() const {
  return MySQLParser::RuleInsertUpdateList;
}

void MySQLParser::InsertUpdateListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertUpdateList(this);
}

void MySQLParser::InsertUpdateListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertUpdateList(this);
}


std::any MySQLParser::InsertUpdateListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertUpdateList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertUpdateListContext* MySQLParser::insertUpdateList() {
  InsertUpdateListContext *_localctx = _tracker.createInstance<InsertUpdateListContext>(_ctx, getState());
  enterRule(_localctx, 272, MySQLParser::RuleInsertUpdateList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3270);
    match(MySQLParser::ON_SYMBOL);
    setState(3271);
    match(MySQLParser::DUPLICATE_SYMBOL);
    setState(3272);
    match(MySQLParser::KEY_SYMBOL);
    setState(3273);
    match(MySQLParser::UPDATE_SYMBOL);
    setState(3274);
    updateList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadStatementContext ------------------------------------------------------------------

MySQLParser::LoadStatementContext::LoadStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadStatementContext::LOAD_SYMBOL() {
  return getToken(MySQLParser::LOAD_SYMBOL, 0);
}

MySQLParser::DataOrXmlContext* MySQLParser::LoadStatementContext::dataOrXml() {
  return getRuleContext<MySQLParser::DataOrXmlContext>(0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::LoadStatementContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::LoadStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::LoadDataFileTailContext* MySQLParser::LoadStatementContext::loadDataFileTail() {
  return getRuleContext<MySQLParser::LoadDataFileTailContext>(0);
}

MySQLParser::LoadDataLockContext* MySQLParser::LoadStatementContext::loadDataLock() {
  return getRuleContext<MySQLParser::LoadDataLockContext>(0);
}

MySQLParser::LoadFromContext* MySQLParser::LoadStatementContext::loadFrom() {
  return getRuleContext<MySQLParser::LoadFromContext>(0);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

MySQLParser::LoadSourceTypeContext* MySQLParser::LoadStatementContext::loadSourceType() {
  return getRuleContext<MySQLParser::LoadSourceTypeContext>(0);
}

MySQLParser::SourceCountContext* MySQLParser::LoadStatementContext::sourceCount() {
  return getRuleContext<MySQLParser::SourceCountContext>(0);
}

MySQLParser::SourceOrderContext* MySQLParser::LoadStatementContext::sourceOrder() {
  return getRuleContext<MySQLParser::SourceOrderContext>(0);
}

MySQLParser::UsePartitionContext* MySQLParser::LoadStatementContext::usePartition() {
  return getRuleContext<MySQLParser::UsePartitionContext>(0);
}

MySQLParser::CompressionAlgorithmContext* MySQLParser::LoadStatementContext::compressionAlgorithm() {
  return getRuleContext<MySQLParser::CompressionAlgorithmContext>(0);
}

MySQLParser::CharsetClauseContext* MySQLParser::LoadStatementContext::charsetClause() {
  return getRuleContext<MySQLParser::CharsetClauseContext>(0);
}

MySQLParser::XmlRowsIdentifiedByContext* MySQLParser::LoadStatementContext::xmlRowsIdentifiedBy() {
  return getRuleContext<MySQLParser::XmlRowsIdentifiedByContext>(0);
}

MySQLParser::FieldsClauseContext* MySQLParser::LoadStatementContext::fieldsClause() {
  return getRuleContext<MySQLParser::FieldsClauseContext>(0);
}

MySQLParser::LinesClauseContext* MySQLParser::LoadStatementContext::linesClause() {
  return getRuleContext<MySQLParser::LinesClauseContext>(0);
}

MySQLParser::LoadParallelContext* MySQLParser::LoadStatementContext::loadParallel() {
  return getRuleContext<MySQLParser::LoadParallelContext>(0);
}

MySQLParser::LoadMemoryContext* MySQLParser::LoadStatementContext::loadMemory() {
  return getRuleContext<MySQLParser::LoadMemoryContext>(0);
}

MySQLParser::LoadAlgorithmContext* MySQLParser::LoadStatementContext::loadAlgorithm() {
  return getRuleContext<MySQLParser::LoadAlgorithmContext>(0);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}


size_t MySQLParser::LoadStatementContext::getRuleIndex() const {
  return MySQLParser::RuleLoadStatement;
}

void MySQLParser::LoadStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadStatement(this);
}

void MySQLParser::LoadStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadStatement(this);
}


std::any MySQLParser::LoadStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadStatementContext* MySQLParser::loadStatement() {
  LoadStatementContext *_localctx = _tracker.createInstance<LoadStatementContext>(_ctx, getState());
  enterRule(_localctx, 274, MySQLParser::RuleLoadStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3276);
    match(MySQLParser::LOAD_SYMBOL);
    setState(3277);
    dataOrXml();
    setState(3279);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 273, _ctx)) {
    case 1: {
      setState(3278);
      loadDataLock();
      break;
    }

    default:
      break;
    }
    setState(3282);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 274, _ctx)) {
    case 1: {
      setState(3281);
      loadFrom();
      break;
    }

    default:
      break;
    }
    setState(3285);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 275, _ctx)) {
    case 1: {
      setState(3284);
      match(MySQLParser::LOCAL_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3288);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 276, _ctx)) {
    case 1: {
      setState(3287);
      loadSourceType();
      break;
    }

    default:
      break;
    }
    setState(3290);
    textStringLiteral();
    setState(3292);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 277, _ctx)) {
    case 1: {
      setState(3291);
      sourceCount();
      break;
    }

    default:
      break;
    }
    setState(3295);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 278, _ctx)) {
    case 1: {
      setState(3294);
      sourceOrder();
      break;
    }

    default:
      break;
    }
    setState(3298);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::REPLACE_SYMBOL) {
      setState(3297);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::REPLACE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(3300);
    match(MySQLParser::INTO_SYMBOL);
    setState(3301);
    match(MySQLParser::TABLE_SYMBOL);
    setState(3302);
    tableRef();
    setState(3304);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 280, _ctx)) {
    case 1: {
      setState(3303);
      usePartition();
      break;
    }

    default:
      break;
    }
    setState(3308);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 281, _ctx)) {
    case 1: {
      setState(3306);

      if (!( serverVersion >= 80400)) throw FailedPredicateException(this, " serverVersion >= 80400");
      setState(3307);
      compressionAlgorithm();
      break;
    }

    default:
      break;
    }
    setState(3311);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 282, _ctx)) {
    case 1: {
      setState(3310);
      charsetClause();
      break;
    }

    default:
      break;
    }
    setState(3314);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 283, _ctx)) {
    case 1: {
      setState(3313);
      xmlRowsIdentifiedBy();
      break;
    }

    default:
      break;
    }
    setState(3317);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 284, _ctx)) {
    case 1: {
      setState(3316);
      fieldsClause();
      break;
    }

    default:
      break;
    }
    setState(3320);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 285, _ctx)) {
    case 1: {
      setState(3319);
      linesClause();
      break;
    }

    default:
      break;
    }
    setState(3322);
    loadDataFileTail();
    setState(3324);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 286, _ctx)) {
    case 1: {
      setState(3323);
      loadParallel();
      break;
    }

    default:
      break;
    }
    setState(3327);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 287, _ctx)) {
    case 1: {
      setState(3326);
      loadMemory();
      break;
    }

    default:
      break;
    }
    setState(3330);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 288, _ctx)) {
    case 1: {
      setState(3329);
      loadAlgorithm();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DataOrXmlContext ------------------------------------------------------------------

MySQLParser::DataOrXmlContext::DataOrXmlContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DataOrXmlContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataOrXmlContext::XML_SYMBOL() {
  return getToken(MySQLParser::XML_SYMBOL, 0);
}


size_t MySQLParser::DataOrXmlContext::getRuleIndex() const {
  return MySQLParser::RuleDataOrXml;
}

void MySQLParser::DataOrXmlContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDataOrXml(this);
}

void MySQLParser::DataOrXmlContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDataOrXml(this);
}


std::any MySQLParser::DataOrXmlContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDataOrXml(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DataOrXmlContext* MySQLParser::dataOrXml() {
  DataOrXmlContext *_localctx = _tracker.createInstance<DataOrXmlContext>(_ctx, getState());
  enterRule(_localctx, 276, MySQLParser::RuleDataOrXml);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3332);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DATA_SYMBOL || _la == MySQLParser::XML_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadDataLockContext ------------------------------------------------------------------

MySQLParser::LoadDataLockContext::LoadDataLockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadDataLockContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadDataLockContext::CONCURRENT_SYMBOL() {
  return getToken(MySQLParser::CONCURRENT_SYMBOL, 0);
}


size_t MySQLParser::LoadDataLockContext::getRuleIndex() const {
  return MySQLParser::RuleLoadDataLock;
}

void MySQLParser::LoadDataLockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadDataLock(this);
}

void MySQLParser::LoadDataLockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadDataLock(this);
}


std::any MySQLParser::LoadDataLockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadDataLock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadDataLockContext* MySQLParser::loadDataLock() {
  LoadDataLockContext *_localctx = _tracker.createInstance<LoadDataLockContext>(_ctx, getState());
  enterRule(_localctx, 278, MySQLParser::RuleLoadDataLock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3334);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::CONCURRENT_SYMBOL || _la == MySQLParser::LOW_PRIORITY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadFromContext ------------------------------------------------------------------

MySQLParser::LoadFromContext::LoadFromContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadFromContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}


size_t MySQLParser::LoadFromContext::getRuleIndex() const {
  return MySQLParser::RuleLoadFrom;
}

void MySQLParser::LoadFromContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadFrom(this);
}

void MySQLParser::LoadFromContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadFrom(this);
}


std::any MySQLParser::LoadFromContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadFrom(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadFromContext* MySQLParser::loadFrom() {
  LoadFromContext *_localctx = _tracker.createInstance<LoadFromContext>(_ctx, getState());
  enterRule(_localctx, 280, MySQLParser::RuleLoadFrom);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3336);

    if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
    setState(3337);
    match(MySQLParser::FROM_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadSourceTypeContext ------------------------------------------------------------------

MySQLParser::LoadSourceTypeContext::LoadSourceTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadSourceTypeContext::INFILE_SYMBOL() {
  return getToken(MySQLParser::INFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadSourceTypeContext::URL_SYMBOL() {
  return getToken(MySQLParser::URL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadSourceTypeContext::S3_SYMBOL() {
  return getToken(MySQLParser::S3_SYMBOL, 0);
}


size_t MySQLParser::LoadSourceTypeContext::getRuleIndex() const {
  return MySQLParser::RuleLoadSourceType;
}

void MySQLParser::LoadSourceTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadSourceType(this);
}

void MySQLParser::LoadSourceTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadSourceType(this);
}


std::any MySQLParser::LoadSourceTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadSourceType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadSourceTypeContext* MySQLParser::loadSourceType() {
  LoadSourceTypeContext *_localctx = _tracker.createInstance<LoadSourceTypeContext>(_ctx, getState());
  enterRule(_localctx, 282, MySQLParser::RuleLoadSourceType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3342);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 289, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3339);
      match(MySQLParser::INFILE_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3340);

      if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
      setState(3341);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::URL_SYMBOL

      || _la == MySQLParser::S3_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceCountContext ------------------------------------------------------------------

MySQLParser::SourceCountContext::SourceCountContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SourceCountContext::COUNT_SYMBOL() {
  return getToken(MySQLParser::COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceCountContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

MySQLParser::PureIdentifierContext* MySQLParser::SourceCountContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}


size_t MySQLParser::SourceCountContext::getRuleIndex() const {
  return MySQLParser::RuleSourceCount;
}

void MySQLParser::SourceCountContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceCount(this);
}

void MySQLParser::SourceCountContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceCount(this);
}


std::any MySQLParser::SourceCountContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceCount(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceCountContext* MySQLParser::sourceCount() {
  SourceCountContext *_localctx = _tracker.createInstance<SourceCountContext>(_ctx, getState());
  enterRule(_localctx, 284, MySQLParser::RuleSourceCount);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3344);

    if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
    setState(3351);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 290, _ctx)) {
    case 1: {
      setState(3345);

      if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
      setState(3346);
      match(MySQLParser::COUNT_SYMBOL);
      setState(3347);
      match(MySQLParser::INT_NUMBER);
      break;
    }

    case 2: {
      setState(3348);
      pureIdentifier();
      setState(3349);
      match(MySQLParser::INT_NUMBER);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceOrderContext ------------------------------------------------------------------

MySQLParser::SourceOrderContext::SourceOrderContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SourceOrderContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceOrderContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceOrderContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceOrderContext::ORDER_SYMBOL() {
  return getToken(MySQLParser::ORDER_SYMBOL, 0);
}


size_t MySQLParser::SourceOrderContext::getRuleIndex() const {
  return MySQLParser::RuleSourceOrder;
}

void MySQLParser::SourceOrderContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceOrder(this);
}

void MySQLParser::SourceOrderContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceOrder(this);
}


std::any MySQLParser::SourceOrderContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceOrder(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceOrderContext* MySQLParser::sourceOrder() {
  SourceOrderContext *_localctx = _tracker.createInstance<SourceOrderContext>(_ctx, getState());
  enterRule(_localctx, 286, MySQLParser::RuleSourceOrder);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3353);

    if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
    setState(3354);
    match(MySQLParser::IN_SYMBOL);
    setState(3355);
    match(MySQLParser::PRIMARY_SYMBOL);
    setState(3356);
    match(MySQLParser::KEY_SYMBOL);
    setState(3357);
    match(MySQLParser::ORDER_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- XmlRowsIdentifiedByContext ------------------------------------------------------------------

MySQLParser::XmlRowsIdentifiedByContext::XmlRowsIdentifiedByContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::XmlRowsIdentifiedByContext::ROWS_SYMBOL() {
  return getToken(MySQLParser::ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XmlRowsIdentifiedByContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XmlRowsIdentifiedByContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::XmlRowsIdentifiedByContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::XmlRowsIdentifiedByContext::getRuleIndex() const {
  return MySQLParser::RuleXmlRowsIdentifiedBy;
}

void MySQLParser::XmlRowsIdentifiedByContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterXmlRowsIdentifiedBy(this);
}

void MySQLParser::XmlRowsIdentifiedByContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitXmlRowsIdentifiedBy(this);
}


std::any MySQLParser::XmlRowsIdentifiedByContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitXmlRowsIdentifiedBy(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::XmlRowsIdentifiedByContext* MySQLParser::xmlRowsIdentifiedBy() {
  XmlRowsIdentifiedByContext *_localctx = _tracker.createInstance<XmlRowsIdentifiedByContext>(_ctx, getState());
  enterRule(_localctx, 288, MySQLParser::RuleXmlRowsIdentifiedBy);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3359);
    match(MySQLParser::ROWS_SYMBOL);
    setState(3360);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(3361);
    match(MySQLParser::BY_SYMBOL);
    setState(3362);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadDataFileTailContext ------------------------------------------------------------------

MySQLParser::LoadDataFileTailContext::LoadDataFileTailContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadDataFileTailContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadDataFileTailContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

MySQLParser::LoadDataFileTargetListContext* MySQLParser::LoadDataFileTailContext::loadDataFileTargetList() {
  return getRuleContext<MySQLParser::LoadDataFileTargetListContext>(0);
}

tree::TerminalNode* MySQLParser::LoadDataFileTailContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

MySQLParser::UpdateListContext* MySQLParser::LoadDataFileTailContext::updateList() {
  return getRuleContext<MySQLParser::UpdateListContext>(0);
}

tree::TerminalNode* MySQLParser::LoadDataFileTailContext::LINES_SYMBOL() {
  return getToken(MySQLParser::LINES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadDataFileTailContext::ROWS_SYMBOL() {
  return getToken(MySQLParser::ROWS_SYMBOL, 0);
}


size_t MySQLParser::LoadDataFileTailContext::getRuleIndex() const {
  return MySQLParser::RuleLoadDataFileTail;
}

void MySQLParser::LoadDataFileTailContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadDataFileTail(this);
}

void MySQLParser::LoadDataFileTailContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadDataFileTail(this);
}


std::any MySQLParser::LoadDataFileTailContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadDataFileTail(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadDataFileTailContext* MySQLParser::loadDataFileTail() {
  LoadDataFileTailContext *_localctx = _tracker.createInstance<LoadDataFileTailContext>(_ctx, getState());
  enterRule(_localctx, 290, MySQLParser::RuleLoadDataFileTail);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3367);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 291, _ctx)) {
    case 1: {
      setState(3364);
      match(MySQLParser::IGNORE_SYMBOL);
      setState(3365);
      match(MySQLParser::INT_NUMBER);
      setState(3366);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LINES_SYMBOL || _la == MySQLParser::ROWS_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
    setState(3370);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 292, _ctx)) {
    case 1: {
      setState(3369);
      loadDataFileTargetList();
      break;
    }

    default:
      break;
    }
    setState(3374);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx)) {
    case 1: {
      setState(3372);
      match(MySQLParser::SET_SYMBOL);
      setState(3373);
      updateList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadDataFileTargetListContext ------------------------------------------------------------------

MySQLParser::LoadDataFileTargetListContext::LoadDataFileTargetListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadDataFileTargetListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadDataFileTargetListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::FieldOrVariableListContext* MySQLParser::LoadDataFileTargetListContext::fieldOrVariableList() {
  return getRuleContext<MySQLParser::FieldOrVariableListContext>(0);
}


size_t MySQLParser::LoadDataFileTargetListContext::getRuleIndex() const {
  return MySQLParser::RuleLoadDataFileTargetList;
}

void MySQLParser::LoadDataFileTargetListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadDataFileTargetList(this);
}

void MySQLParser::LoadDataFileTargetListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadDataFileTargetList(this);
}


std::any MySQLParser::LoadDataFileTargetListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadDataFileTargetList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadDataFileTargetListContext* MySQLParser::loadDataFileTargetList() {
  LoadDataFileTargetListContext *_localctx = _tracker.createInstance<LoadDataFileTargetListContext>(_ctx, getState());
  enterRule(_localctx, 292, MySQLParser::RuleLoadDataFileTargetList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3376);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3378);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx)) {
    case 1: {
      setState(3377);
      fieldOrVariableList();
      break;
    }

    default:
      break;
    }
    setState(3380);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldOrVariableListContext ------------------------------------------------------------------

MySQLParser::FieldOrVariableListContext::FieldOrVariableListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::ColumnRefContext *> MySQLParser::FieldOrVariableListContext::columnRef() {
  return getRuleContexts<MySQLParser::ColumnRefContext>();
}

MySQLParser::ColumnRefContext* MySQLParser::FieldOrVariableListContext::columnRef(size_t i) {
  return getRuleContext<MySQLParser::ColumnRefContext>(i);
}

std::vector<MySQLParser::UserVariableContext *> MySQLParser::FieldOrVariableListContext::userVariable() {
  return getRuleContexts<MySQLParser::UserVariableContext>();
}

MySQLParser::UserVariableContext* MySQLParser::FieldOrVariableListContext::userVariable(size_t i) {
  return getRuleContext<MySQLParser::UserVariableContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::FieldOrVariableListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::FieldOrVariableListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::FieldOrVariableListContext::getRuleIndex() const {
  return MySQLParser::RuleFieldOrVariableList;
}

void MySQLParser::FieldOrVariableListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldOrVariableList(this);
}

void MySQLParser::FieldOrVariableListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldOrVariableList(this);
}


std::any MySQLParser::FieldOrVariableListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldOrVariableList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldOrVariableListContext* MySQLParser::fieldOrVariableList() {
  FieldOrVariableListContext *_localctx = _tracker.createInstance<FieldOrVariableListContext>(_ctx, getState());
  enterRule(_localctx, 294, MySQLParser::RuleFieldOrVariableList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3384);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 295, _ctx)) {
    case 1: {
      setState(3382);
      columnRef();
      break;
    }

    case 2: {
      setState(3383);
      userVariable();
      break;
    }

    default:
      break;
    }
    setState(3393);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3386);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3389);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 296, _ctx)) {
      case 1: {
        setState(3387);
        columnRef();
        break;
      }

      case 2: {
        setState(3388);
        userVariable();
        break;
      }

      default:
        break;
      }
      setState(3395);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadAlgorithmContext ------------------------------------------------------------------

MySQLParser::LoadAlgorithmContext::LoadAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadAlgorithmContext::ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadAlgorithmContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::LoadAlgorithmContext::BULK_SYMBOL() {
  return getToken(MySQLParser::BULK_SYMBOL, 0);
}


size_t MySQLParser::LoadAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RuleLoadAlgorithm;
}

void MySQLParser::LoadAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadAlgorithm(this);
}

void MySQLParser::LoadAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadAlgorithm(this);
}


std::any MySQLParser::LoadAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadAlgorithmContext* MySQLParser::loadAlgorithm() {
  LoadAlgorithmContext *_localctx = _tracker.createInstance<LoadAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 296, MySQLParser::RuleLoadAlgorithm);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3396);

    if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
    setState(3397);
    match(MySQLParser::ALGORITHM_SYMBOL);
    setState(3398);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(3399);
    match(MySQLParser::BULK_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CompressionAlgorithmContext ------------------------------------------------------------------

MySQLParser::CompressionAlgorithmContext::CompressionAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CompressionAlgorithmContext::COMPRESSION_SYMBOL() {
  return getToken(MySQLParser::COMPRESSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CompressionAlgorithmContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::CompressionAlgorithmContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::CompressionAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RuleCompressionAlgorithm;
}

void MySQLParser::CompressionAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCompressionAlgorithm(this);
}

void MySQLParser::CompressionAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCompressionAlgorithm(this);
}


std::any MySQLParser::CompressionAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCompressionAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CompressionAlgorithmContext* MySQLParser::compressionAlgorithm() {
  CompressionAlgorithmContext *_localctx = _tracker.createInstance<CompressionAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 298, MySQLParser::RuleCompressionAlgorithm);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3401);

    if (!(serverVersion >= 80400)) throw FailedPredicateException(this, "serverVersion >= 80400");
    setState(3402);
    match(MySQLParser::COMPRESSION_SYMBOL);
    setState(3403);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(3404);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadParallelContext ------------------------------------------------------------------

MySQLParser::LoadParallelContext::LoadParallelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadParallelContext::PARALLEL_SYMBOL() {
  return getToken(MySQLParser::PARALLEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadParallelContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::LoadParallelContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}


size_t MySQLParser::LoadParallelContext::getRuleIndex() const {
  return MySQLParser::RuleLoadParallel;
}

void MySQLParser::LoadParallelContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadParallel(this);
}

void MySQLParser::LoadParallelContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadParallel(this);
}


std::any MySQLParser::LoadParallelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadParallel(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadParallelContext* MySQLParser::loadParallel() {
  LoadParallelContext *_localctx = _tracker.createInstance<LoadParallelContext>(_ctx, getState());
  enterRule(_localctx, 300, MySQLParser::RuleLoadParallel);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3406);

    if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
    setState(3407);
    match(MySQLParser::PARALLEL_SYMBOL);
    setState(3408);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(3409);
    match(MySQLParser::INT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoadMemoryContext ------------------------------------------------------------------

MySQLParser::LoadMemoryContext::LoadMemoryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LoadMemoryContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadMemoryContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::SizeNumberContext* MySQLParser::LoadMemoryContext::sizeNumber() {
  return getRuleContext<MySQLParser::SizeNumberContext>(0);
}


size_t MySQLParser::LoadMemoryContext::getRuleIndex() const {
  return MySQLParser::RuleLoadMemory;
}

void MySQLParser::LoadMemoryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoadMemory(this);
}

void MySQLParser::LoadMemoryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoadMemory(this);
}


std::any MySQLParser::LoadMemoryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoadMemory(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoadMemoryContext* MySQLParser::loadMemory() {
  LoadMemoryContext *_localctx = _tracker.createInstance<LoadMemoryContext>(_ctx, getState());
  enterRule(_localctx, 302, MySQLParser::RuleLoadMemory);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3411);

    if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
    setState(3412);
    match(MySQLParser::MEMORY_SYMBOL);
    setState(3413);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(3414);
    sizeNumber();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplaceStatementContext ------------------------------------------------------------------

MySQLParser::ReplaceStatementContext::ReplaceStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReplaceStatementContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::ReplaceStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::InsertFromConstructorContext* MySQLParser::ReplaceStatementContext::insertFromConstructor() {
  return getRuleContext<MySQLParser::InsertFromConstructorContext>(0);
}

tree::TerminalNode* MySQLParser::ReplaceStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

MySQLParser::UpdateListContext* MySQLParser::ReplaceStatementContext::updateList() {
  return getRuleContext<MySQLParser::UpdateListContext>(0);
}

MySQLParser::InsertQueryExpressionContext* MySQLParser::ReplaceStatementContext::insertQueryExpression() {
  return getRuleContext<MySQLParser::InsertQueryExpressionContext>(0);
}

tree::TerminalNode* MySQLParser::ReplaceStatementContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

MySQLParser::UsePartitionContext* MySQLParser::ReplaceStatementContext::usePartition() {
  return getRuleContext<MySQLParser::UsePartitionContext>(0);
}

tree::TerminalNode* MySQLParser::ReplaceStatementContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplaceStatementContext::DELAYED_SYMBOL() {
  return getToken(MySQLParser::DELAYED_SYMBOL, 0);
}


size_t MySQLParser::ReplaceStatementContext::getRuleIndex() const {
  return MySQLParser::RuleReplaceStatement;
}

void MySQLParser::ReplaceStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplaceStatement(this);
}

void MySQLParser::ReplaceStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplaceStatement(this);
}


std::any MySQLParser::ReplaceStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplaceStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplaceStatementContext* MySQLParser::replaceStatement() {
  ReplaceStatementContext *_localctx = _tracker.createInstance<ReplaceStatementContext>(_ctx, getState());
  enterRule(_localctx, 304, MySQLParser::RuleReplaceStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3416);
    match(MySQLParser::REPLACE_SYMBOL);
    setState(3418);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx)) {
    case 1: {
      setState(3417);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DELAYED_SYMBOL || _la == MySQLParser::LOW_PRIORITY_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
    setState(3421);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 299, _ctx)) {
    case 1: {
      setState(3420);
      match(MySQLParser::INTO_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3423);
    tableRef();
    setState(3425);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 300, _ctx)) {
    case 1: {
      setState(3424);
      usePartition();
      break;
    }

    default:
      break;
    }
    setState(3431);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx)) {
    case 1: {
      setState(3427);
      insertFromConstructor();
      break;
    }

    case 2: {
      setState(3428);
      match(MySQLParser::SET_SYMBOL);
      setState(3429);
      updateList();
      break;
    }

    case 3: {
      setState(3430);
      insertQueryExpression();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectStatementContext ------------------------------------------------------------------

MySQLParser::SelectStatementContext::SelectStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionContext* MySQLParser::SelectStatementContext::queryExpression() {
  return getRuleContext<MySQLParser::QueryExpressionContext>(0);
}

MySQLParser::LockingClauseListContext* MySQLParser::SelectStatementContext::lockingClauseList() {
  return getRuleContext<MySQLParser::LockingClauseListContext>(0);
}

MySQLParser::SelectStatementWithIntoContext* MySQLParser::SelectStatementContext::selectStatementWithInto() {
  return getRuleContext<MySQLParser::SelectStatementWithIntoContext>(0);
}


size_t MySQLParser::SelectStatementContext::getRuleIndex() const {
  return MySQLParser::RuleSelectStatement;
}

void MySQLParser::SelectStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSelectStatement(this);
}

void MySQLParser::SelectStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSelectStatement(this);
}


std::any MySQLParser::SelectStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSelectStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SelectStatementContext* MySQLParser::selectStatement() {
  SelectStatementContext *_localctx = _tracker.createInstance<SelectStatementContext>(_ctx, getState());
  enterRule(_localctx, 306, MySQLParser::RuleSelectStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3438);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 303, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3433);
      queryExpression();
      setState(3435);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 302, _ctx)) {
      case 1: {
        setState(3434);
        lockingClauseList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3437);
      selectStatementWithInto();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectStatementWithIntoContext ------------------------------------------------------------------

MySQLParser::SelectStatementWithIntoContext::SelectStatementWithIntoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SelectStatementWithIntoContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::SelectStatementWithIntoContext* MySQLParser::SelectStatementWithIntoContext::selectStatementWithInto() {
  return getRuleContext<MySQLParser::SelectStatementWithIntoContext>(0);
}

tree::TerminalNode* MySQLParser::SelectStatementWithIntoContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::QueryExpressionContext* MySQLParser::SelectStatementWithIntoContext::queryExpression() {
  return getRuleContext<MySQLParser::QueryExpressionContext>(0);
}

MySQLParser::IntoClauseContext* MySQLParser::SelectStatementWithIntoContext::intoClause() {
  return getRuleContext<MySQLParser::IntoClauseContext>(0);
}

MySQLParser::LockingClauseListContext* MySQLParser::SelectStatementWithIntoContext::lockingClauseList() {
  return getRuleContext<MySQLParser::LockingClauseListContext>(0);
}

MySQLParser::QueryExpressionParensContext* MySQLParser::SelectStatementWithIntoContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}


size_t MySQLParser::SelectStatementWithIntoContext::getRuleIndex() const {
  return MySQLParser::RuleSelectStatementWithInto;
}

void MySQLParser::SelectStatementWithIntoContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSelectStatementWithInto(this);
}

void MySQLParser::SelectStatementWithIntoContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSelectStatementWithInto(this);
}


std::any MySQLParser::SelectStatementWithIntoContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSelectStatementWithInto(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SelectStatementWithIntoContext* MySQLParser::selectStatementWithInto() {
  SelectStatementWithIntoContext *_localctx = _tracker.createInstance<SelectStatementWithIntoContext>(_ctx, getState());
  enterRule(_localctx, 308, MySQLParser::RuleSelectStatementWithInto);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3457);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 305, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3440);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(3441);
      selectStatementWithInto();
      setState(3442);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3444);
      queryExpression();
      setState(3445);
      intoClause();
      setState(3447);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 304, _ctx)) {
      case 1: {
        setState(3446);
        lockingClauseList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3449);
      queryExpression();
      setState(3450);
      lockingClauseList();
      setState(3451);
      intoClause();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3453);

      if (!(serverVersion >= 80024 && serverVersion < 80031)) throw FailedPredicateException(this, "serverVersion >= 80024 && serverVersion < 80031");
      setState(3454);
      queryExpressionParens();
      setState(3455);
      intoClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryExpressionContext ------------------------------------------------------------------

MySQLParser::QueryExpressionContext::QueryExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionBodyContext* MySQLParser::QueryExpressionContext::queryExpressionBody() {
  return getRuleContext<MySQLParser::QueryExpressionBodyContext>(0);
}

MySQLParser::WithClauseContext* MySQLParser::QueryExpressionContext::withClause() {
  return getRuleContext<MySQLParser::WithClauseContext>(0);
}

MySQLParser::OrderClauseContext* MySQLParser::QueryExpressionContext::orderClause() {
  return getRuleContext<MySQLParser::OrderClauseContext>(0);
}

MySQLParser::LimitClauseContext* MySQLParser::QueryExpressionContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}

MySQLParser::ProcedureAnalyseClauseContext* MySQLParser::QueryExpressionContext::procedureAnalyseClause() {
  return getRuleContext<MySQLParser::ProcedureAnalyseClauseContext>(0);
}


size_t MySQLParser::QueryExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleQueryExpression;
}

void MySQLParser::QueryExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQueryExpression(this);
}

void MySQLParser::QueryExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQueryExpression(this);
}


std::any MySQLParser::QueryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQueryExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryExpressionContext* MySQLParser::queryExpression() {
  QueryExpressionContext *_localctx = _tracker.createInstance<QueryExpressionContext>(_ctx, getState());
  enterRule(_localctx, 310, MySQLParser::RuleQueryExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3461);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 306, _ctx)) {
    case 1: {
      setState(3459);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3460);
      withClause();
      break;
    }

    default:
      break;
    }
    setState(3463);
    queryExpressionBody();
    setState(3465);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx)) {
    case 1: {
      setState(3464);
      orderClause();
      break;
    }

    default:
      break;
    }
    setState(3468);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 308, _ctx)) {
    case 1: {
      setState(3467);
      limitClause();
      break;
    }

    default:
      break;
    }
    setState(3472);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 309, _ctx)) {
    case 1: {
      setState(3470);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(3471);
      procedureAnalyseClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryExpressionBodyContext ------------------------------------------------------------------

MySQLParser::QueryExpressionBodyContext::QueryExpressionBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryPrimaryContext* MySQLParser::QueryExpressionBodyContext::queryPrimary() {
  return getRuleContext<MySQLParser::QueryPrimaryContext>(0);
}

MySQLParser::QueryExpressionParensContext* MySQLParser::QueryExpressionBodyContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}

std::vector<MySQLParser::QueryExpressionBodyContext *> MySQLParser::QueryExpressionBodyContext::queryExpressionBody() {
  return getRuleContexts<MySQLParser::QueryExpressionBodyContext>();
}

MySQLParser::QueryExpressionBodyContext* MySQLParser::QueryExpressionBodyContext::queryExpressionBody(size_t i) {
  return getRuleContext<MySQLParser::QueryExpressionBodyContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::QueryExpressionBodyContext::UNION_SYMBOL() {
  return getTokens(MySQLParser::UNION_SYMBOL);
}

tree::TerminalNode* MySQLParser::QueryExpressionBodyContext::UNION_SYMBOL(size_t i) {
  return getToken(MySQLParser::UNION_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::QueryExpressionBodyContext::EXCEPT_SYMBOL() {
  return getTokens(MySQLParser::EXCEPT_SYMBOL);
}

tree::TerminalNode* MySQLParser::QueryExpressionBodyContext::EXCEPT_SYMBOL(size_t i) {
  return getToken(MySQLParser::EXCEPT_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::QueryExpressionBodyContext::INTERSECT_SYMBOL() {
  return getTokens(MySQLParser::INTERSECT_SYMBOL);
}

tree::TerminalNode* MySQLParser::QueryExpressionBodyContext::INTERSECT_SYMBOL(size_t i) {
  return getToken(MySQLParser::INTERSECT_SYMBOL, i);
}

std::vector<MySQLParser::UnionOptionContext *> MySQLParser::QueryExpressionBodyContext::unionOption() {
  return getRuleContexts<MySQLParser::UnionOptionContext>();
}

MySQLParser::UnionOptionContext* MySQLParser::QueryExpressionBodyContext::unionOption(size_t i) {
  return getRuleContext<MySQLParser::UnionOptionContext>(i);
}


size_t MySQLParser::QueryExpressionBodyContext::getRuleIndex() const {
  return MySQLParser::RuleQueryExpressionBody;
}

void MySQLParser::QueryExpressionBodyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQueryExpressionBody(this);
}

void MySQLParser::QueryExpressionBodyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQueryExpressionBody(this);
}


std::any MySQLParser::QueryExpressionBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQueryExpressionBody(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryExpressionBodyContext* MySQLParser::queryExpressionBody() {
  QueryExpressionBodyContext *_localctx = _tracker.createInstance<QueryExpressionBodyContext>(_ctx, getState());
  enterRule(_localctx, 312, MySQLParser::RuleQueryExpressionBody);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3476);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 310, _ctx)) {
    case 1: {
      setState(3474);
      queryPrimary();
      break;
    }

    case 2: {
      setState(3475);
      queryExpressionParens();
      break;
    }

    default:
      break;
    }
    setState(3489);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3481);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _ctx)) {
        case 1: {
          setState(3478);
          match(MySQLParser::UNION_SYMBOL);
          break;
        }

        case 2: {
          setState(3479);

          if (!(serverVersion >= 80031)) throw FailedPredicateException(this, "serverVersion >= 80031");
          setState(3480);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::EXCEPT_SYMBOL || _la == MySQLParser::INTERSECT_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          break;
        }

        default:
          break;
        }
        setState(3484);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 312, _ctx)) {
        case 1: {
          setState(3483);
          unionOption();
          break;
        }

        default:
          break;
        }
        setState(3486);
        queryExpressionBody(); 
      }
      setState(3491);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryExpressionParensContext ------------------------------------------------------------------

MySQLParser::QueryExpressionParensContext::QueryExpressionParensContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::QueryExpressionParensContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QueryExpressionParensContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::QueryExpressionParensContext* MySQLParser::QueryExpressionParensContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}

MySQLParser::QueryExpressionWithOptLockingClausesContext* MySQLParser::QueryExpressionParensContext::queryExpressionWithOptLockingClauses() {
  return getRuleContext<MySQLParser::QueryExpressionWithOptLockingClausesContext>(0);
}


size_t MySQLParser::QueryExpressionParensContext::getRuleIndex() const {
  return MySQLParser::RuleQueryExpressionParens;
}

void MySQLParser::QueryExpressionParensContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQueryExpressionParens(this);
}

void MySQLParser::QueryExpressionParensContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQueryExpressionParens(this);
}


std::any MySQLParser::QueryExpressionParensContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQueryExpressionParens(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryExpressionParensContext* MySQLParser::queryExpressionParens() {
  QueryExpressionParensContext *_localctx = _tracker.createInstance<QueryExpressionParensContext>(_ctx, getState());
  enterRule(_localctx, 314, MySQLParser::RuleQueryExpressionParens);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3492);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3495);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 314, _ctx)) {
    case 1: {
      setState(3493);
      queryExpressionParens();
      break;
    }

    case 2: {
      setState(3494);
      queryExpressionWithOptLockingClauses();
      break;
    }

    default:
      break;
    }
    setState(3497);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryPrimaryContext ------------------------------------------------------------------

MySQLParser::QueryPrimaryContext::QueryPrimaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QuerySpecificationContext* MySQLParser::QueryPrimaryContext::querySpecification() {
  return getRuleContext<MySQLParser::QuerySpecificationContext>(0);
}

MySQLParser::TableValueConstructorContext* MySQLParser::QueryPrimaryContext::tableValueConstructor() {
  return getRuleContext<MySQLParser::TableValueConstructorContext>(0);
}

MySQLParser::ExplicitTableContext* MySQLParser::QueryPrimaryContext::explicitTable() {
  return getRuleContext<MySQLParser::ExplicitTableContext>(0);
}


size_t MySQLParser::QueryPrimaryContext::getRuleIndex() const {
  return MySQLParser::RuleQueryPrimary;
}

void MySQLParser::QueryPrimaryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQueryPrimary(this);
}

void MySQLParser::QueryPrimaryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQueryPrimary(this);
}


std::any MySQLParser::QueryPrimaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQueryPrimary(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QueryPrimaryContext* MySQLParser::queryPrimary() {
  QueryPrimaryContext *_localctx = _tracker.createInstance<QueryPrimaryContext>(_ctx, getState());
  enterRule(_localctx, 316, MySQLParser::RuleQueryPrimary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3504);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 315, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3499);
      querySpecification();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3500);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(3501);
      tableValueConstructor();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3502);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(3503);
      explicitTable();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QuerySpecificationContext ------------------------------------------------------------------

MySQLParser::QuerySpecificationContext::QuerySpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::QuerySpecificationContext::SELECT_SYMBOL() {
  return getToken(MySQLParser::SELECT_SYMBOL, 0);
}

MySQLParser::SelectItemListContext* MySQLParser::QuerySpecificationContext::selectItemList() {
  return getRuleContext<MySQLParser::SelectItemListContext>(0);
}

std::vector<MySQLParser::SelectOptionContext *> MySQLParser::QuerySpecificationContext::selectOption() {
  return getRuleContexts<MySQLParser::SelectOptionContext>();
}

MySQLParser::SelectOptionContext* MySQLParser::QuerySpecificationContext::selectOption(size_t i) {
  return getRuleContext<MySQLParser::SelectOptionContext>(i);
}

MySQLParser::IntoClauseContext* MySQLParser::QuerySpecificationContext::intoClause() {
  return getRuleContext<MySQLParser::IntoClauseContext>(0);
}

MySQLParser::FromClauseContext* MySQLParser::QuerySpecificationContext::fromClause() {
  return getRuleContext<MySQLParser::FromClauseContext>(0);
}

MySQLParser::WhereClauseContext* MySQLParser::QuerySpecificationContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}

MySQLParser::GroupByClauseContext* MySQLParser::QuerySpecificationContext::groupByClause() {
  return getRuleContext<MySQLParser::GroupByClauseContext>(0);
}

MySQLParser::HavingClauseContext* MySQLParser::QuerySpecificationContext::havingClause() {
  return getRuleContext<MySQLParser::HavingClauseContext>(0);
}

MySQLParser::WindowClauseContext* MySQLParser::QuerySpecificationContext::windowClause() {
  return getRuleContext<MySQLParser::WindowClauseContext>(0);
}

MySQLParser::QualifyClauseContext* MySQLParser::QuerySpecificationContext::qualifyClause() {
  return getRuleContext<MySQLParser::QualifyClauseContext>(0);
}


size_t MySQLParser::QuerySpecificationContext::getRuleIndex() const {
  return MySQLParser::RuleQuerySpecification;
}

void MySQLParser::QuerySpecificationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQuerySpecification(this);
}

void MySQLParser::QuerySpecificationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQuerySpecification(this);
}


std::any MySQLParser::QuerySpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQuerySpecification(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QuerySpecificationContext* MySQLParser::querySpecification() {
  QuerySpecificationContext *_localctx = _tracker.createInstance<QuerySpecificationContext>(_ctx, getState());
  enterRule(_localctx, 318, MySQLParser::RuleQuerySpecification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3506);
    match(MySQLParser::SELECT_SYMBOL);
    setState(3510);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3507);
        selectOption(); 
      }
      setState(3512);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _ctx);
    }
    setState(3513);
    selectItemList();
    setState(3515);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 317, _ctx)) {
    case 1: {
      setState(3514);
      intoClause();
      break;
    }

    default:
      break;
    }
    setState(3518);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 318, _ctx)) {
    case 1: {
      setState(3517);
      fromClause();
      break;
    }

    default:
      break;
    }
    setState(3521);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 319, _ctx)) {
    case 1: {
      setState(3520);
      whereClause();
      break;
    }

    default:
      break;
    }
    setState(3524);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 320, _ctx)) {
    case 1: {
      setState(3523);
      groupByClause();
      break;
    }

    default:
      break;
    }
    setState(3527);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 321, _ctx)) {
    case 1: {
      setState(3526);
      havingClause();
      break;
    }

    default:
      break;
    }
    setState(3531);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 322, _ctx)) {
    case 1: {
      setState(3529);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3530);
      windowClause();
      break;
    }

    default:
      break;
    }
    setState(3534);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 323, _ctx)) {
    case 1: {
      setState(3533);
      qualifyClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SubqueryContext ------------------------------------------------------------------

MySQLParser::SubqueryContext::SubqueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QueryExpressionParensContext* MySQLParser::SubqueryContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}


size_t MySQLParser::SubqueryContext::getRuleIndex() const {
  return MySQLParser::RuleSubquery;
}

void MySQLParser::SubqueryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSubquery(this);
}

void MySQLParser::SubqueryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSubquery(this);
}


std::any MySQLParser::SubqueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSubquery(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SubqueryContext* MySQLParser::subquery() {
  SubqueryContext *_localctx = _tracker.createInstance<SubqueryContext>(_ctx, getState());
  enterRule(_localctx, 320, MySQLParser::RuleSubquery);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3536);
    queryExpressionParens();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QuerySpecOptionContext ------------------------------------------------------------------

MySQLParser::QuerySpecOptionContext::QuerySpecOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::DISTINCT_SYMBOL() {
  return getToken(MySQLParser::DISTINCT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::STRAIGHT_JOIN_SYMBOL() {
  return getToken(MySQLParser::STRAIGHT_JOIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::HIGH_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::HIGH_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::SQL_SMALL_RESULT_SYMBOL() {
  return getToken(MySQLParser::SQL_SMALL_RESULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::SQL_BIG_RESULT_SYMBOL() {
  return getToken(MySQLParser::SQL_BIG_RESULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::SQL_BUFFER_RESULT_SYMBOL() {
  return getToken(MySQLParser::SQL_BUFFER_RESULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::QuerySpecOptionContext::SQL_CALC_FOUND_ROWS_SYMBOL() {
  return getToken(MySQLParser::SQL_CALC_FOUND_ROWS_SYMBOL, 0);
}


size_t MySQLParser::QuerySpecOptionContext::getRuleIndex() const {
  return MySQLParser::RuleQuerySpecOption;
}

void MySQLParser::QuerySpecOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQuerySpecOption(this);
}

void MySQLParser::QuerySpecOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQuerySpecOption(this);
}


std::any MySQLParser::QuerySpecOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQuerySpecOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QuerySpecOptionContext* MySQLParser::querySpecOption() {
  QuerySpecOptionContext *_localctx = _tracker.createInstance<QuerySpecOptionContext>(_ctx, getState());
  enterRule(_localctx, 322, MySQLParser::RuleQuerySpecOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3538);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ALL_SYMBOL || _la == MySQLParser::DISTINCT_SYMBOL || _la == MySQLParser::HIGH_PRIORITY_SYMBOL || ((((_la - 557) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 557)) & ((1ULL << (MySQLParser::SQL_BIG_RESULT_SYMBOL - 557))
      | (1ULL << (MySQLParser::SQL_BUFFER_RESULT_SYMBOL - 557))
      | (1ULL << (MySQLParser::SQL_CALC_FOUND_ROWS_SYMBOL - 557))
      | (1ULL << (MySQLParser::SQL_SMALL_RESULT_SYMBOL - 557))
      | (1ULL << (MySQLParser::STRAIGHT_JOIN_SYMBOL - 557)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LimitClauseContext ------------------------------------------------------------------

MySQLParser::LimitClauseContext::LimitClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LimitClauseContext::LIMIT_SYMBOL() {
  return getToken(MySQLParser::LIMIT_SYMBOL, 0);
}

MySQLParser::LimitOptionsContext* MySQLParser::LimitClauseContext::limitOptions() {
  return getRuleContext<MySQLParser::LimitOptionsContext>(0);
}


size_t MySQLParser::LimitClauseContext::getRuleIndex() const {
  return MySQLParser::RuleLimitClause;
}

void MySQLParser::LimitClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLimitClause(this);
}

void MySQLParser::LimitClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLimitClause(this);
}


std::any MySQLParser::LimitClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLimitClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LimitClauseContext* MySQLParser::limitClause() {
  LimitClauseContext *_localctx = _tracker.createInstance<LimitClauseContext>(_ctx, getState());
  enterRule(_localctx, 324, MySQLParser::RuleLimitClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3540);
    match(MySQLParser::LIMIT_SYMBOL);
    setState(3541);
    limitOptions();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleLimitClauseContext ------------------------------------------------------------------

MySQLParser::SimpleLimitClauseContext::SimpleLimitClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SimpleLimitClauseContext::LIMIT_SYMBOL() {
  return getToken(MySQLParser::LIMIT_SYMBOL, 0);
}

MySQLParser::LimitOptionContext* MySQLParser::SimpleLimitClauseContext::limitOption() {
  return getRuleContext<MySQLParser::LimitOptionContext>(0);
}


size_t MySQLParser::SimpleLimitClauseContext::getRuleIndex() const {
  return MySQLParser::RuleSimpleLimitClause;
}

void MySQLParser::SimpleLimitClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleLimitClause(this);
}

void MySQLParser::SimpleLimitClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleLimitClause(this);
}


std::any MySQLParser::SimpleLimitClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleLimitClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SimpleLimitClauseContext* MySQLParser::simpleLimitClause() {
  SimpleLimitClauseContext *_localctx = _tracker.createInstance<SimpleLimitClauseContext>(_ctx, getState());
  enterRule(_localctx, 326, MySQLParser::RuleSimpleLimitClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3543);
    match(MySQLParser::LIMIT_SYMBOL);
    setState(3544);
    limitOption();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LimitOptionsContext ------------------------------------------------------------------

MySQLParser::LimitOptionsContext::LimitOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::LimitOptionContext *> MySQLParser::LimitOptionsContext::limitOption() {
  return getRuleContexts<MySQLParser::LimitOptionContext>();
}

MySQLParser::LimitOptionContext* MySQLParser::LimitOptionsContext::limitOption(size_t i) {
  return getRuleContext<MySQLParser::LimitOptionContext>(i);
}

tree::TerminalNode* MySQLParser::LimitOptionsContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LimitOptionsContext::OFFSET_SYMBOL() {
  return getToken(MySQLParser::OFFSET_SYMBOL, 0);
}


size_t MySQLParser::LimitOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleLimitOptions;
}

void MySQLParser::LimitOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLimitOptions(this);
}

void MySQLParser::LimitOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLimitOptions(this);
}


std::any MySQLParser::LimitOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLimitOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LimitOptionsContext* MySQLParser::limitOptions() {
  LimitOptionsContext *_localctx = _tracker.createInstance<LimitOptionsContext>(_ctx, getState());
  enterRule(_localctx, 328, MySQLParser::RuleLimitOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3546);
    limitOption();
    setState(3549);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 324, _ctx)) {
    case 1: {
      setState(3547);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::COMMA_SYMBOL || _la == MySQLParser::OFFSET_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3548);
      limitOption();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LimitOptionContext ------------------------------------------------------------------

MySQLParser::LimitOptionContext::LimitOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::LimitOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::LimitOptionContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}

tree::TerminalNode* MySQLParser::LimitOptionContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::LimitOptionContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::LimitOptionContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}


size_t MySQLParser::LimitOptionContext::getRuleIndex() const {
  return MySQLParser::RuleLimitOption;
}

void MySQLParser::LimitOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLimitOption(this);
}

void MySQLParser::LimitOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLimitOption(this);
}


std::any MySQLParser::LimitOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLimitOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LimitOptionContext* MySQLParser::limitOption() {
  LimitOptionContext *_localctx = _tracker.createInstance<LimitOptionContext>(_ctx, getState());
  enterRule(_localctx, 330, MySQLParser::RuleLimitOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3553);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 325, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3551);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3552);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
        | (1ULL << MySQLParser::LONG_NUMBER)
        | (1ULL << MySQLParser::ULONGLONG_NUMBER)
        | (1ULL << MySQLParser::PARAM_MARKER))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OutfileURIContext ------------------------------------------------------------------

MySQLParser::OutfileURIContext::OutfileURIContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OutfileURIContext::URL_SYMBOL() {
  return getToken(MySQLParser::URL_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::OutfileURIContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::OutfileURIContext::getRuleIndex() const {
  return MySQLParser::RuleOutfileURI;
}

void MySQLParser::OutfileURIContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOutfileURI(this);
}

void MySQLParser::OutfileURIContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOutfileURI(this);
}


std::any MySQLParser::OutfileURIContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOutfileURI(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OutfileURIContext* MySQLParser::outfileURI() {
  OutfileURIContext *_localctx = _tracker.createInstance<OutfileURIContext>(_ctx, getState());
  enterRule(_localctx, 332, MySQLParser::RuleOutfileURI);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3555);
    match(MySQLParser::URL_SYMBOL);
    setState(3556);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OutfileFileInfoContext ------------------------------------------------------------------

MySQLParser::OutfileFileInfoContext::OutfileFileInfoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OutfileFileInfoListContext* MySQLParser::OutfileFileInfoContext::outfileFileInfoList() {
  return getRuleContext<MySQLParser::OutfileFileInfoListContext>(0);
}


size_t MySQLParser::OutfileFileInfoContext::getRuleIndex() const {
  return MySQLParser::RuleOutfileFileInfo;
}

void MySQLParser::OutfileFileInfoContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOutfileFileInfo(this);
}

void MySQLParser::OutfileFileInfoContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOutfileFileInfo(this);
}


std::any MySQLParser::OutfileFileInfoContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOutfileFileInfo(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OutfileFileInfoContext* MySQLParser::outfileFileInfo() {
  OutfileFileInfoContext *_localctx = _tracker.createInstance<OutfileFileInfoContext>(_ctx, getState());
  enterRule(_localctx, 334, MySQLParser::RuleOutfileFileInfo);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3558);
    outfileFileInfoList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OutfileFileInfoListContext ------------------------------------------------------------------

MySQLParser::OutfileFileInfoListContext::OutfileFileInfoListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::OutfileFileInfoElemContext *> MySQLParser::OutfileFileInfoListContext::outfileFileInfoElem() {
  return getRuleContexts<MySQLParser::OutfileFileInfoElemContext>();
}

MySQLParser::OutfileFileInfoElemContext* MySQLParser::OutfileFileInfoListContext::outfileFileInfoElem(size_t i) {
  return getRuleContext<MySQLParser::OutfileFileInfoElemContext>(i);
}


size_t MySQLParser::OutfileFileInfoListContext::getRuleIndex() const {
  return MySQLParser::RuleOutfileFileInfoList;
}

void MySQLParser::OutfileFileInfoListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOutfileFileInfoList(this);
}

void MySQLParser::OutfileFileInfoListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOutfileFileInfoList(this);
}


std::any MySQLParser::OutfileFileInfoListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOutfileFileInfoList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OutfileFileInfoListContext* MySQLParser::outfileFileInfoList() {
  OutfileFileInfoListContext *_localctx = _tracker.createInstance<OutfileFileInfoListContext>(_ctx, getState());
  enterRule(_localctx, 336, MySQLParser::RuleOutfileFileInfoList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3561); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(3560);
              outfileFileInfoElem();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(3563); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 326, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OutfileFileInfoElemContext ------------------------------------------------------------------

MySQLParser::OutfileFileInfoElemContext::OutfileFileInfoElemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OutfileFileInfoElemContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::OutfileFileInfoElemContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::OutfileFileInfoElemContext::COMPRESSION_SYMBOL() {
  return getToken(MySQLParser::COMPRESSION_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::OutfileFileInfoElemContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::OutfileFileInfoElemContext::HEADER_SYMBOL() {
  return getToken(MySQLParser::HEADER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OutfileFileInfoElemContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OutfileFileInfoElemContext::OFF_SYMBOL() {
  return getToken(MySQLParser::OFF_SYMBOL, 0);
}

MySQLParser::CharsetClauseContext* MySQLParser::OutfileFileInfoElemContext::charsetClause() {
  return getRuleContext<MySQLParser::CharsetClauseContext>(0);
}


size_t MySQLParser::OutfileFileInfoElemContext::getRuleIndex() const {
  return MySQLParser::RuleOutfileFileInfoElem;
}

void MySQLParser::OutfileFileInfoElemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOutfileFileInfoElem(this);
}

void MySQLParser::OutfileFileInfoElemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOutfileFileInfoElem(this);
}


std::any MySQLParser::OutfileFileInfoElemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOutfileFileInfoElem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OutfileFileInfoElemContext* MySQLParser::outfileFileInfoElem() {
  OutfileFileInfoElemContext *_localctx = _tracker.createInstance<OutfileFileInfoElemContext>(_ctx, getState());
  enterRule(_localctx, 338, MySQLParser::RuleOutfileFileInfoElem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3574);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3565);
      match(MySQLParser::FORMAT_SYMBOL);
      setState(3566);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3567);
      match(MySQLParser::COMPRESSION_SYMBOL);
      setState(3568);
      textString();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3569);
      match(MySQLParser::HEADER_SYMBOL);
      setState(3570);
      match(MySQLParser::ON_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3571);
      match(MySQLParser::HEADER_SYMBOL);
      setState(3572);
      match(MySQLParser::OFF_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3573);
      charsetClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IntoClauseContext ------------------------------------------------------------------

MySQLParser::IntoClauseContext::IntoClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IntoClauseContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntoClauseContext::OUTFILE_SYMBOL() {
  return getToken(MySQLParser::OUTFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntoClauseContext::DUMPFILE_SYMBOL() {
  return getToken(MySQLParser::DUMPFILE_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::IntoClauseContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::IntoClauseContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntoClauseContext::PARAMETERS_SYMBOL() {
  return getToken(MySQLParser::PARAMETERS_SYMBOL, 0);
}

MySQLParser::JsonAttributeContext* MySQLParser::IntoClauseContext::jsonAttribute() {
  return getRuleContext<MySQLParser::JsonAttributeContext>(0);
}

std::vector<MySQLParser::TextOrIdentifierContext *> MySQLParser::IntoClauseContext::textOrIdentifier() {
  return getRuleContexts<MySQLParser::TextOrIdentifierContext>();
}

MySQLParser::TextOrIdentifierContext* MySQLParser::IntoClauseContext::textOrIdentifier(size_t i) {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(i);
}

std::vector<MySQLParser::UserVariableContext *> MySQLParser::IntoClauseContext::userVariable() {
  return getRuleContexts<MySQLParser::UserVariableContext>();
}

MySQLParser::UserVariableContext* MySQLParser::IntoClauseContext::userVariable(size_t i) {
  return getRuleContext<MySQLParser::UserVariableContext>(i);
}

MySQLParser::FieldsClauseContext* MySQLParser::IntoClauseContext::fieldsClause() {
  return getRuleContext<MySQLParser::FieldsClauseContext>(0);
}

MySQLParser::LinesClauseContext* MySQLParser::IntoClauseContext::linesClause() {
  return getRuleContext<MySQLParser::LinesClauseContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::IntoClauseContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::IntoClauseContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

MySQLParser::OutfileURIContext* MySQLParser::IntoClauseContext::outfileURI() {
  return getRuleContext<MySQLParser::OutfileURIContext>(0);
}

MySQLParser::CharsetClauseContext* MySQLParser::IntoClauseContext::charsetClause() {
  return getRuleContext<MySQLParser::CharsetClauseContext>(0);
}

MySQLParser::OutfileFileInfoContext* MySQLParser::IntoClauseContext::outfileFileInfo() {
  return getRuleContext<MySQLParser::OutfileFileInfoContext>(0);
}


size_t MySQLParser::IntoClauseContext::getRuleIndex() const {
  return MySQLParser::RuleIntoClause;
}

void MySQLParser::IntoClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIntoClause(this);
}

void MySQLParser::IntoClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIntoClause(this);
}


std::any MySQLParser::IntoClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIntoClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IntoClauseContext* MySQLParser::intoClause() {
  IntoClauseContext *_localctx = _tracker.createInstance<IntoClauseContext>(_ctx, getState());
  enterRule(_localctx, 340, MySQLParser::RuleIntoClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3576);
    match(MySQLParser::INTO_SYMBOL);
    setState(3619);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 337, _ctx)) {
    case 1: {
      setState(3577);
      match(MySQLParser::OUTFILE_SYMBOL);
      setState(3595);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 331, _ctx)) {
      case 1: {
        setState(3578);

        if (!(serverVersion < 90101)) throw FailedPredicateException(this, "serverVersion < 90101");
        setState(3579);
        textStringLiteral();
        setState(3581);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 328, _ctx)) {
        case 1: {
          setState(3580);
          charsetClause();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(3583);

        if (!(serverVersion >= 90101)) throw FailedPredicateException(this, "serverVersion >= 90101");
        setState(3586);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 329, _ctx)) {
        case 1: {
          setState(3584);
          textStringLiteral();
          break;
        }

        case 2: {
          setState(3585);
          outfileURI();
          break;
        }

        default:
          break;
        }
        setState(3589);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 330, _ctx)) {
        case 1: {
          setState(3588);
          outfileFileInfo();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 3: {
        setState(3591);

        if (!(serverVersion >= 90101)) throw FailedPredicateException(this, "serverVersion >= 90101");
        setState(3592);
        match(MySQLParser::WITH_SYMBOL);
        setState(3593);
        match(MySQLParser::PARAMETERS_SYMBOL);
        setState(3594);
        jsonAttribute();
        break;
      }

      default:
        break;
      }
      setState(3598);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 332, _ctx)) {
      case 1: {
        setState(3597);
        fieldsClause();
        break;
      }

      default:
        break;
      }
      setState(3601);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 333, _ctx)) {
      case 1: {
        setState(3600);
        linesClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(3603);
      match(MySQLParser::DUMPFILE_SYMBOL);
      setState(3604);
      textStringLiteral();
      break;
    }

    case 3: {
      setState(3607);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 334, _ctx)) {
      case 1: {
        setState(3605);
        textOrIdentifier();
        break;
      }

      case 2: {
        setState(3606);
        userVariable();
        break;
      }

      default:
        break;
      }
      setState(3616);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 336, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3609);
          match(MySQLParser::COMMA_SYMBOL);
          setState(3612);
          _errHandler->sync(this);
          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 335, _ctx)) {
          case 1: {
            setState(3610);
            textOrIdentifier();
            break;
          }

          case 2: {
            setState(3611);
            userVariable();
            break;
          }

          default:
            break;
          } 
        }
        setState(3618);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 336, _ctx);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProcedureAnalyseClauseContext ------------------------------------------------------------------

MySQLParser::ProcedureAnalyseClauseContext::ProcedureAnalyseClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ProcedureAnalyseClauseContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProcedureAnalyseClauseContext::ANALYSE_SYMBOL() {
  return getToken(MySQLParser::ANALYSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProcedureAnalyseClauseContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProcedureAnalyseClauseContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ProcedureAnalyseClauseContext::INT_NUMBER() {
  return getTokens(MySQLParser::INT_NUMBER);
}

tree::TerminalNode* MySQLParser::ProcedureAnalyseClauseContext::INT_NUMBER(size_t i) {
  return getToken(MySQLParser::INT_NUMBER, i);
}

tree::TerminalNode* MySQLParser::ProcedureAnalyseClauseContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}


size_t MySQLParser::ProcedureAnalyseClauseContext::getRuleIndex() const {
  return MySQLParser::RuleProcedureAnalyseClause;
}

void MySQLParser::ProcedureAnalyseClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProcedureAnalyseClause(this);
}

void MySQLParser::ProcedureAnalyseClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProcedureAnalyseClause(this);
}


std::any MySQLParser::ProcedureAnalyseClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitProcedureAnalyseClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ProcedureAnalyseClauseContext* MySQLParser::procedureAnalyseClause() {
  ProcedureAnalyseClauseContext *_localctx = _tracker.createInstance<ProcedureAnalyseClauseContext>(_ctx, getState());
  enterRule(_localctx, 342, MySQLParser::RuleProcedureAnalyseClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3621);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(3622);
    match(MySQLParser::ANALYSE_SYMBOL);
    setState(3623);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3629);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::INT_NUMBER) {
      setState(3624);
      match(MySQLParser::INT_NUMBER);
      setState(3627);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(3625);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3626);
        match(MySQLParser::INT_NUMBER);
      }
    }
    setState(3631);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HavingClauseContext ------------------------------------------------------------------

MySQLParser::HavingClauseContext::HavingClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HavingClauseContext::HAVING_SYMBOL() {
  return getToken(MySQLParser::HAVING_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::HavingClauseContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::HavingClauseContext::getRuleIndex() const {
  return MySQLParser::RuleHavingClause;
}

void MySQLParser::HavingClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHavingClause(this);
}

void MySQLParser::HavingClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHavingClause(this);
}


std::any MySQLParser::HavingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHavingClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HavingClauseContext* MySQLParser::havingClause() {
  HavingClauseContext *_localctx = _tracker.createInstance<HavingClauseContext>(_ctx, getState());
  enterRule(_localctx, 344, MySQLParser::RuleHavingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3633);
    match(MySQLParser::HAVING_SYMBOL);
    setState(3634);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QualifyClauseContext ------------------------------------------------------------------

MySQLParser::QualifyClauseContext::QualifyClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::QualifyClauseContext::QUALIFY_SYMBOL() {
  return getToken(MySQLParser::QUALIFY_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::QualifyClauseContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::QualifyClauseContext::getRuleIndex() const {
  return MySQLParser::RuleQualifyClause;
}

void MySQLParser::QualifyClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQualifyClause(this);
}

void MySQLParser::QualifyClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQualifyClause(this);
}


std::any MySQLParser::QualifyClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQualifyClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QualifyClauseContext* MySQLParser::qualifyClause() {
  QualifyClauseContext *_localctx = _tracker.createInstance<QualifyClauseContext>(_ctx, getState());
  enterRule(_localctx, 346, MySQLParser::RuleQualifyClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3636);

    if (!(serverVersion >= 80300)) throw FailedPredicateException(this, "serverVersion >= 80300");
    setState(3637);
    match(MySQLParser::QUALIFY_SYMBOL);
    setState(3638);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowClauseContext ------------------------------------------------------------------

MySQLParser::WindowClauseContext::WindowClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowClauseContext::WINDOW_SYMBOL() {
  return getToken(MySQLParser::WINDOW_SYMBOL, 0);
}

std::vector<MySQLParser::WindowDefinitionContext *> MySQLParser::WindowClauseContext::windowDefinition() {
  return getRuleContexts<MySQLParser::WindowDefinitionContext>();
}

MySQLParser::WindowDefinitionContext* MySQLParser::WindowClauseContext::windowDefinition(size_t i) {
  return getRuleContext<MySQLParser::WindowDefinitionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::WindowClauseContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::WindowClauseContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::WindowClauseContext::getRuleIndex() const {
  return MySQLParser::RuleWindowClause;
}

void MySQLParser::WindowClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowClause(this);
}

void MySQLParser::WindowClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowClause(this);
}


std::any MySQLParser::WindowClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowClauseContext* MySQLParser::windowClause() {
  WindowClauseContext *_localctx = _tracker.createInstance<WindowClauseContext>(_ctx, getState());
  enterRule(_localctx, 348, MySQLParser::RuleWindowClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3640);
    match(MySQLParser::WINDOW_SYMBOL);
    setState(3641);
    windowDefinition();
    setState(3646);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 340, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3642);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3643);
        windowDefinition(); 
      }
      setState(3648);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 340, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowDefinitionContext ------------------------------------------------------------------

MySQLParser::WindowDefinitionContext::WindowDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::WindowNameContext* MySQLParser::WindowDefinitionContext::windowName() {
  return getRuleContext<MySQLParser::WindowNameContext>(0);
}

tree::TerminalNode* MySQLParser::WindowDefinitionContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::WindowSpecContext* MySQLParser::WindowDefinitionContext::windowSpec() {
  return getRuleContext<MySQLParser::WindowSpecContext>(0);
}


size_t MySQLParser::WindowDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleWindowDefinition;
}

void MySQLParser::WindowDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowDefinition(this);
}

void MySQLParser::WindowDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowDefinition(this);
}


std::any MySQLParser::WindowDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowDefinitionContext* MySQLParser::windowDefinition() {
  WindowDefinitionContext *_localctx = _tracker.createInstance<WindowDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 350, MySQLParser::RuleWindowDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3649);
    windowName();
    setState(3650);
    match(MySQLParser::AS_SYMBOL);
    setState(3651);
    windowSpec();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowSpecContext ------------------------------------------------------------------

MySQLParser::WindowSpecContext::WindowSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowSpecContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::WindowSpecDetailsContext* MySQLParser::WindowSpecContext::windowSpecDetails() {
  return getRuleContext<MySQLParser::WindowSpecDetailsContext>(0);
}

tree::TerminalNode* MySQLParser::WindowSpecContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::WindowSpecContext::getRuleIndex() const {
  return MySQLParser::RuleWindowSpec;
}

void MySQLParser::WindowSpecContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowSpec(this);
}

void MySQLParser::WindowSpecContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowSpec(this);
}


std::any MySQLParser::WindowSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowSpec(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowSpecContext* MySQLParser::windowSpec() {
  WindowSpecContext *_localctx = _tracker.createInstance<WindowSpecContext>(_ctx, getState());
  enterRule(_localctx, 352, MySQLParser::RuleWindowSpec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3653);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3654);
    windowSpecDetails();
    setState(3655);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowSpecDetailsContext ------------------------------------------------------------------

MySQLParser::WindowSpecDetailsContext::WindowSpecDetailsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::WindowNameContext* MySQLParser::WindowSpecDetailsContext::windowName() {
  return getRuleContext<MySQLParser::WindowNameContext>(0);
}

tree::TerminalNode* MySQLParser::WindowSpecDetailsContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowSpecDetailsContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::OrderListContext* MySQLParser::WindowSpecDetailsContext::orderList() {
  return getRuleContext<MySQLParser::OrderListContext>(0);
}

MySQLParser::OrderClauseContext* MySQLParser::WindowSpecDetailsContext::orderClause() {
  return getRuleContext<MySQLParser::OrderClauseContext>(0);
}

MySQLParser::WindowFrameClauseContext* MySQLParser::WindowSpecDetailsContext::windowFrameClause() {
  return getRuleContext<MySQLParser::WindowFrameClauseContext>(0);
}


size_t MySQLParser::WindowSpecDetailsContext::getRuleIndex() const {
  return MySQLParser::RuleWindowSpecDetails;
}

void MySQLParser::WindowSpecDetailsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowSpecDetails(this);
}

void MySQLParser::WindowSpecDetailsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowSpecDetails(this);
}


std::any MySQLParser::WindowSpecDetailsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowSpecDetails(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowSpecDetailsContext* MySQLParser::windowSpecDetails() {
  WindowSpecDetailsContext *_localctx = _tracker.createInstance<WindowSpecDetailsContext>(_ctx, getState());
  enterRule(_localctx, 354, MySQLParser::RuleWindowSpecDetails);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3658);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 341, _ctx)) {
    case 1: {
      setState(3657);
      windowName();
      break;
    }

    default:
      break;
    }
    setState(3663);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::PARTITION_SYMBOL) {
      setState(3660);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(3661);
      match(MySQLParser::BY_SYMBOL);
      setState(3662);
      orderList();
    }
    setState(3666);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ORDER_SYMBOL) {
      setState(3665);
      orderClause();
    }
    setState(3669);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::RANGE_SYMBOL

    || _la == MySQLParser::ROWS_SYMBOL || _la == MySQLParser::GROUPS_SYMBOL) {
      setState(3668);
      windowFrameClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameClauseContext ------------------------------------------------------------------

MySQLParser::WindowFrameClauseContext::WindowFrameClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::WindowFrameUnitsContext* MySQLParser::WindowFrameClauseContext::windowFrameUnits() {
  return getRuleContext<MySQLParser::WindowFrameUnitsContext>(0);
}

MySQLParser::WindowFrameExtentContext* MySQLParser::WindowFrameClauseContext::windowFrameExtent() {
  return getRuleContext<MySQLParser::WindowFrameExtentContext>(0);
}

MySQLParser::WindowFrameExclusionContext* MySQLParser::WindowFrameClauseContext::windowFrameExclusion() {
  return getRuleContext<MySQLParser::WindowFrameExclusionContext>(0);
}


size_t MySQLParser::WindowFrameClauseContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameClause;
}

void MySQLParser::WindowFrameClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameClause(this);
}

void MySQLParser::WindowFrameClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameClause(this);
}


std::any MySQLParser::WindowFrameClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameClauseContext* MySQLParser::windowFrameClause() {
  WindowFrameClauseContext *_localctx = _tracker.createInstance<WindowFrameClauseContext>(_ctx, getState());
  enterRule(_localctx, 356, MySQLParser::RuleWindowFrameClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3671);
    windowFrameUnits();
    setState(3672);
    windowFrameExtent();
    setState(3674);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::EXCLUDE_SYMBOL) {
      setState(3673);
      windowFrameExclusion();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameUnitsContext ------------------------------------------------------------------

MySQLParser::WindowFrameUnitsContext::WindowFrameUnitsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowFrameUnitsContext::ROWS_SYMBOL() {
  return getToken(MySQLParser::ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameUnitsContext::RANGE_SYMBOL() {
  return getToken(MySQLParser::RANGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameUnitsContext::GROUPS_SYMBOL() {
  return getToken(MySQLParser::GROUPS_SYMBOL, 0);
}


size_t MySQLParser::WindowFrameUnitsContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameUnits;
}

void MySQLParser::WindowFrameUnitsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameUnits(this);
}

void MySQLParser::WindowFrameUnitsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameUnits(this);
}


std::any MySQLParser::WindowFrameUnitsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameUnits(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameUnitsContext* MySQLParser::windowFrameUnits() {
  WindowFrameUnitsContext *_localctx = _tracker.createInstance<WindowFrameUnitsContext>(_ctx, getState());
  enterRule(_localctx, 358, MySQLParser::RuleWindowFrameUnits);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3676);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::RANGE_SYMBOL

    || _la == MySQLParser::ROWS_SYMBOL || _la == MySQLParser::GROUPS_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameExtentContext ------------------------------------------------------------------

MySQLParser::WindowFrameExtentContext::WindowFrameExtentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::WindowFrameStartContext* MySQLParser::WindowFrameExtentContext::windowFrameStart() {
  return getRuleContext<MySQLParser::WindowFrameStartContext>(0);
}

MySQLParser::WindowFrameBetweenContext* MySQLParser::WindowFrameExtentContext::windowFrameBetween() {
  return getRuleContext<MySQLParser::WindowFrameBetweenContext>(0);
}


size_t MySQLParser::WindowFrameExtentContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameExtent;
}

void MySQLParser::WindowFrameExtentContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameExtent(this);
}

void MySQLParser::WindowFrameExtentContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameExtent(this);
}


std::any MySQLParser::WindowFrameExtentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameExtent(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameExtentContext* MySQLParser::windowFrameExtent() {
  WindowFrameExtentContext *_localctx = _tracker.createInstance<WindowFrameExtentContext>(_ctx, getState());
  enterRule(_localctx, 360, MySQLParser::RuleWindowFrameExtent);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3680);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER:
      case MySQLParser::PARAM_MARKER:
      case MySQLParser::DECIMAL_NUMBER:
      case MySQLParser::FLOAT_NUMBER:
      case MySQLParser::CURRENT_SYMBOL:
      case MySQLParser::INTERVAL_SYMBOL:
      case MySQLParser::UNBOUNDED_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3678);
        windowFrameStart();
        break;
      }

      case MySQLParser::BETWEEN_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3679);
        windowFrameBetween();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameStartContext ------------------------------------------------------------------

MySQLParser::WindowFrameStartContext::WindowFrameStartContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowFrameStartContext::UNBOUNDED_SYMBOL() {
  return getToken(MySQLParser::UNBOUNDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameStartContext::PRECEDING_SYMBOL() {
  return getToken(MySQLParser::PRECEDING_SYMBOL, 0);
}

MySQLParser::UlonglongNumberContext* MySQLParser::WindowFrameStartContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFrameStartContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameStartContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::WindowFrameStartContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::IntervalContext* MySQLParser::WindowFrameStartContext::interval() {
  return getRuleContext<MySQLParser::IntervalContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFrameStartContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameStartContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}


size_t MySQLParser::WindowFrameStartContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameStart;
}

void MySQLParser::WindowFrameStartContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameStart(this);
}

void MySQLParser::WindowFrameStartContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameStart(this);
}


std::any MySQLParser::WindowFrameStartContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameStart(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameStartContext* MySQLParser::windowFrameStart() {
  WindowFrameStartContext *_localctx = _tracker.createInstance<WindowFrameStartContext>(_ctx, getState());
  enterRule(_localctx, 362, MySQLParser::RuleWindowFrameStart);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3696);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UNBOUNDED_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3682);
        match(MySQLParser::UNBOUNDED_SYMBOL);
        setState(3683);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER:
      case MySQLParser::DECIMAL_NUMBER:
      case MySQLParser::FLOAT_NUMBER: {
        enterOuterAlt(_localctx, 2);
        setState(3684);
        ulonglongNumber();
        setState(3685);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::PARAM_MARKER: {
        enterOuterAlt(_localctx, 3);
        setState(3687);
        match(MySQLParser::PARAM_MARKER);
        setState(3688);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::INTERVAL_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(3689);
        match(MySQLParser::INTERVAL_SYMBOL);
        setState(3690);
        expr(0);
        setState(3691);
        interval();
        setState(3692);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::CURRENT_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(3694);
        match(MySQLParser::CURRENT_SYMBOL);
        setState(3695);
        match(MySQLParser::ROW_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameBetweenContext ------------------------------------------------------------------

MySQLParser::WindowFrameBetweenContext::WindowFrameBetweenContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowFrameBetweenContext::BETWEEN_SYMBOL() {
  return getToken(MySQLParser::BETWEEN_SYMBOL, 0);
}

std::vector<MySQLParser::WindowFrameBoundContext *> MySQLParser::WindowFrameBetweenContext::windowFrameBound() {
  return getRuleContexts<MySQLParser::WindowFrameBoundContext>();
}

MySQLParser::WindowFrameBoundContext* MySQLParser::WindowFrameBetweenContext::windowFrameBound(size_t i) {
  return getRuleContext<MySQLParser::WindowFrameBoundContext>(i);
}

tree::TerminalNode* MySQLParser::WindowFrameBetweenContext::AND_SYMBOL() {
  return getToken(MySQLParser::AND_SYMBOL, 0);
}


size_t MySQLParser::WindowFrameBetweenContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameBetween;
}

void MySQLParser::WindowFrameBetweenContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameBetween(this);
}

void MySQLParser::WindowFrameBetweenContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameBetween(this);
}


std::any MySQLParser::WindowFrameBetweenContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameBetween(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameBetweenContext* MySQLParser::windowFrameBetween() {
  WindowFrameBetweenContext *_localctx = _tracker.createInstance<WindowFrameBetweenContext>(_ctx, getState());
  enterRule(_localctx, 364, MySQLParser::RuleWindowFrameBetween);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3698);
    match(MySQLParser::BETWEEN_SYMBOL);
    setState(3699);
    windowFrameBound();
    setState(3700);
    match(MySQLParser::AND_SYMBOL);
    setState(3701);
    windowFrameBound();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameBoundContext ------------------------------------------------------------------

MySQLParser::WindowFrameBoundContext::WindowFrameBoundContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::WindowFrameStartContext* MySQLParser::WindowFrameBoundContext::windowFrameStart() {
  return getRuleContext<MySQLParser::WindowFrameStartContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFrameBoundContext::UNBOUNDED_SYMBOL() {
  return getToken(MySQLParser::UNBOUNDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameBoundContext::FOLLOWING_SYMBOL() {
  return getToken(MySQLParser::FOLLOWING_SYMBOL, 0);
}

MySQLParser::UlonglongNumberContext* MySQLParser::WindowFrameBoundContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFrameBoundContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameBoundContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::WindowFrameBoundContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::IntervalContext* MySQLParser::WindowFrameBoundContext::interval() {
  return getRuleContext<MySQLParser::IntervalContext>(0);
}


size_t MySQLParser::WindowFrameBoundContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameBound;
}

void MySQLParser::WindowFrameBoundContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameBound(this);
}

void MySQLParser::WindowFrameBoundContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameBound(this);
}


std::any MySQLParser::WindowFrameBoundContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameBound(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameBoundContext* MySQLParser::windowFrameBound() {
  WindowFrameBoundContext *_localctx = _tracker.createInstance<WindowFrameBoundContext>(_ctx, getState());
  enterRule(_localctx, 366, MySQLParser::RuleWindowFrameBound);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3716);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 348, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3703);
      windowFrameStart();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3704);
      match(MySQLParser::UNBOUNDED_SYMBOL);
      setState(3705);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3706);
      ulonglongNumber();
      setState(3707);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3709);
      match(MySQLParser::PARAM_MARKER);
      setState(3710);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3711);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(3712);
      expr(0);
      setState(3713);
      interval();
      setState(3714);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFrameExclusionContext ------------------------------------------------------------------

MySQLParser::WindowFrameExclusionContext::WindowFrameExclusionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::EXCLUDE_SYMBOL() {
  return getToken(MySQLParser::EXCLUDE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::TIES_SYMBOL() {
  return getToken(MySQLParser::TIES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFrameExclusionContext::OTHERS_SYMBOL() {
  return getToken(MySQLParser::OTHERS_SYMBOL, 0);
}


size_t MySQLParser::WindowFrameExclusionContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFrameExclusion;
}

void MySQLParser::WindowFrameExclusionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFrameExclusion(this);
}

void MySQLParser::WindowFrameExclusionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFrameExclusion(this);
}


std::any MySQLParser::WindowFrameExclusionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFrameExclusion(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFrameExclusionContext* MySQLParser::windowFrameExclusion() {
  WindowFrameExclusionContext *_localctx = _tracker.createInstance<WindowFrameExclusionContext>(_ctx, getState());
  enterRule(_localctx, 368, MySQLParser::RuleWindowFrameExclusion);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3718);
    match(MySQLParser::EXCLUDE_SYMBOL);
    setState(3725);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CURRENT_SYMBOL: {
        setState(3719);
        match(MySQLParser::CURRENT_SYMBOL);
        setState(3720);
        match(MySQLParser::ROW_SYMBOL);
        break;
      }

      case MySQLParser::GROUP_SYMBOL: {
        setState(3721);
        match(MySQLParser::GROUP_SYMBOL);
        break;
      }

      case MySQLParser::TIES_SYMBOL: {
        setState(3722);
        match(MySQLParser::TIES_SYMBOL);
        break;
      }

      case MySQLParser::NO_SYMBOL: {
        setState(3723);
        match(MySQLParser::NO_SYMBOL);
        setState(3724);
        match(MySQLParser::OTHERS_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WithClauseContext ------------------------------------------------------------------

MySQLParser::WithClauseContext::WithClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WithClauseContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

std::vector<MySQLParser::CommonTableExpressionContext *> MySQLParser::WithClauseContext::commonTableExpression() {
  return getRuleContexts<MySQLParser::CommonTableExpressionContext>();
}

MySQLParser::CommonTableExpressionContext* MySQLParser::WithClauseContext::commonTableExpression(size_t i) {
  return getRuleContext<MySQLParser::CommonTableExpressionContext>(i);
}

tree::TerminalNode* MySQLParser::WithClauseContext::RECURSIVE_SYMBOL() {
  return getToken(MySQLParser::RECURSIVE_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::WithClauseContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::WithClauseContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::WithClauseContext::getRuleIndex() const {
  return MySQLParser::RuleWithClause;
}

void MySQLParser::WithClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWithClause(this);
}

void MySQLParser::WithClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWithClause(this);
}


std::any MySQLParser::WithClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWithClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WithClauseContext* MySQLParser::withClause() {
  WithClauseContext *_localctx = _tracker.createInstance<WithClauseContext>(_ctx, getState());
  enterRule(_localctx, 370, MySQLParser::RuleWithClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3727);
    match(MySQLParser::WITH_SYMBOL);
    setState(3729);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 350, _ctx)) {
    case 1: {
      setState(3728);
      match(MySQLParser::RECURSIVE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3731);
    commonTableExpression();
    setState(3736);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 351, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3732);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3733);
        commonTableExpression(); 
      }
      setState(3738);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 351, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CommonTableExpressionContext ------------------------------------------------------------------

MySQLParser::CommonTableExpressionContext::CommonTableExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::CommonTableExpressionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CommonTableExpressionContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::SubqueryContext* MySQLParser::CommonTableExpressionContext::subquery() {
  return getRuleContext<MySQLParser::SubqueryContext>(0);
}

MySQLParser::ColumnInternalRefListContext* MySQLParser::CommonTableExpressionContext::columnInternalRefList() {
  return getRuleContext<MySQLParser::ColumnInternalRefListContext>(0);
}


size_t MySQLParser::CommonTableExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleCommonTableExpression;
}

void MySQLParser::CommonTableExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCommonTableExpression(this);
}

void MySQLParser::CommonTableExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCommonTableExpression(this);
}


std::any MySQLParser::CommonTableExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCommonTableExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CommonTableExpressionContext* MySQLParser::commonTableExpression() {
  CommonTableExpressionContext *_localctx = _tracker.createInstance<CommonTableExpressionContext>(_ctx, getState());
  enterRule(_localctx, 372, MySQLParser::RuleCommonTableExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3739);
    identifier();
    setState(3741);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(3740);
      columnInternalRefList();
    }
    setState(3743);
    match(MySQLParser::AS_SYMBOL);
    setState(3744);
    subquery();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupByClauseContext ------------------------------------------------------------------

MySQLParser::GroupByClauseContext::GroupByClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GroupByClauseContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupByClauseContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::OrderListContext* MySQLParser::GroupByClauseContext::orderList() {
  return getRuleContext<MySQLParser::OrderListContext>(0);
}

MySQLParser::OlapOptionContext* MySQLParser::GroupByClauseContext::olapOption() {
  return getRuleContext<MySQLParser::OlapOptionContext>(0);
}

tree::TerminalNode* MySQLParser::GroupByClauseContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::GroupListContext* MySQLParser::GroupByClauseContext::groupList() {
  return getRuleContext<MySQLParser::GroupListContext>(0);
}

tree::TerminalNode* MySQLParser::GroupByClauseContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupByClauseContext::ROLLUP_SYMBOL() {
  return getToken(MySQLParser::ROLLUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupByClauseContext::CUBE_SYMBOL() {
  return getToken(MySQLParser::CUBE_SYMBOL, 0);
}


size_t MySQLParser::GroupByClauseContext::getRuleIndex() const {
  return MySQLParser::RuleGroupByClause;
}

void MySQLParser::GroupByClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupByClause(this);
}

void MySQLParser::GroupByClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupByClause(this);
}


std::any MySQLParser::GroupByClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupByClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupByClauseContext* MySQLParser::groupByClause() {
  GroupByClauseContext *_localctx = _tracker.createInstance<GroupByClauseContext>(_ctx, getState());
  enterRule(_localctx, 374, MySQLParser::RuleGroupByClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3760);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 354, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3746);
      match(MySQLParser::GROUP_SYMBOL);
      setState(3747);
      match(MySQLParser::BY_SYMBOL);
      setState(3748);
      orderList();
      setState(3750);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 353, _ctx)) {
      case 1: {
        setState(3749);
        olapOption();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3752);

      if (!(serverVersion >= 80032)) throw FailedPredicateException(this, "serverVersion >= 80032");
      setState(3753);
      match(MySQLParser::GROUP_SYMBOL);
      setState(3754);
      match(MySQLParser::BY_SYMBOL);
      setState(3755);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CUBE_SYMBOL || _la == MySQLParser::ROLLUP_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3756);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(3757);
      groupList();
      setState(3758);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OlapOptionContext ------------------------------------------------------------------

MySQLParser::OlapOptionContext::OlapOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OlapOptionContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OlapOptionContext::ROLLUP_SYMBOL() {
  return getToken(MySQLParser::ROLLUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OlapOptionContext::CUBE_SYMBOL() {
  return getToken(MySQLParser::CUBE_SYMBOL, 0);
}


size_t MySQLParser::OlapOptionContext::getRuleIndex() const {
  return MySQLParser::RuleOlapOption;
}

void MySQLParser::OlapOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOlapOption(this);
}

void MySQLParser::OlapOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOlapOption(this);
}


std::any MySQLParser::OlapOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOlapOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OlapOptionContext* MySQLParser::olapOption() {
  OlapOptionContext *_localctx = _tracker.createInstance<OlapOptionContext>(_ctx, getState());
  enterRule(_localctx, 376, MySQLParser::RuleOlapOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3767);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 355, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3762);
      match(MySQLParser::WITH_SYMBOL);
      setState(3763);
      match(MySQLParser::ROLLUP_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3764);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(3765);
      match(MySQLParser::WITH_SYMBOL);
      setState(3766);
      match(MySQLParser::CUBE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OrderClauseContext ------------------------------------------------------------------

MySQLParser::OrderClauseContext::OrderClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OrderClauseContext::ORDER_SYMBOL() {
  return getToken(MySQLParser::ORDER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OrderClauseContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::OrderListContext* MySQLParser::OrderClauseContext::orderList() {
  return getRuleContext<MySQLParser::OrderListContext>(0);
}


size_t MySQLParser::OrderClauseContext::getRuleIndex() const {
  return MySQLParser::RuleOrderClause;
}

void MySQLParser::OrderClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOrderClause(this);
}

void MySQLParser::OrderClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOrderClause(this);
}


std::any MySQLParser::OrderClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOrderClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OrderClauseContext* MySQLParser::orderClause() {
  OrderClauseContext *_localctx = _tracker.createInstance<OrderClauseContext>(_ctx, getState());
  enterRule(_localctx, 378, MySQLParser::RuleOrderClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3769);
    match(MySQLParser::ORDER_SYMBOL);
    setState(3770);
    match(MySQLParser::BY_SYMBOL);
    setState(3771);
    orderList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DirectionContext ------------------------------------------------------------------

MySQLParser::DirectionContext::DirectionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DirectionContext::ASC_SYMBOL() {
  return getToken(MySQLParser::ASC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DirectionContext::DESC_SYMBOL() {
  return getToken(MySQLParser::DESC_SYMBOL, 0);
}


size_t MySQLParser::DirectionContext::getRuleIndex() const {
  return MySQLParser::RuleDirection;
}

void MySQLParser::DirectionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDirection(this);
}

void MySQLParser::DirectionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDirection(this);
}


std::any MySQLParser::DirectionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDirection(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DirectionContext* MySQLParser::direction() {
  DirectionContext *_localctx = _tracker.createInstance<DirectionContext>(_ctx, getState());
  enterRule(_localctx, 380, MySQLParser::RuleDirection);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3773);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FromClauseContext ------------------------------------------------------------------

MySQLParser::FromClauseContext::FromClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FromClauseContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FromClauseContext::DUAL_SYMBOL() {
  return getToken(MySQLParser::DUAL_SYMBOL, 0);
}

MySQLParser::TableReferenceListContext* MySQLParser::FromClauseContext::tableReferenceList() {
  return getRuleContext<MySQLParser::TableReferenceListContext>(0);
}


size_t MySQLParser::FromClauseContext::getRuleIndex() const {
  return MySQLParser::RuleFromClause;
}

void MySQLParser::FromClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFromClause(this);
}

void MySQLParser::FromClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFromClause(this);
}


std::any MySQLParser::FromClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFromClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FromClauseContext* MySQLParser::fromClause() {
  FromClauseContext *_localctx = _tracker.createInstance<FromClauseContext>(_ctx, getState());
  enterRule(_localctx, 382, MySQLParser::RuleFromClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3775);
    match(MySQLParser::FROM_SYMBOL);
    setState(3778);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 356, _ctx)) {
    case 1: {
      setState(3776);
      match(MySQLParser::DUAL_SYMBOL);
      break;
    }

    case 2: {
      setState(3777);
      tableReferenceList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableReferenceListContext ------------------------------------------------------------------

MySQLParser::TableReferenceListContext::TableReferenceListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TableReferenceContext *> MySQLParser::TableReferenceListContext::tableReference() {
  return getRuleContexts<MySQLParser::TableReferenceContext>();
}

MySQLParser::TableReferenceContext* MySQLParser::TableReferenceListContext::tableReference(size_t i) {
  return getRuleContext<MySQLParser::TableReferenceContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TableReferenceListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TableReferenceListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TableReferenceListContext::getRuleIndex() const {
  return MySQLParser::RuleTableReferenceList;
}

void MySQLParser::TableReferenceListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableReferenceList(this);
}

void MySQLParser::TableReferenceListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableReferenceList(this);
}


std::any MySQLParser::TableReferenceListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableReferenceList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableReferenceListContext* MySQLParser::tableReferenceList() {
  TableReferenceListContext *_localctx = _tracker.createInstance<TableReferenceListContext>(_ctx, getState());
  enterRule(_localctx, 384, MySQLParser::RuleTableReferenceList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3780);
    tableReference();
    setState(3785);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 357, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3781);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3782);
        tableReference(); 
      }
      setState(3787);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 357, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableValueConstructorContext ------------------------------------------------------------------

MySQLParser::TableValueConstructorContext::TableValueConstructorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TableValueConstructorContext::VALUES_SYMBOL() {
  return getToken(MySQLParser::VALUES_SYMBOL, 0);
}

std::vector<MySQLParser::RowValueExplicitContext *> MySQLParser::TableValueConstructorContext::rowValueExplicit() {
  return getRuleContexts<MySQLParser::RowValueExplicitContext>();
}

MySQLParser::RowValueExplicitContext* MySQLParser::TableValueConstructorContext::rowValueExplicit(size_t i) {
  return getRuleContext<MySQLParser::RowValueExplicitContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TableValueConstructorContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TableValueConstructorContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TableValueConstructorContext::getRuleIndex() const {
  return MySQLParser::RuleTableValueConstructor;
}

void MySQLParser::TableValueConstructorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableValueConstructor(this);
}

void MySQLParser::TableValueConstructorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableValueConstructor(this);
}


std::any MySQLParser::TableValueConstructorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableValueConstructor(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableValueConstructorContext* MySQLParser::tableValueConstructor() {
  TableValueConstructorContext *_localctx = _tracker.createInstance<TableValueConstructorContext>(_ctx, getState());
  enterRule(_localctx, 386, MySQLParser::RuleTableValueConstructor);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3788);
    match(MySQLParser::VALUES_SYMBOL);
    setState(3789);
    rowValueExplicit();
    setState(3794);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 358, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3790);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3791);
        rowValueExplicit(); 
      }
      setState(3796);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 358, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplicitTableContext ------------------------------------------------------------------

MySQLParser::ExplicitTableContext::ExplicitTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExplicitTableContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::ExplicitTableContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}


size_t MySQLParser::ExplicitTableContext::getRuleIndex() const {
  return MySQLParser::RuleExplicitTable;
}

void MySQLParser::ExplicitTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExplicitTable(this);
}

void MySQLParser::ExplicitTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExplicitTable(this);
}


std::any MySQLParser::ExplicitTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExplicitTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExplicitTableContext* MySQLParser::explicitTable() {
  ExplicitTableContext *_localctx = _tracker.createInstance<ExplicitTableContext>(_ctx, getState());
  enterRule(_localctx, 388, MySQLParser::RuleExplicitTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3797);
    match(MySQLParser::TABLE_SYMBOL);
    setState(3798);
    tableRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RowValueExplicitContext ------------------------------------------------------------------

MySQLParser::RowValueExplicitContext::RowValueExplicitContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RowValueExplicitContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RowValueExplicitContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RowValueExplicitContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::ValuesContext* MySQLParser::RowValueExplicitContext::values() {
  return getRuleContext<MySQLParser::ValuesContext>(0);
}


size_t MySQLParser::RowValueExplicitContext::getRuleIndex() const {
  return MySQLParser::RuleRowValueExplicit;
}

void MySQLParser::RowValueExplicitContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRowValueExplicit(this);
}

void MySQLParser::RowValueExplicitContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRowValueExplicit(this);
}


std::any MySQLParser::RowValueExplicitContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRowValueExplicit(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RowValueExplicitContext* MySQLParser::rowValueExplicit() {
  RowValueExplicitContext *_localctx = _tracker.createInstance<RowValueExplicitContext>(_ctx, getState());
  enterRule(_localctx, 390, MySQLParser::RuleRowValueExplicit);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3800);
    match(MySQLParser::ROW_SYMBOL);
    setState(3801);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3803);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 359, _ctx)) {
    case 1: {
      setState(3802);
      values();
      break;
    }

    default:
      break;
    }
    setState(3805);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectOptionContext ------------------------------------------------------------------

MySQLParser::SelectOptionContext::SelectOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QuerySpecOptionContext* MySQLParser::SelectOptionContext::querySpecOption() {
  return getRuleContext<MySQLParser::QuerySpecOptionContext>(0);
}

tree::TerminalNode* MySQLParser::SelectOptionContext::SQL_NO_CACHE_SYMBOL() {
  return getToken(MySQLParser::SQL_NO_CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SelectOptionContext::SQL_CACHE_SYMBOL() {
  return getToken(MySQLParser::SQL_CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SelectOptionContext::MAX_STATEMENT_TIME_SYMBOL() {
  return getToken(MySQLParser::MAX_STATEMENT_TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SelectOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::SelectOptionContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}


size_t MySQLParser::SelectOptionContext::getRuleIndex() const {
  return MySQLParser::RuleSelectOption;
}

void MySQLParser::SelectOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSelectOption(this);
}

void MySQLParser::SelectOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSelectOption(this);
}


std::any MySQLParser::SelectOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSelectOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SelectOptionContext* MySQLParser::selectOption() {
  SelectOptionContext *_localctx = _tracker.createInstance<SelectOptionContext>(_ctx, getState());
  enterRule(_localctx, 392, MySQLParser::RuleSelectOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3815);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 360, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3807);
      querySpecOption();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3808);
      match(MySQLParser::SQL_NO_CACHE_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3809);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(3810);
      match(MySQLParser::SQL_CACHE_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3811);

      if (!(serverVersion >= 50704 && serverVersion < 50708)) throw FailedPredicateException(this, "serverVersion >= 50704 && serverVersion < 50708");
      setState(3812);
      match(MySQLParser::MAX_STATEMENT_TIME_SYMBOL);
      setState(3813);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(3814);
      real_ulong_number();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockingClauseListContext ------------------------------------------------------------------

MySQLParser::LockingClauseListContext::LockingClauseListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::LockingClauseContext *> MySQLParser::LockingClauseListContext::lockingClause() {
  return getRuleContexts<MySQLParser::LockingClauseContext>();
}

MySQLParser::LockingClauseContext* MySQLParser::LockingClauseListContext::lockingClause(size_t i) {
  return getRuleContext<MySQLParser::LockingClauseContext>(i);
}


size_t MySQLParser::LockingClauseListContext::getRuleIndex() const {
  return MySQLParser::RuleLockingClauseList;
}

void MySQLParser::LockingClauseListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockingClauseList(this);
}

void MySQLParser::LockingClauseListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockingClauseList(this);
}


std::any MySQLParser::LockingClauseListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockingClauseList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockingClauseListContext* MySQLParser::lockingClauseList() {
  LockingClauseListContext *_localctx = _tracker.createInstance<LockingClauseListContext>(_ctx, getState());
  enterRule(_localctx, 394, MySQLParser::RuleLockingClauseList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3817);

    if (!(serverVersion >= 80031)) throw FailedPredicateException(this, "serverVersion >= 80031");
    setState(3819); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(3818);
      lockingClause();
      setState(3821); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == MySQLParser::FOR_SYMBOL || _la == MySQLParser::LOCK_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockingClauseContext ------------------------------------------------------------------

MySQLParser::LockingClauseContext::LockingClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LockingClauseContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::LockStrenghContext* MySQLParser::LockingClauseContext::lockStrengh() {
  return getRuleContext<MySQLParser::LockStrenghContext>(0);
}

tree::TerminalNode* MySQLParser::LockingClauseContext::OF_SYMBOL() {
  return getToken(MySQLParser::OF_SYMBOL, 0);
}

MySQLParser::TableAliasRefListContext* MySQLParser::LockingClauseContext::tableAliasRefList() {
  return getRuleContext<MySQLParser::TableAliasRefListContext>(0);
}

MySQLParser::LockedRowActionContext* MySQLParser::LockingClauseContext::lockedRowAction() {
  return getRuleContext<MySQLParser::LockedRowActionContext>(0);
}

tree::TerminalNode* MySQLParser::LockingClauseContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockingClauseContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockingClauseContext::SHARE_SYMBOL() {
  return getToken(MySQLParser::SHARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockingClauseContext::MODE_SYMBOL() {
  return getToken(MySQLParser::MODE_SYMBOL, 0);
}


size_t MySQLParser::LockingClauseContext::getRuleIndex() const {
  return MySQLParser::RuleLockingClause;
}

void MySQLParser::LockingClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockingClause(this);
}

void MySQLParser::LockingClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockingClause(this);
}


std::any MySQLParser::LockingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockingClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockingClauseContext* MySQLParser::lockingClause() {
  LockingClauseContext *_localctx = _tracker.createInstance<LockingClauseContext>(_ctx, getState());
  enterRule(_localctx, 396, MySQLParser::RuleLockingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3838);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FOR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3823);
        match(MySQLParser::FOR_SYMBOL);
        setState(3824);
        lockStrengh();
        setState(3828);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 362, _ctx)) {
        case 1: {
          setState(3825);

          if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
          setState(3826);
          match(MySQLParser::OF_SYMBOL);
          setState(3827);
          tableAliasRefList();
          break;
        }

        default:
          break;
        }
        setState(3832);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 363, _ctx)) {
        case 1: {
          setState(3830);

          if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
          setState(3831);
          lockedRowAction();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::LOCK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3834);
        match(MySQLParser::LOCK_SYMBOL);
        setState(3835);
        match(MySQLParser::IN_SYMBOL);
        setState(3836);
        match(MySQLParser::SHARE_SYMBOL);
        setState(3837);
        match(MySQLParser::MODE_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockStrenghContext ------------------------------------------------------------------

MySQLParser::LockStrenghContext::LockStrenghContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LockStrenghContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockStrenghContext::SHARE_SYMBOL() {
  return getToken(MySQLParser::SHARE_SYMBOL, 0);
}


size_t MySQLParser::LockStrenghContext::getRuleIndex() const {
  return MySQLParser::RuleLockStrengh;
}

void MySQLParser::LockStrenghContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockStrengh(this);
}

void MySQLParser::LockStrenghContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockStrengh(this);
}


std::any MySQLParser::LockStrenghContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockStrengh(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockStrenghContext* MySQLParser::lockStrengh() {
  LockStrenghContext *_localctx = _tracker.createInstance<LockStrenghContext>(_ctx, getState());
  enterRule(_localctx, 398, MySQLParser::RuleLockStrengh);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3843);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 365, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3840);
      match(MySQLParser::UPDATE_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3841);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3842);
      match(MySQLParser::SHARE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockedRowActionContext ------------------------------------------------------------------

MySQLParser::LockedRowActionContext::LockedRowActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LockedRowActionContext::SKIP_SYMBOL() {
  return getToken(MySQLParser::SKIP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockedRowActionContext::LOCKED_SYMBOL() {
  return getToken(MySQLParser::LOCKED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockedRowActionContext::NOWAIT_SYMBOL() {
  return getToken(MySQLParser::NOWAIT_SYMBOL, 0);
}


size_t MySQLParser::LockedRowActionContext::getRuleIndex() const {
  return MySQLParser::RuleLockedRowAction;
}

void MySQLParser::LockedRowActionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockedRowAction(this);
}

void MySQLParser::LockedRowActionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockedRowAction(this);
}


std::any MySQLParser::LockedRowActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockedRowAction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockedRowActionContext* MySQLParser::lockedRowAction() {
  LockedRowActionContext *_localctx = _tracker.createInstance<LockedRowActionContext>(_ctx, getState());
  enterRule(_localctx, 400, MySQLParser::RuleLockedRowAction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3848);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::SKIP_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3845);
        match(MySQLParser::SKIP_SYMBOL);
        setState(3846);
        match(MySQLParser::LOCKED_SYMBOL);
        break;
      }

      case MySQLParser::NOWAIT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3847);
        match(MySQLParser::NOWAIT_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectItemListContext ------------------------------------------------------------------

MySQLParser::SelectItemListContext::SelectItemListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SelectItemContext *> MySQLParser::SelectItemListContext::selectItem() {
  return getRuleContexts<MySQLParser::SelectItemContext>();
}

MySQLParser::SelectItemContext* MySQLParser::SelectItemListContext::selectItem(size_t i) {
  return getRuleContext<MySQLParser::SelectItemContext>(i);
}

tree::TerminalNode* MySQLParser::SelectItemListContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::SelectItemListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::SelectItemListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::SelectItemListContext::getRuleIndex() const {
  return MySQLParser::RuleSelectItemList;
}

void MySQLParser::SelectItemListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSelectItemList(this);
}

void MySQLParser::SelectItemListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSelectItemList(this);
}


std::any MySQLParser::SelectItemListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSelectItemList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SelectItemListContext* MySQLParser::selectItemList() {
  SelectItemListContext *_localctx = _tracker.createInstance<SelectItemListContext>(_ctx, getState());
  enterRule(_localctx, 402, MySQLParser::RuleSelectItemList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3852);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 367, _ctx)) {
    case 1: {
      setState(3850);
      selectItem();
      break;
    }

    case 2: {
      setState(3851);
      match(MySQLParser::MULT_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(3858);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 368, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3854);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3855);
        selectItem(); 
      }
      setState(3860);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 368, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectItemContext ------------------------------------------------------------------

MySQLParser::SelectItemContext::SelectItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableWildContext* MySQLParser::SelectItemContext::tableWild() {
  return getRuleContext<MySQLParser::TableWildContext>(0);
}

MySQLParser::ExprContext* MySQLParser::SelectItemContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::SelectAliasContext* MySQLParser::SelectItemContext::selectAlias() {
  return getRuleContext<MySQLParser::SelectAliasContext>(0);
}


size_t MySQLParser::SelectItemContext::getRuleIndex() const {
  return MySQLParser::RuleSelectItem;
}

void MySQLParser::SelectItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSelectItem(this);
}

void MySQLParser::SelectItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSelectItem(this);
}


std::any MySQLParser::SelectItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSelectItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SelectItemContext* MySQLParser::selectItem() {
  SelectItemContext *_localctx = _tracker.createInstance<SelectItemContext>(_ctx, getState());
  enterRule(_localctx, 404, MySQLParser::RuleSelectItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3866);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 370, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3861);
      tableWild();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3862);
      expr(0);
      setState(3864);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _ctx)) {
      case 1: {
        setState(3863);
        selectAlias();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SelectAliasContext ------------------------------------------------------------------

MySQLParser::SelectAliasContext::SelectAliasContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::SelectAliasContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::SelectAliasContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::SelectAliasContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}


size_t MySQLParser::SelectAliasContext::getRuleIndex() const {
  return MySQLParser::RuleSelectAlias;
}

void MySQLParser::SelectAliasContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSelectAlias(this);
}

void MySQLParser::SelectAliasContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSelectAlias(this);
}


std::any MySQLParser::SelectAliasContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSelectAlias(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SelectAliasContext* MySQLParser::selectAlias() {
  SelectAliasContext *_localctx = _tracker.createInstance<SelectAliasContext>(_ctx, getState());
  enterRule(_localctx, 406, MySQLParser::RuleSelectAlias);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3869);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 371, _ctx)) {
    case 1: {
      setState(3868);
      match(MySQLParser::AS_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3873);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _ctx)) {
    case 1: {
      setState(3871);
      identifier();
      break;
    }

    case 2: {
      setState(3872);
      textStringLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WhereClauseContext ------------------------------------------------------------------

MySQLParser::WhereClauseContext::WhereClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WhereClauseContext::WHERE_SYMBOL() {
  return getToken(MySQLParser::WHERE_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::WhereClauseContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::WhereClauseContext::getRuleIndex() const {
  return MySQLParser::RuleWhereClause;
}

void MySQLParser::WhereClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWhereClause(this);
}

void MySQLParser::WhereClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWhereClause(this);
}


std::any MySQLParser::WhereClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWhereClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WhereClauseContext* MySQLParser::whereClause() {
  WhereClauseContext *_localctx = _tracker.createInstance<WhereClauseContext>(_ctx, getState());
  enterRule(_localctx, 408, MySQLParser::RuleWhereClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3875);
    match(MySQLParser::WHERE_SYMBOL);
    setState(3876);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableReferenceContext ------------------------------------------------------------------

MySQLParser::TableReferenceContext::TableReferenceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableFactorContext* MySQLParser::TableReferenceContext::tableFactor() {
  return getRuleContext<MySQLParser::TableFactorContext>(0);
}

tree::TerminalNode* MySQLParser::TableReferenceContext::OPEN_CURLY_SYMBOL() {
  return getToken(MySQLParser::OPEN_CURLY_SYMBOL, 0);
}

MySQLParser::EscapedTableReferenceContext* MySQLParser::TableReferenceContext::escapedTableReference() {
  return getRuleContext<MySQLParser::EscapedTableReferenceContext>(0);
}

tree::TerminalNode* MySQLParser::TableReferenceContext::CLOSE_CURLY_SYMBOL() {
  return getToken(MySQLParser::CLOSE_CURLY_SYMBOL, 0);
}

std::vector<MySQLParser::JoinedTableContext *> MySQLParser::TableReferenceContext::joinedTable() {
  return getRuleContexts<MySQLParser::JoinedTableContext>();
}

MySQLParser::JoinedTableContext* MySQLParser::TableReferenceContext::joinedTable(size_t i) {
  return getRuleContext<MySQLParser::JoinedTableContext>(i);
}

MySQLParser::IdentifierContext* MySQLParser::TableReferenceContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::TableReferenceContext::OJ_SYMBOL() {
  return getToken(MySQLParser::OJ_SYMBOL, 0);
}


size_t MySQLParser::TableReferenceContext::getRuleIndex() const {
  return MySQLParser::RuleTableReference;
}

void MySQLParser::TableReferenceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableReference(this);
}

void MySQLParser::TableReferenceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableReference(this);
}


std::any MySQLParser::TableReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableReference(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableReferenceContext* MySQLParser::tableReference() {
  TableReferenceContext *_localctx = _tracker.createInstance<TableReferenceContext>(_ctx, getState());
  enterRule(_localctx, 410, MySQLParser::RuleTableReference);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3888);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 374, _ctx)) {
    case 1: {
      setState(3878);
      tableFactor();
      break;
    }

    case 2: {
      setState(3879);
      match(MySQLParser::OPEN_CURLY_SYMBOL);
      setState(3883);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 373, _ctx)) {
      case 1: {
        setState(3880);

        if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
        setState(3881);
        identifier();
        break;
      }

      case 2: {
        setState(3882);
        match(MySQLParser::OJ_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(3885);
      escapedTableReference();
      setState(3886);
      match(MySQLParser::CLOSE_CURLY_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3893);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3890);
        joinedTable(); 
      }
      setState(3895);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EscapedTableReferenceContext ------------------------------------------------------------------

MySQLParser::EscapedTableReferenceContext::EscapedTableReferenceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableFactorContext* MySQLParser::EscapedTableReferenceContext::tableFactor() {
  return getRuleContext<MySQLParser::TableFactorContext>(0);
}

std::vector<MySQLParser::JoinedTableContext *> MySQLParser::EscapedTableReferenceContext::joinedTable() {
  return getRuleContexts<MySQLParser::JoinedTableContext>();
}

MySQLParser::JoinedTableContext* MySQLParser::EscapedTableReferenceContext::joinedTable(size_t i) {
  return getRuleContext<MySQLParser::JoinedTableContext>(i);
}


size_t MySQLParser::EscapedTableReferenceContext::getRuleIndex() const {
  return MySQLParser::RuleEscapedTableReference;
}

void MySQLParser::EscapedTableReferenceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEscapedTableReference(this);
}

void MySQLParser::EscapedTableReferenceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEscapedTableReference(this);
}


std::any MySQLParser::EscapedTableReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitEscapedTableReference(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::EscapedTableReferenceContext* MySQLParser::escapedTableReference() {
  EscapedTableReferenceContext *_localctx = _tracker.createInstance<EscapedTableReferenceContext>(_ctx, getState());
  enterRule(_localctx, 412, MySQLParser::RuleEscapedTableReference);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3896);
    tableFactor();
    setState(3900);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::CROSS_SYMBOL || ((((_la - 275) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 275)) & ((1ULL << (MySQLParser::INNER_SYMBOL - 275))
      | (1ULL << (MySQLParser::JOIN_SYMBOL - 275))
      | (1ULL << (MySQLParser::LEFT_SYMBOL - 275)))) != 0) || _la == MySQLParser::NATURAL_SYMBOL || _la == MySQLParser::RIGHT_SYMBOL || _la == MySQLParser::STRAIGHT_JOIN_SYMBOL) {
      setState(3897);
      joinedTable();
      setState(3902);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JoinedTableContext ------------------------------------------------------------------

MySQLParser::JoinedTableContext::JoinedTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::InnerJoinTypeContext* MySQLParser::JoinedTableContext::innerJoinType() {
  return getRuleContext<MySQLParser::InnerJoinTypeContext>(0);
}

MySQLParser::TableReferenceContext* MySQLParser::JoinedTableContext::tableReference() {
  return getRuleContext<MySQLParser::TableReferenceContext>(0);
}

tree::TerminalNode* MySQLParser::JoinedTableContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::JoinedTableContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::JoinedTableContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::IdentifierListWithParenthesesContext* MySQLParser::JoinedTableContext::identifierListWithParentheses() {
  return getRuleContext<MySQLParser::IdentifierListWithParenthesesContext>(0);
}

MySQLParser::OuterJoinTypeContext* MySQLParser::JoinedTableContext::outerJoinType() {
  return getRuleContext<MySQLParser::OuterJoinTypeContext>(0);
}

MySQLParser::NaturalJoinTypeContext* MySQLParser::JoinedTableContext::naturalJoinType() {
  return getRuleContext<MySQLParser::NaturalJoinTypeContext>(0);
}

MySQLParser::TableFactorContext* MySQLParser::JoinedTableContext::tableFactor() {
  return getRuleContext<MySQLParser::TableFactorContext>(0);
}


size_t MySQLParser::JoinedTableContext::getRuleIndex() const {
  return MySQLParser::RuleJoinedTable;
}

void MySQLParser::JoinedTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterJoinedTable(this);
}

void MySQLParser::JoinedTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitJoinedTable(this);
}


std::any MySQLParser::JoinedTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitJoinedTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::JoinedTableContext* MySQLParser::joinedTable() {
  JoinedTableContext *_localctx = _tracker.createInstance<JoinedTableContext>(_ctx, getState());
  enterRule(_localctx, 414, MySQLParser::RuleJoinedTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3922);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CROSS_SYMBOL:
      case MySQLParser::INNER_SYMBOL:
      case MySQLParser::JOIN_SYMBOL:
      case MySQLParser::STRAIGHT_JOIN_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3903);
        innerJoinType();
        setState(3904);
        tableReference();
        setState(3909);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 377, _ctx)) {
        case 1: {
          setState(3905);
          match(MySQLParser::ON_SYMBOL);
          setState(3906);
          expr(0);
          break;
        }

        case 2: {
          setState(3907);
          match(MySQLParser::USING_SYMBOL);
          setState(3908);
          identifierListWithParentheses();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::LEFT_SYMBOL:
      case MySQLParser::RIGHT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3911);
        outerJoinType();
        setState(3912);
        tableReference();
        setState(3917);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::ON_SYMBOL: {
            setState(3913);
            match(MySQLParser::ON_SYMBOL);
            setState(3914);
            expr(0);
            break;
          }

          case MySQLParser::USING_SYMBOL: {
            setState(3915);
            match(MySQLParser::USING_SYMBOL);
            setState(3916);
            identifierListWithParentheses();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        break;
      }

      case MySQLParser::NATURAL_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(3919);
        naturalJoinType();
        setState(3920);
        tableFactor();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NaturalJoinTypeContext ------------------------------------------------------------------

MySQLParser::NaturalJoinTypeContext::NaturalJoinTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NaturalJoinTypeContext::NATURAL_SYMBOL() {
  return getToken(MySQLParser::NATURAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NaturalJoinTypeContext::JOIN_SYMBOL() {
  return getToken(MySQLParser::JOIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NaturalJoinTypeContext::INNER_SYMBOL() {
  return getToken(MySQLParser::INNER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NaturalJoinTypeContext::LEFT_SYMBOL() {
  return getToken(MySQLParser::LEFT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NaturalJoinTypeContext::RIGHT_SYMBOL() {
  return getToken(MySQLParser::RIGHT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NaturalJoinTypeContext::OUTER_SYMBOL() {
  return getToken(MySQLParser::OUTER_SYMBOL, 0);
}


size_t MySQLParser::NaturalJoinTypeContext::getRuleIndex() const {
  return MySQLParser::RuleNaturalJoinType;
}

void MySQLParser::NaturalJoinTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNaturalJoinType(this);
}

void MySQLParser::NaturalJoinTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNaturalJoinType(this);
}


std::any MySQLParser::NaturalJoinTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNaturalJoinType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NaturalJoinTypeContext* MySQLParser::naturalJoinType() {
  NaturalJoinTypeContext *_localctx = _tracker.createInstance<NaturalJoinTypeContext>(_ctx, getState());
  enterRule(_localctx, 416, MySQLParser::RuleNaturalJoinType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3935);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 382, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3924);
      match(MySQLParser::NATURAL_SYMBOL);
      setState(3926);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::INNER_SYMBOL) {
        setState(3925);
        match(MySQLParser::INNER_SYMBOL);
      }
      setState(3928);
      match(MySQLParser::JOIN_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3929);
      match(MySQLParser::NATURAL_SYMBOL);
      setState(3930);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LEFT_SYMBOL || _la == MySQLParser::RIGHT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3932);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::OUTER_SYMBOL) {
        setState(3931);
        match(MySQLParser::OUTER_SYMBOL);
      }
      setState(3934);
      match(MySQLParser::JOIN_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InnerJoinTypeContext ------------------------------------------------------------------

MySQLParser::InnerJoinTypeContext::InnerJoinTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InnerJoinTypeContext::JOIN_SYMBOL() {
  return getToken(MySQLParser::JOIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InnerJoinTypeContext::INNER_SYMBOL() {
  return getToken(MySQLParser::INNER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InnerJoinTypeContext::CROSS_SYMBOL() {
  return getToken(MySQLParser::CROSS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InnerJoinTypeContext::STRAIGHT_JOIN_SYMBOL() {
  return getToken(MySQLParser::STRAIGHT_JOIN_SYMBOL, 0);
}


size_t MySQLParser::InnerJoinTypeContext::getRuleIndex() const {
  return MySQLParser::RuleInnerJoinType;
}

void MySQLParser::InnerJoinTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInnerJoinType(this);
}

void MySQLParser::InnerJoinTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInnerJoinType(this);
}


std::any MySQLParser::InnerJoinTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInnerJoinType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InnerJoinTypeContext* MySQLParser::innerJoinType() {
  InnerJoinTypeContext *_localctx = _tracker.createInstance<InnerJoinTypeContext>(_ctx, getState());
  enterRule(_localctx, 418, MySQLParser::RuleInnerJoinType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3942);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CROSS_SYMBOL:
      case MySQLParser::INNER_SYMBOL:
      case MySQLParser::JOIN_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3938);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::CROSS_SYMBOL || _la == MySQLParser::INNER_SYMBOL) {
          setState(3937);
          antlrcpp::downCast<InnerJoinTypeContext *>(_localctx)->type = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::CROSS_SYMBOL || _la == MySQLParser::INNER_SYMBOL)) {
            antlrcpp::downCast<InnerJoinTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        setState(3940);
        match(MySQLParser::JOIN_SYMBOL);
        break;
      }

      case MySQLParser::STRAIGHT_JOIN_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3941);
        antlrcpp::downCast<InnerJoinTypeContext *>(_localctx)->type = match(MySQLParser::STRAIGHT_JOIN_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OuterJoinTypeContext ------------------------------------------------------------------

MySQLParser::OuterJoinTypeContext::OuterJoinTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OuterJoinTypeContext::JOIN_SYMBOL() {
  return getToken(MySQLParser::JOIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OuterJoinTypeContext::LEFT_SYMBOL() {
  return getToken(MySQLParser::LEFT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OuterJoinTypeContext::RIGHT_SYMBOL() {
  return getToken(MySQLParser::RIGHT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OuterJoinTypeContext::OUTER_SYMBOL() {
  return getToken(MySQLParser::OUTER_SYMBOL, 0);
}


size_t MySQLParser::OuterJoinTypeContext::getRuleIndex() const {
  return MySQLParser::RuleOuterJoinType;
}

void MySQLParser::OuterJoinTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOuterJoinType(this);
}

void MySQLParser::OuterJoinTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOuterJoinType(this);
}


std::any MySQLParser::OuterJoinTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOuterJoinType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OuterJoinTypeContext* MySQLParser::outerJoinType() {
  OuterJoinTypeContext *_localctx = _tracker.createInstance<OuterJoinTypeContext>(_ctx, getState());
  enterRule(_localctx, 420, MySQLParser::RuleOuterJoinType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3944);
    antlrcpp::downCast<OuterJoinTypeContext *>(_localctx)->type = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::LEFT_SYMBOL || _la == MySQLParser::RIGHT_SYMBOL)) {
      antlrcpp::downCast<OuterJoinTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(3946);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OUTER_SYMBOL) {
      setState(3945);
      match(MySQLParser::OUTER_SYMBOL);
    }
    setState(3948);
    match(MySQLParser::JOIN_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableFactorContext ------------------------------------------------------------------

MySQLParser::TableFactorContext::TableFactorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SingleTableContext* MySQLParser::TableFactorContext::singleTable() {
  return getRuleContext<MySQLParser::SingleTableContext>(0);
}

MySQLParser::SingleTableParensContext* MySQLParser::TableFactorContext::singleTableParens() {
  return getRuleContext<MySQLParser::SingleTableParensContext>(0);
}

MySQLParser::DerivedTableContext* MySQLParser::TableFactorContext::derivedTable() {
  return getRuleContext<MySQLParser::DerivedTableContext>(0);
}

MySQLParser::TableReferenceListParensContext* MySQLParser::TableFactorContext::tableReferenceListParens() {
  return getRuleContext<MySQLParser::TableReferenceListParensContext>(0);
}

MySQLParser::TableFunctionContext* MySQLParser::TableFactorContext::tableFunction() {
  return getRuleContext<MySQLParser::TableFunctionContext>(0);
}


size_t MySQLParser::TableFactorContext::getRuleIndex() const {
  return MySQLParser::RuleTableFactor;
}

void MySQLParser::TableFactorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableFactor(this);
}

void MySQLParser::TableFactorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableFactor(this);
}


std::any MySQLParser::TableFactorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableFactor(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableFactorContext* MySQLParser::tableFactor() {
  TableFactorContext *_localctx = _tracker.createInstance<TableFactorContext>(_ctx, getState());
  enterRule(_localctx, 422, MySQLParser::RuleTableFactor);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3956);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 386, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3950);
      singleTable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3951);
      singleTableParens();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3952);
      derivedTable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3953);
      tableReferenceListParens();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3954);

      if (!(serverVersion >= 80004)) throw FailedPredicateException(this, "serverVersion >= 80004");
      setState(3955);
      tableFunction();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SingleTableContext ------------------------------------------------------------------

MySQLParser::SingleTableContext::SingleTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::SingleTableContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::UsePartitionContext* MySQLParser::SingleTableContext::usePartition() {
  return getRuleContext<MySQLParser::UsePartitionContext>(0);
}

MySQLParser::TableAliasContext* MySQLParser::SingleTableContext::tableAlias() {
  return getRuleContext<MySQLParser::TableAliasContext>(0);
}

MySQLParser::IndexHintListContext* MySQLParser::SingleTableContext::indexHintList() {
  return getRuleContext<MySQLParser::IndexHintListContext>(0);
}

MySQLParser::TablesampleClauseContext* MySQLParser::SingleTableContext::tablesampleClause() {
  return getRuleContext<MySQLParser::TablesampleClauseContext>(0);
}


size_t MySQLParser::SingleTableContext::getRuleIndex() const {
  return MySQLParser::RuleSingleTable;
}

void MySQLParser::SingleTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSingleTable(this);
}

void MySQLParser::SingleTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSingleTable(this);
}


std::any MySQLParser::SingleTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSingleTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SingleTableContext* MySQLParser::singleTable() {
  SingleTableContext *_localctx = _tracker.createInstance<SingleTableContext>(_ctx, getState());
  enterRule(_localctx, 424, MySQLParser::RuleSingleTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3958);
    tableRef();
    setState(3960);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 387, _ctx)) {
    case 1: {
      setState(3959);
      usePartition();
      break;
    }

    default:
      break;
    }
    setState(3963);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 388, _ctx)) {
    case 1: {
      setState(3962);
      tableAlias();
      break;
    }

    default:
      break;
    }
    setState(3966);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 389, _ctx)) {
    case 1: {
      setState(3965);
      indexHintList();
      break;
    }

    default:
      break;
    }
    setState(3969);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 390, _ctx)) {
    case 1: {
      setState(3968);
      tablesampleClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SingleTableParensContext ------------------------------------------------------------------

MySQLParser::SingleTableParensContext::SingleTableParensContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SingleTableParensContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SingleTableParensContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::SingleTableContext* MySQLParser::SingleTableParensContext::singleTable() {
  return getRuleContext<MySQLParser::SingleTableContext>(0);
}

MySQLParser::SingleTableParensContext* MySQLParser::SingleTableParensContext::singleTableParens() {
  return getRuleContext<MySQLParser::SingleTableParensContext>(0);
}


size_t MySQLParser::SingleTableParensContext::getRuleIndex() const {
  return MySQLParser::RuleSingleTableParens;
}

void MySQLParser::SingleTableParensContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSingleTableParens(this);
}

void MySQLParser::SingleTableParensContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSingleTableParens(this);
}


std::any MySQLParser::SingleTableParensContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSingleTableParens(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SingleTableParensContext* MySQLParser::singleTableParens() {
  SingleTableParensContext *_localctx = _tracker.createInstance<SingleTableParensContext>(_ctx, getState());
  enterRule(_localctx, 426, MySQLParser::RuleSingleTableParens);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3971);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3974);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 391, _ctx)) {
    case 1: {
      setState(3972);
      singleTable();
      break;
    }

    case 2: {
      setState(3973);
      singleTableParens();
      break;
    }

    default:
      break;
    }
    setState(3976);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DerivedTableContext ------------------------------------------------------------------

MySQLParser::DerivedTableContext::DerivedTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SubqueryContext* MySQLParser::DerivedTableContext::subquery() {
  return getRuleContext<MySQLParser::SubqueryContext>(0);
}

MySQLParser::TableAliasContext* MySQLParser::DerivedTableContext::tableAlias() {
  return getRuleContext<MySQLParser::TableAliasContext>(0);
}

MySQLParser::ColumnInternalRefListContext* MySQLParser::DerivedTableContext::columnInternalRefList() {
  return getRuleContext<MySQLParser::ColumnInternalRefListContext>(0);
}

tree::TerminalNode* MySQLParser::DerivedTableContext::LATERAL_SYMBOL() {
  return getToken(MySQLParser::LATERAL_SYMBOL, 0);
}


size_t MySQLParser::DerivedTableContext::getRuleIndex() const {
  return MySQLParser::RuleDerivedTable;
}

void MySQLParser::DerivedTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDerivedTable(this);
}

void MySQLParser::DerivedTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDerivedTable(this);
}


std::any MySQLParser::DerivedTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDerivedTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DerivedTableContext* MySQLParser::derivedTable() {
  DerivedTableContext *_localctx = _tracker.createInstance<DerivedTableContext>(_ctx, getState());
  enterRule(_localctx, 428, MySQLParser::RuleDerivedTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3995);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 396, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3978);
      subquery();
      setState(3980);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 392, _ctx)) {
      case 1: {
        setState(3979);
        tableAlias();
        break;
      }

      default:
        break;
      }
      setState(3984);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 393, _ctx)) {
      case 1: {
        setState(3982);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(3983);
        columnInternalRefList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3986);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(3987);
      match(MySQLParser::LATERAL_SYMBOL);
      setState(3988);
      subquery();
      setState(3990);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 394, _ctx)) {
      case 1: {
        setState(3989);
        tableAlias();
        break;
      }

      default:
        break;
      }
      setState(3993);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 395, _ctx)) {
      case 1: {
        setState(3992);
        columnInternalRefList();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableReferenceListParensContext ------------------------------------------------------------------

MySQLParser::TableReferenceListParensContext::TableReferenceListParensContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TableReferenceListParensContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableReferenceListParensContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::TableReferenceListContext* MySQLParser::TableReferenceListParensContext::tableReferenceList() {
  return getRuleContext<MySQLParser::TableReferenceListContext>(0);
}

MySQLParser::TableReferenceListParensContext* MySQLParser::TableReferenceListParensContext::tableReferenceListParens() {
  return getRuleContext<MySQLParser::TableReferenceListParensContext>(0);
}


size_t MySQLParser::TableReferenceListParensContext::getRuleIndex() const {
  return MySQLParser::RuleTableReferenceListParens;
}

void MySQLParser::TableReferenceListParensContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableReferenceListParens(this);
}

void MySQLParser::TableReferenceListParensContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableReferenceListParens(this);
}


std::any MySQLParser::TableReferenceListParensContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableReferenceListParens(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableReferenceListParensContext* MySQLParser::tableReferenceListParens() {
  TableReferenceListParensContext *_localctx = _tracker.createInstance<TableReferenceListParensContext>(_ctx, getState());
  enterRule(_localctx, 430, MySQLParser::RuleTableReferenceListParens);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3997);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(4000);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 397, _ctx)) {
    case 1: {
      setState(3998);
      tableReferenceList();
      break;
    }

    case 2: {
      setState(3999);
      tableReferenceListParens();
      break;
    }

    default:
      break;
    }
    setState(4002);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableFunctionContext ------------------------------------------------------------------

MySQLParser::TableFunctionContext::TableFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TableFunctionContext::JSON_TABLE_SYMBOL() {
  return getToken(MySQLParser::JSON_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableFunctionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::TableFunctionContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::TableFunctionContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::TableFunctionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

MySQLParser::ColumnsClauseContext* MySQLParser::TableFunctionContext::columnsClause() {
  return getRuleContext<MySQLParser::ColumnsClauseContext>(0);
}

tree::TerminalNode* MySQLParser::TableFunctionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::TableAliasContext* MySQLParser::TableFunctionContext::tableAlias() {
  return getRuleContext<MySQLParser::TableAliasContext>(0);
}


size_t MySQLParser::TableFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleTableFunction;
}

void MySQLParser::TableFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableFunction(this);
}

void MySQLParser::TableFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableFunction(this);
}


std::any MySQLParser::TableFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableFunctionContext* MySQLParser::tableFunction() {
  TableFunctionContext *_localctx = _tracker.createInstance<TableFunctionContext>(_ctx, getState());
  enterRule(_localctx, 432, MySQLParser::RuleTableFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4004);
    match(MySQLParser::JSON_TABLE_SYMBOL);
    setState(4005);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(4006);
    expr(0);
    setState(4007);
    match(MySQLParser::COMMA_SYMBOL);
    setState(4008);
    textStringLiteral();
    setState(4009);
    columnsClause();
    setState(4010);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(4012);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 398, _ctx)) {
    case 1: {
      setState(4011);
      tableAlias();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnsClauseContext ------------------------------------------------------------------

MySQLParser::ColumnsClauseContext::ColumnsClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ColumnsClauseContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnsClauseContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::JtColumnContext *> MySQLParser::ColumnsClauseContext::jtColumn() {
  return getRuleContexts<MySQLParser::JtColumnContext>();
}

MySQLParser::JtColumnContext* MySQLParser::ColumnsClauseContext::jtColumn(size_t i) {
  return getRuleContext<MySQLParser::JtColumnContext>(i);
}

tree::TerminalNode* MySQLParser::ColumnsClauseContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ColumnsClauseContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ColumnsClauseContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ColumnsClauseContext::getRuleIndex() const {
  return MySQLParser::RuleColumnsClause;
}

void MySQLParser::ColumnsClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnsClause(this);
}

void MySQLParser::ColumnsClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnsClause(this);
}


std::any MySQLParser::ColumnsClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnsClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnsClauseContext* MySQLParser::columnsClause() {
  ColumnsClauseContext *_localctx = _tracker.createInstance<ColumnsClauseContext>(_ctx, getState());
  enterRule(_localctx, 434, MySQLParser::RuleColumnsClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4014);
    match(MySQLParser::COLUMNS_SYMBOL);
    setState(4015);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(4016);
    jtColumn();
    setState(4021);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4017);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4018);
      jtColumn();
      setState(4023);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(4024);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JtColumnContext ------------------------------------------------------------------

MySQLParser::JtColumnContext::JtColumnContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::JtColumnContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::JtColumnContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::JtColumnContext::ORDINALITY_SYMBOL() {
  return getToken(MySQLParser::ORDINALITY_SYMBOL, 0);
}

MySQLParser::DataTypeContext* MySQLParser::JtColumnContext::dataType() {
  return getRuleContext<MySQLParser::DataTypeContext>(0);
}

tree::TerminalNode* MySQLParser::JtColumnContext::PATH_SYMBOL() {
  return getToken(MySQLParser::PATH_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::JtColumnContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

MySQLParser::CollateContext* MySQLParser::JtColumnContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}

tree::TerminalNode* MySQLParser::JtColumnContext::EXISTS_SYMBOL() {
  return getToken(MySQLParser::EXISTS_SYMBOL, 0);
}

MySQLParser::OnEmptyOrErrorJsonTableContext* MySQLParser::JtColumnContext::onEmptyOrErrorJsonTable() {
  return getRuleContext<MySQLParser::OnEmptyOrErrorJsonTableContext>(0);
}

tree::TerminalNode* MySQLParser::JtColumnContext::NESTED_SYMBOL() {
  return getToken(MySQLParser::NESTED_SYMBOL, 0);
}

MySQLParser::ColumnsClauseContext* MySQLParser::JtColumnContext::columnsClause() {
  return getRuleContext<MySQLParser::ColumnsClauseContext>(0);
}


size_t MySQLParser::JtColumnContext::getRuleIndex() const {
  return MySQLParser::RuleJtColumn;
}

void MySQLParser::JtColumnContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterJtColumn(this);
}

void MySQLParser::JtColumnContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitJtColumn(this);
}


std::any MySQLParser::JtColumnContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitJtColumn(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::JtColumnContext* MySQLParser::jtColumn() {
  JtColumnContext *_localctx = _tracker.createInstance<JtColumnContext>(_ctx, getState());
  enterRule(_localctx, 436, MySQLParser::RuleJtColumn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4049);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 403, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4026);
      identifier();
      setState(4027);
      match(MySQLParser::FOR_SYMBOL);
      setState(4028);
      match(MySQLParser::ORDINALITY_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4030);
      identifier();
      setState(4031);
      dataType();
      setState(4034);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx)) {
      case 1: {
        setState(4032);

        if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
        setState(4033);
        collate();
        break;
      }

      default:
        break;
      }
      setState(4037);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXISTS_SYMBOL) {
        setState(4036);
        match(MySQLParser::EXISTS_SYMBOL);
      }
      setState(4039);
      match(MySQLParser::PATH_SYMBOL);
      setState(4040);
      textStringLiteral();
      setState(4042);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DEFAULT_SYMBOL

      || _la == MySQLParser::ERROR_SYMBOL || _la == MySQLParser::NULL_SYMBOL) {
        setState(4041);
        onEmptyOrErrorJsonTable();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4044);
      match(MySQLParser::NESTED_SYMBOL);
      setState(4045);
      match(MySQLParser::PATH_SYMBOL);
      setState(4046);
      textStringLiteral();
      setState(4047);
      columnsClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OnEmptyOrErrorContext ------------------------------------------------------------------

MySQLParser::OnEmptyOrErrorContext::OnEmptyOrErrorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OnEmptyContext* MySQLParser::OnEmptyOrErrorContext::onEmpty() {
  return getRuleContext<MySQLParser::OnEmptyContext>(0);
}

MySQLParser::OnErrorContext* MySQLParser::OnEmptyOrErrorContext::onError() {
  return getRuleContext<MySQLParser::OnErrorContext>(0);
}


size_t MySQLParser::OnEmptyOrErrorContext::getRuleIndex() const {
  return MySQLParser::RuleOnEmptyOrError;
}

void MySQLParser::OnEmptyOrErrorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOnEmptyOrError(this);
}

void MySQLParser::OnEmptyOrErrorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOnEmptyOrError(this);
}


std::any MySQLParser::OnEmptyOrErrorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOnEmptyOrError(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OnEmptyOrErrorContext* MySQLParser::onEmptyOrError() {
  OnEmptyOrErrorContext *_localctx = _tracker.createInstance<OnEmptyOrErrorContext>(_ctx, getState());
  enterRule(_localctx, 438, MySQLParser::RuleOnEmptyOrError);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4056);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 405, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4051);
      onEmpty();
      setState(4053);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DEFAULT_SYMBOL

      || _la == MySQLParser::ERROR_SYMBOL || _la == MySQLParser::NULL_SYMBOL) {
        setState(4052);
        onError();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4055);
      onError();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OnEmptyOrErrorJsonTableContext ------------------------------------------------------------------

MySQLParser::OnEmptyOrErrorJsonTableContext::OnEmptyOrErrorJsonTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OnEmptyOrErrorContext* MySQLParser::OnEmptyOrErrorJsonTableContext::onEmptyOrError() {
  return getRuleContext<MySQLParser::OnEmptyOrErrorContext>(0);
}

MySQLParser::OnErrorContext* MySQLParser::OnEmptyOrErrorJsonTableContext::onError() {
  return getRuleContext<MySQLParser::OnErrorContext>(0);
}

MySQLParser::OnEmptyContext* MySQLParser::OnEmptyOrErrorJsonTableContext::onEmpty() {
  return getRuleContext<MySQLParser::OnEmptyContext>(0);
}


size_t MySQLParser::OnEmptyOrErrorJsonTableContext::getRuleIndex() const {
  return MySQLParser::RuleOnEmptyOrErrorJsonTable;
}

void MySQLParser::OnEmptyOrErrorJsonTableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOnEmptyOrErrorJsonTable(this);
}

void MySQLParser::OnEmptyOrErrorJsonTableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOnEmptyOrErrorJsonTable(this);
}


std::any MySQLParser::OnEmptyOrErrorJsonTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOnEmptyOrErrorJsonTable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OnEmptyOrErrorJsonTableContext* MySQLParser::onEmptyOrErrorJsonTable() {
  OnEmptyOrErrorJsonTableContext *_localctx = _tracker.createInstance<OnEmptyOrErrorJsonTableContext>(_ctx, getState());
  enterRule(_localctx, 440, MySQLParser::RuleOnEmptyOrErrorJsonTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4062);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4058);
      onEmptyOrError();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4059);
      onError();
      setState(4060);
      onEmpty();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OnEmptyContext ------------------------------------------------------------------

MySQLParser::OnEmptyContext::OnEmptyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::JsonOnResponseContext* MySQLParser::OnEmptyContext::jsonOnResponse() {
  return getRuleContext<MySQLParser::JsonOnResponseContext>(0);
}

tree::TerminalNode* MySQLParser::OnEmptyContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OnEmptyContext::EMPTY_SYMBOL() {
  return getToken(MySQLParser::EMPTY_SYMBOL, 0);
}


size_t MySQLParser::OnEmptyContext::getRuleIndex() const {
  return MySQLParser::RuleOnEmpty;
}

void MySQLParser::OnEmptyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOnEmpty(this);
}

void MySQLParser::OnEmptyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOnEmpty(this);
}


std::any MySQLParser::OnEmptyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOnEmpty(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OnEmptyContext* MySQLParser::onEmpty() {
  OnEmptyContext *_localctx = _tracker.createInstance<OnEmptyContext>(_ctx, getState());
  enterRule(_localctx, 442, MySQLParser::RuleOnEmpty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4064);
    jsonOnResponse();
    setState(4065);
    match(MySQLParser::ON_SYMBOL);
    setState(4066);
    match(MySQLParser::EMPTY_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OnErrorContext ------------------------------------------------------------------

MySQLParser::OnErrorContext::OnErrorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::JsonOnResponseContext* MySQLParser::OnErrorContext::jsonOnResponse() {
  return getRuleContext<MySQLParser::JsonOnResponseContext>(0);
}

tree::TerminalNode* MySQLParser::OnErrorContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OnErrorContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}


size_t MySQLParser::OnErrorContext::getRuleIndex() const {
  return MySQLParser::RuleOnError;
}

void MySQLParser::OnErrorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOnError(this);
}

void MySQLParser::OnErrorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOnError(this);
}


std::any MySQLParser::OnErrorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOnError(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OnErrorContext* MySQLParser::onError() {
  OnErrorContext *_localctx = _tracker.createInstance<OnErrorContext>(_ctx, getState());
  enterRule(_localctx, 444, MySQLParser::RuleOnError);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4068);
    jsonOnResponse();
    setState(4069);
    match(MySQLParser::ON_SYMBOL);
    setState(4070);
    match(MySQLParser::ERROR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JsonOnResponseContext ------------------------------------------------------------------

MySQLParser::JsonOnResponseContext::JsonOnResponseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::JsonOnResponseContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::JsonOnResponseContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::JsonOnResponseContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::JsonOnResponseContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::JsonOnResponseContext::getRuleIndex() const {
  return MySQLParser::RuleJsonOnResponse;
}

void MySQLParser::JsonOnResponseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterJsonOnResponse(this);
}

void MySQLParser::JsonOnResponseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitJsonOnResponse(this);
}


std::any MySQLParser::JsonOnResponseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitJsonOnResponse(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::JsonOnResponseContext* MySQLParser::jsonOnResponse() {
  JsonOnResponseContext *_localctx = _tracker.createInstance<JsonOnResponseContext>(_ctx, getState());
  enterRule(_localctx, 446, MySQLParser::RuleJsonOnResponse);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4076);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ERROR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4072);
        match(MySQLParser::ERROR_SYMBOL);
        break;
      }

      case MySQLParser::NULL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4073);
        match(MySQLParser::NULL_SYMBOL);
        break;
      }

      case MySQLParser::DEFAULT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4074);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(4075);
        textStringLiteral();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnionOptionContext ------------------------------------------------------------------

MySQLParser::UnionOptionContext::UnionOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UnionOptionContext::DISTINCT_SYMBOL() {
  return getToken(MySQLParser::DISTINCT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UnionOptionContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}


size_t MySQLParser::UnionOptionContext::getRuleIndex() const {
  return MySQLParser::RuleUnionOption;
}

void MySQLParser::UnionOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUnionOption(this);
}

void MySQLParser::UnionOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUnionOption(this);
}


std::any MySQLParser::UnionOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUnionOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UnionOptionContext* MySQLParser::unionOption() {
  UnionOptionContext *_localctx = _tracker.createInstance<UnionOptionContext>(_ctx, getState());
  enterRule(_localctx, 448, MySQLParser::RuleUnionOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4078);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ALL_SYMBOL || _la == MySQLParser::DISTINCT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableAliasContext ------------------------------------------------------------------

MySQLParser::TableAliasContext::TableAliasContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::TableAliasContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::TableAliasContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableAliasContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::TableAliasContext::getRuleIndex() const {
  return MySQLParser::RuleTableAlias;
}

void MySQLParser::TableAliasContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableAlias(this);
}

void MySQLParser::TableAliasContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableAlias(this);
}


std::any MySQLParser::TableAliasContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableAlias(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableAliasContext* MySQLParser::tableAlias() {
  TableAliasContext *_localctx = _tracker.createInstance<TableAliasContext>(_ctx, getState());
  enterRule(_localctx, 450, MySQLParser::RuleTableAlias);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4083);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 408, _ctx)) {
    case 1: {
      setState(4080);
      match(MySQLParser::AS_SYMBOL);
      break;
    }

    case 2: {
      setState(4081);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(4082);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(4085);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexHintListContext ------------------------------------------------------------------

MySQLParser::IndexHintListContext::IndexHintListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::IndexHintContext *> MySQLParser::IndexHintListContext::indexHint() {
  return getRuleContexts<MySQLParser::IndexHintContext>();
}

MySQLParser::IndexHintContext* MySQLParser::IndexHintListContext::indexHint(size_t i) {
  return getRuleContext<MySQLParser::IndexHintContext>(i);
}


size_t MySQLParser::IndexHintListContext::getRuleIndex() const {
  return MySQLParser::RuleIndexHintList;
}

void MySQLParser::IndexHintListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexHintList(this);
}

void MySQLParser::IndexHintListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexHintList(this);
}


std::any MySQLParser::IndexHintListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexHintList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexHintListContext* MySQLParser::indexHintList() {
  IndexHintListContext *_localctx = _tracker.createInstance<IndexHintListContext>(_ctx, getState());
  enterRule(_localctx, 452, MySQLParser::RuleIndexHintList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4087);
    indexHint();
    setState(4091);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4088);
        indexHint(); 
      }
      setState(4093);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexHintContext ------------------------------------------------------------------

MySQLParser::IndexHintContext::IndexHintContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IndexHintTypeContext* MySQLParser::IndexHintContext::indexHintType() {
  return getRuleContext<MySQLParser::IndexHintTypeContext>(0);
}

MySQLParser::KeyOrIndexContext* MySQLParser::IndexHintContext::keyOrIndex() {
  return getRuleContext<MySQLParser::KeyOrIndexContext>(0);
}

tree::TerminalNode* MySQLParser::IndexHintContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::IndexListContext* MySQLParser::IndexHintContext::indexList() {
  return getRuleContext<MySQLParser::IndexListContext>(0);
}

tree::TerminalNode* MySQLParser::IndexHintContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::IndexHintClauseContext* MySQLParser::IndexHintContext::indexHintClause() {
  return getRuleContext<MySQLParser::IndexHintClauseContext>(0);
}

tree::TerminalNode* MySQLParser::IndexHintContext::USE_SYMBOL() {
  return getToken(MySQLParser::USE_SYMBOL, 0);
}


size_t MySQLParser::IndexHintContext::getRuleIndex() const {
  return MySQLParser::RuleIndexHint;
}

void MySQLParser::IndexHintContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexHint(this);
}

void MySQLParser::IndexHintContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexHint(this);
}


std::any MySQLParser::IndexHintContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexHint(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexHintContext* MySQLParser::indexHint() {
  IndexHintContext *_localctx = _tracker.createInstance<IndexHintContext>(_ctx, getState());
  enterRule(_localctx, 454, MySQLParser::RuleIndexHint);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4114);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FORCE_SYMBOL:
      case MySQLParser::IGNORE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4094);
        indexHintType();
        setState(4095);
        keyOrIndex();
        setState(4097);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FOR_SYMBOL) {
          setState(4096);
          indexHintClause();
        }
        setState(4099);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4100);
        indexList();
        setState(4101);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::USE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4103);
        match(MySQLParser::USE_SYMBOL);
        setState(4104);
        keyOrIndex();
        setState(4106);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FOR_SYMBOL) {
          setState(4105);
          indexHintClause();
        }
        setState(4108);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4110);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 412, _ctx)) {
        case 1: {
          setState(4109);
          indexList();
          break;
        }

        default:
          break;
        }
        setState(4112);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexHintTypeContext ------------------------------------------------------------------

MySQLParser::IndexHintTypeContext::IndexHintTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IndexHintTypeContext::FORCE_SYMBOL() {
  return getToken(MySQLParser::FORCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexHintTypeContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}


size_t MySQLParser::IndexHintTypeContext::getRuleIndex() const {
  return MySQLParser::RuleIndexHintType;
}

void MySQLParser::IndexHintTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexHintType(this);
}

void MySQLParser::IndexHintTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexHintType(this);
}


std::any MySQLParser::IndexHintTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexHintType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexHintTypeContext* MySQLParser::indexHintType() {
  IndexHintTypeContext *_localctx = _tracker.createInstance<IndexHintTypeContext>(_ctx, getState());
  enterRule(_localctx, 456, MySQLParser::RuleIndexHintType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4116);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::FORCE_SYMBOL

    || _la == MySQLParser::IGNORE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyOrIndexContext ------------------------------------------------------------------

MySQLParser::KeyOrIndexContext::KeyOrIndexContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::KeyOrIndexContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::KeyOrIndexContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}


size_t MySQLParser::KeyOrIndexContext::getRuleIndex() const {
  return MySQLParser::RuleKeyOrIndex;
}

void MySQLParser::KeyOrIndexContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyOrIndex(this);
}

void MySQLParser::KeyOrIndexContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyOrIndex(this);
}


std::any MySQLParser::KeyOrIndexContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyOrIndex(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyOrIndexContext* MySQLParser::keyOrIndex() {
  KeyOrIndexContext *_localctx = _tracker.createInstance<KeyOrIndexContext>(_ctx, getState());
  enterRule(_localctx, 458, MySQLParser::RuleKeyOrIndex);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4118);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::INDEX_SYMBOL

    || _la == MySQLParser::KEY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConstraintKeyTypeContext ------------------------------------------------------------------

MySQLParser::ConstraintKeyTypeContext::ConstraintKeyTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ConstraintKeyTypeContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ConstraintKeyTypeContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ConstraintKeyTypeContext::UNIQUE_SYMBOL() {
  return getToken(MySQLParser::UNIQUE_SYMBOL, 0);
}

MySQLParser::KeyOrIndexContext* MySQLParser::ConstraintKeyTypeContext::keyOrIndex() {
  return getRuleContext<MySQLParser::KeyOrIndexContext>(0);
}


size_t MySQLParser::ConstraintKeyTypeContext::getRuleIndex() const {
  return MySQLParser::RuleConstraintKeyType;
}

void MySQLParser::ConstraintKeyTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConstraintKeyType(this);
}

void MySQLParser::ConstraintKeyTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConstraintKeyType(this);
}


std::any MySQLParser::ConstraintKeyTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitConstraintKeyType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ConstraintKeyTypeContext* MySQLParser::constraintKeyType() {
  ConstraintKeyTypeContext *_localctx = _tracker.createInstance<ConstraintKeyTypeContext>(_ctx, getState());
  enterRule(_localctx, 460, MySQLParser::RuleConstraintKeyType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4126);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PRIMARY_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4120);
        match(MySQLParser::PRIMARY_SYMBOL);
        setState(4121);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      case MySQLParser::UNIQUE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4122);
        match(MySQLParser::UNIQUE_SYMBOL);
        setState(4124);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::INDEX_SYMBOL

        || _la == MySQLParser::KEY_SYMBOL) {
          setState(4123);
          keyOrIndex();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexHintClauseContext ------------------------------------------------------------------

MySQLParser::IndexHintClauseContext::IndexHintClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IndexHintClauseContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexHintClauseContext::JOIN_SYMBOL() {
  return getToken(MySQLParser::JOIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexHintClauseContext::ORDER_SYMBOL() {
  return getToken(MySQLParser::ORDER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexHintClauseContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexHintClauseContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}


size_t MySQLParser::IndexHintClauseContext::getRuleIndex() const {
  return MySQLParser::RuleIndexHintClause;
}

void MySQLParser::IndexHintClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexHintClause(this);
}

void MySQLParser::IndexHintClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexHintClause(this);
}


std::any MySQLParser::IndexHintClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexHintClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexHintClauseContext* MySQLParser::indexHintClause() {
  IndexHintClauseContext *_localctx = _tracker.createInstance<IndexHintClauseContext>(_ctx, getState());
  enterRule(_localctx, 462, MySQLParser::RuleIndexHintClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4128);
    match(MySQLParser::FOR_SYMBOL);
    setState(4134);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::JOIN_SYMBOL: {
        setState(4129);
        match(MySQLParser::JOIN_SYMBOL);
        break;
      }

      case MySQLParser::ORDER_SYMBOL: {
        setState(4130);
        match(MySQLParser::ORDER_SYMBOL);
        setState(4131);
        match(MySQLParser::BY_SYMBOL);
        break;
      }

      case MySQLParser::GROUP_SYMBOL: {
        setState(4132);
        match(MySQLParser::GROUP_SYMBOL);
        setState(4133);
        match(MySQLParser::BY_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexListContext ------------------------------------------------------------------

MySQLParser::IndexListContext::IndexListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::IndexListElementContext *> MySQLParser::IndexListContext::indexListElement() {
  return getRuleContexts<MySQLParser::IndexListElementContext>();
}

MySQLParser::IndexListElementContext* MySQLParser::IndexListContext::indexListElement(size_t i) {
  return getRuleContext<MySQLParser::IndexListElementContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::IndexListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::IndexListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::IndexListContext::getRuleIndex() const {
  return MySQLParser::RuleIndexList;
}

void MySQLParser::IndexListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexList(this);
}

void MySQLParser::IndexListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexList(this);
}


std::any MySQLParser::IndexListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexListContext* MySQLParser::indexList() {
  IndexListContext *_localctx = _tracker.createInstance<IndexListContext>(_ctx, getState());
  enterRule(_localctx, 464, MySQLParser::RuleIndexList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4136);
    indexListElement();
    setState(4141);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4137);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4138);
      indexListElement();
      setState(4143);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexListElementContext ------------------------------------------------------------------

MySQLParser::IndexListElementContext::IndexListElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::IndexListElementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::IndexListElementContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}


size_t MySQLParser::IndexListElementContext::getRuleIndex() const {
  return MySQLParser::RuleIndexListElement;
}

void MySQLParser::IndexListElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexListElement(this);
}

void MySQLParser::IndexListElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexListElement(this);
}


std::any MySQLParser::IndexListElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexListElement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexListElementContext* MySQLParser::indexListElement() {
  IndexListElementContext *_localctx = _tracker.createInstance<IndexListElementContext>(_ctx, getState());
  enterRule(_localctx, 466, MySQLParser::RuleIndexListElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4146);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 418, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4144);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4145);
      match(MySQLParser::PRIMARY_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UpdateStatementContext ------------------------------------------------------------------

MySQLParser::UpdateStatementContext::UpdateStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UpdateStatementContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

MySQLParser::TableReferenceListContext* MySQLParser::UpdateStatementContext::tableReferenceList() {
  return getRuleContext<MySQLParser::TableReferenceListContext>(0);
}

tree::TerminalNode* MySQLParser::UpdateStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

MySQLParser::UpdateListContext* MySQLParser::UpdateStatementContext::updateList() {
  return getRuleContext<MySQLParser::UpdateListContext>(0);
}

MySQLParser::WithClauseContext* MySQLParser::UpdateStatementContext::withClause() {
  return getRuleContext<MySQLParser::WithClauseContext>(0);
}

tree::TerminalNode* MySQLParser::UpdateStatementContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UpdateStatementContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}

MySQLParser::WhereClauseContext* MySQLParser::UpdateStatementContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}

MySQLParser::OrderClauseContext* MySQLParser::UpdateStatementContext::orderClause() {
  return getRuleContext<MySQLParser::OrderClauseContext>(0);
}

MySQLParser::SimpleLimitClauseContext* MySQLParser::UpdateStatementContext::simpleLimitClause() {
  return getRuleContext<MySQLParser::SimpleLimitClauseContext>(0);
}


size_t MySQLParser::UpdateStatementContext::getRuleIndex() const {
  return MySQLParser::RuleUpdateStatement;
}

void MySQLParser::UpdateStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUpdateStatement(this);
}

void MySQLParser::UpdateStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUpdateStatement(this);
}


std::any MySQLParser::UpdateStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUpdateStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UpdateStatementContext* MySQLParser::updateStatement() {
  UpdateStatementContext *_localctx = _tracker.createInstance<UpdateStatementContext>(_ctx, getState());
  enterRule(_localctx, 468, MySQLParser::RuleUpdateStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4150);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 419, _ctx)) {
    case 1: {
      setState(4148);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4149);
      withClause();
      break;
    }

    default:
      break;
    }
    setState(4152);
    match(MySQLParser::UPDATE_SYMBOL);
    setState(4154);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 420, _ctx)) {
    case 1: {
      setState(4153);
      match(MySQLParser::LOW_PRIORITY_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(4157);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 421, _ctx)) {
    case 1: {
      setState(4156);
      match(MySQLParser::IGNORE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(4159);
    tableReferenceList();
    setState(4160);
    match(MySQLParser::SET_SYMBOL);
    setState(4161);
    updateList();
    setState(4163);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::WHERE_SYMBOL) {
      setState(4162);
      whereClause();
    }
    setState(4166);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ORDER_SYMBOL) {
      setState(4165);
      orderClause();
    }
    setState(4169);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIMIT_SYMBOL) {
      setState(4168);
      simpleLimitClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TransactionOrLockingStatementContext ------------------------------------------------------------------

MySQLParser::TransactionOrLockingStatementContext::TransactionOrLockingStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TransactionStatementContext* MySQLParser::TransactionOrLockingStatementContext::transactionStatement() {
  return getRuleContext<MySQLParser::TransactionStatementContext>(0);
}

MySQLParser::SavepointStatementContext* MySQLParser::TransactionOrLockingStatementContext::savepointStatement() {
  return getRuleContext<MySQLParser::SavepointStatementContext>(0);
}

MySQLParser::LockStatementContext* MySQLParser::TransactionOrLockingStatementContext::lockStatement() {
  return getRuleContext<MySQLParser::LockStatementContext>(0);
}

MySQLParser::XaStatementContext* MySQLParser::TransactionOrLockingStatementContext::xaStatement() {
  return getRuleContext<MySQLParser::XaStatementContext>(0);
}


size_t MySQLParser::TransactionOrLockingStatementContext::getRuleIndex() const {
  return MySQLParser::RuleTransactionOrLockingStatement;
}

void MySQLParser::TransactionOrLockingStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTransactionOrLockingStatement(this);
}

void MySQLParser::TransactionOrLockingStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTransactionOrLockingStatement(this);
}


std::any MySQLParser::TransactionOrLockingStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTransactionOrLockingStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TransactionOrLockingStatementContext* MySQLParser::transactionOrLockingStatement() {
  TransactionOrLockingStatementContext *_localctx = _tracker.createInstance<TransactionOrLockingStatementContext>(_ctx, getState());
  enterRule(_localctx, 470, MySQLParser::RuleTransactionOrLockingStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4175);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 425, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4171);
      transactionStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4172);
      savepointStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4173);
      lockStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4174);
      xaStatement();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TransactionStatementContext ------------------------------------------------------------------

MySQLParser::TransactionStatementContext::TransactionStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::TRANSACTION_SYMBOL() {
  return getToken(MySQLParser::TRANSACTION_SYMBOL, 0);
}

std::vector<MySQLParser::StartTransactionOptionListContext *> MySQLParser::TransactionStatementContext::startTransactionOptionList() {
  return getRuleContexts<MySQLParser::StartTransactionOptionListContext>();
}

MySQLParser::StartTransactionOptionListContext* MySQLParser::TransactionStatementContext::startTransactionOptionList(size_t i) {
  return getRuleContext<MySQLParser::StartTransactionOptionListContext>(i);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::COMMIT_SYMBOL() {
  return getToken(MySQLParser::COMMIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::WORK_SYMBOL() {
  return getToken(MySQLParser::WORK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::AND_SYMBOL() {
  return getToken(MySQLParser::AND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::CHAIN_SYMBOL() {
  return getToken(MySQLParser::CHAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::RELEASE_SYMBOL() {
  return getToken(MySQLParser::RELEASE_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::TransactionStatementContext::NO_SYMBOL() {
  return getTokens(MySQLParser::NO_SYMBOL);
}

tree::TerminalNode* MySQLParser::TransactionStatementContext::NO_SYMBOL(size_t i) {
  return getToken(MySQLParser::NO_SYMBOL, i);
}


size_t MySQLParser::TransactionStatementContext::getRuleIndex() const {
  return MySQLParser::RuleTransactionStatement;
}

void MySQLParser::TransactionStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTransactionStatement(this);
}

void MySQLParser::TransactionStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTransactionStatement(this);
}


std::any MySQLParser::TransactionStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTransactionStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TransactionStatementContext* MySQLParser::transactionStatement() {
  TransactionStatementContext *_localctx = _tracker.createInstance<TransactionStatementContext>(_ctx, getState());
  enterRule(_localctx, 472, MySQLParser::RuleTransactionStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4202);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::START_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4177);
        match(MySQLParser::START_SYMBOL);
        setState(4178);
        match(MySQLParser::TRANSACTION_SYMBOL);
        setState(4182);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::READ_SYMBOL || _la == MySQLParser::WITH_SYMBOL) {
          setState(4179);
          startTransactionOptionList();
          setState(4184);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case MySQLParser::COMMIT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4185);
        match(MySQLParser::COMMIT_SYMBOL);
        setState(4187);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WORK_SYMBOL) {
          setState(4186);
          match(MySQLParser::WORK_SYMBOL);
        }
        setState(4194);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::AND_SYMBOL) {
          setState(4189);
          match(MySQLParser::AND_SYMBOL);
          setState(4191);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::NO_SYMBOL) {
            setState(4190);
            match(MySQLParser::NO_SYMBOL);
          }
          setState(4193);
          match(MySQLParser::CHAIN_SYMBOL);
        }
        setState(4200);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NO_SYMBOL || _la == MySQLParser::RELEASE_SYMBOL) {
          setState(4197);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::NO_SYMBOL) {
            setState(4196);
            match(MySQLParser::NO_SYMBOL);
          }
          setState(4199);
          match(MySQLParser::RELEASE_SYMBOL);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BeginWorkContext ------------------------------------------------------------------

MySQLParser::BeginWorkContext::BeginWorkContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::BeginWorkContext::BEGIN_SYMBOL() {
  return getToken(MySQLParser::BEGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::BeginWorkContext::WORK_SYMBOL() {
  return getToken(MySQLParser::WORK_SYMBOL, 0);
}


size_t MySQLParser::BeginWorkContext::getRuleIndex() const {
  return MySQLParser::RuleBeginWork;
}

void MySQLParser::BeginWorkContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBeginWork(this);
}

void MySQLParser::BeginWorkContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBeginWork(this);
}


std::any MySQLParser::BeginWorkContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitBeginWork(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::BeginWorkContext* MySQLParser::beginWork() {
  BeginWorkContext *_localctx = _tracker.createInstance<BeginWorkContext>(_ctx, getState());
  enterRule(_localctx, 474, MySQLParser::RuleBeginWork);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4204);
    match(MySQLParser::BEGIN_SYMBOL);
    setState(4206);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::WORK_SYMBOL) {
      setState(4205);
      match(MySQLParser::WORK_SYMBOL);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StartTransactionOptionListContext ------------------------------------------------------------------

MySQLParser::StartTransactionOptionListContext::StartTransactionOptionListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StartTransactionOptionListContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartTransactionOptionListContext::CONSISTENT_SYMBOL() {
  return getToken(MySQLParser::CONSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartTransactionOptionListContext::SNAPSHOT_SYMBOL() {
  return getToken(MySQLParser::SNAPSHOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartTransactionOptionListContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartTransactionOptionListContext::WRITE_SYMBOL() {
  return getToken(MySQLParser::WRITE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartTransactionOptionListContext::ONLY_SYMBOL() {
  return getToken(MySQLParser::ONLY_SYMBOL, 0);
}


size_t MySQLParser::StartTransactionOptionListContext::getRuleIndex() const {
  return MySQLParser::RuleStartTransactionOptionList;
}

void MySQLParser::StartTransactionOptionListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStartTransactionOptionList(this);
}

void MySQLParser::StartTransactionOptionListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStartTransactionOptionList(this);
}


std::any MySQLParser::StartTransactionOptionListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStartTransactionOptionList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StartTransactionOptionListContext* MySQLParser::startTransactionOptionList() {
  StartTransactionOptionListContext *_localctx = _tracker.createInstance<StartTransactionOptionListContext>(_ctx, getState());
  enterRule(_localctx, 476, MySQLParser::RuleStartTransactionOptionList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4213);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::WITH_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4208);
        match(MySQLParser::WITH_SYMBOL);
        setState(4209);
        match(MySQLParser::CONSISTENT_SYMBOL);
        setState(4210);
        match(MySQLParser::SNAPSHOT_SYMBOL);
        break;
      }

      case MySQLParser::READ_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4211);
        match(MySQLParser::READ_SYMBOL);
        setState(4212);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::ONLY_SYMBOL || _la == MySQLParser::WRITE_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SavepointStatementContext ------------------------------------------------------------------

MySQLParser::SavepointStatementContext::SavepointStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::SAVEPOINT_SYMBOL() {
  return getToken(MySQLParser::SAVEPOINT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::SavepointStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::ROLLBACK_SYMBOL() {
  return getToken(MySQLParser::ROLLBACK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::WORK_SYMBOL() {
  return getToken(MySQLParser::WORK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::AND_SYMBOL() {
  return getToken(MySQLParser::AND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::CHAIN_SYMBOL() {
  return getToken(MySQLParser::CHAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::RELEASE_SYMBOL() {
  return getToken(MySQLParser::RELEASE_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::SavepointStatementContext::NO_SYMBOL() {
  return getTokens(MySQLParser::NO_SYMBOL);
}

tree::TerminalNode* MySQLParser::SavepointStatementContext::NO_SYMBOL(size_t i) {
  return getToken(MySQLParser::NO_SYMBOL, i);
}


size_t MySQLParser::SavepointStatementContext::getRuleIndex() const {
  return MySQLParser::RuleSavepointStatement;
}

void MySQLParser::SavepointStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSavepointStatement(this);
}

void MySQLParser::SavepointStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSavepointStatement(this);
}


std::any MySQLParser::SavepointStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSavepointStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SavepointStatementContext* MySQLParser::savepointStatement() {
  SavepointStatementContext *_localctx = _tracker.createInstance<SavepointStatementContext>(_ctx, getState());
  enterRule(_localctx, 478, MySQLParser::RuleSavepointStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4244);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::SAVEPOINT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4215);
        match(MySQLParser::SAVEPOINT_SYMBOL);
        setState(4216);
        identifier();
        break;
      }

      case MySQLParser::ROLLBACK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4217);
        match(MySQLParser::ROLLBACK_SYMBOL);
        setState(4219);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WORK_SYMBOL) {
          setState(4218);
          match(MySQLParser::WORK_SYMBOL);
        }
        setState(4239);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::TO_SYMBOL: {
            setState(4221);
            match(MySQLParser::TO_SYMBOL);
            setState(4223);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 436, _ctx)) {
            case 1: {
              setState(4222);
              match(MySQLParser::SAVEPOINT_SYMBOL);
              break;
            }

            default:
              break;
            }
            setState(4225);
            identifier();
            break;
          }

          case MySQLParser::EOF:
          case MySQLParser::SEMICOLON_SYMBOL:
          case MySQLParser::AND_SYMBOL:
          case MySQLParser::NO_SYMBOL:
          case MySQLParser::RELEASE_SYMBOL: {
            setState(4231);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == MySQLParser::AND_SYMBOL) {
              setState(4226);
              match(MySQLParser::AND_SYMBOL);
              setState(4228);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == MySQLParser::NO_SYMBOL) {
                setState(4227);
                match(MySQLParser::NO_SYMBOL);
              }
              setState(4230);
              match(MySQLParser::CHAIN_SYMBOL);
            }
            setState(4237);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == MySQLParser::NO_SYMBOL || _la == MySQLParser::RELEASE_SYMBOL) {
              setState(4234);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == MySQLParser::NO_SYMBOL) {
                setState(4233);
                match(MySQLParser::NO_SYMBOL);
              }
              setState(4236);
              match(MySQLParser::RELEASE_SYMBOL);
            }
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        break;
      }

      case MySQLParser::RELEASE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4241);
        match(MySQLParser::RELEASE_SYMBOL);
        setState(4242);
        match(MySQLParser::SAVEPOINT_SYMBOL);
        setState(4243);
        identifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockStatementContext ------------------------------------------------------------------

MySQLParser::LockStatementContext::LockStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LockStatementContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}

std::vector<MySQLParser::LockItemContext *> MySQLParser::LockStatementContext::lockItem() {
  return getRuleContexts<MySQLParser::LockItemContext>();
}

MySQLParser::LockItemContext* MySQLParser::LockStatementContext::lockItem(size_t i) {
  return getRuleContext<MySQLParser::LockItemContext>(i);
}

tree::TerminalNode* MySQLParser::LockStatementContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::LockStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::LockStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::LockStatementContext::INSTANCE_SYMBOL() {
  return getToken(MySQLParser::INSTANCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockStatementContext::BACKUP_SYMBOL() {
  return getToken(MySQLParser::BACKUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockStatementContext::UNLOCK_SYMBOL() {
  return getToken(MySQLParser::UNLOCK_SYMBOL, 0);
}


size_t MySQLParser::LockStatementContext::getRuleIndex() const {
  return MySQLParser::RuleLockStatement;
}

void MySQLParser::LockStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockStatement(this);
}

void MySQLParser::LockStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockStatement(this);
}


std::any MySQLParser::LockStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockStatementContext* MySQLParser::lockStatement() {
  LockStatementContext *_localctx = _tracker.createInstance<LockStatementContext>(_ctx, getState());
  enterRule(_localctx, 480, MySQLParser::RuleLockStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4268);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 445, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4246);
      match(MySQLParser::LOCK_SYMBOL);
      setState(4247);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::TABLES_SYMBOL

      || _la == MySQLParser::TABLE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(4248);
      lockItem();
      setState(4253);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(4249);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4250);
        lockItem();
        setState(4255);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4256);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4257);
      match(MySQLParser::LOCK_SYMBOL);
      setState(4258);
      match(MySQLParser::INSTANCE_SYMBOL);
      setState(4259);
      match(MySQLParser::FOR_SYMBOL);
      setState(4260);
      match(MySQLParser::BACKUP_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4261);
      match(MySQLParser::UNLOCK_SYMBOL);
      setState(4266);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 444, _ctx)) {
      case 1: {
        setState(4262);
        match(MySQLParser::TABLES_SYMBOL);
        break;
      }

      case 2: {
        setState(4263);
        match(MySQLParser::TABLE_SYMBOL);
        break;
      }

      case 3: {
        setState(4264);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(4265);
        match(MySQLParser::INSTANCE_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockItemContext ------------------------------------------------------------------

MySQLParser::LockItemContext::LockItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::LockItemContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::LockOptionContext* MySQLParser::LockItemContext::lockOption() {
  return getRuleContext<MySQLParser::LockOptionContext>(0);
}

MySQLParser::TableAliasContext* MySQLParser::LockItemContext::tableAlias() {
  return getRuleContext<MySQLParser::TableAliasContext>(0);
}


size_t MySQLParser::LockItemContext::getRuleIndex() const {
  return MySQLParser::RuleLockItem;
}

void MySQLParser::LockItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockItem(this);
}

void MySQLParser::LockItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockItem(this);
}


std::any MySQLParser::LockItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockItemContext* MySQLParser::lockItem() {
  LockItemContext *_localctx = _tracker.createInstance<LockItemContext>(_ctx, getState());
  enterRule(_localctx, 482, MySQLParser::RuleLockItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4270);
    tableRef();
    setState(4272);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 446, _ctx)) {
    case 1: {
      setState(4271);
      tableAlias();
      break;
    }

    default:
      break;
    }
    setState(4274);
    lockOption();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LockOptionContext ------------------------------------------------------------------

MySQLParser::LockOptionContext::LockOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LockOptionContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockOptionContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockOptionContext::WRITE_SYMBOL() {
  return getToken(MySQLParser::WRITE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LockOptionContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}


size_t MySQLParser::LockOptionContext::getRuleIndex() const {
  return MySQLParser::RuleLockOption;
}

void MySQLParser::LockOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLockOption(this);
}

void MySQLParser::LockOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLockOption(this);
}


std::any MySQLParser::LockOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLockOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LockOptionContext* MySQLParser::lockOption() {
  LockOptionContext *_localctx = _tracker.createInstance<LockOptionContext>(_ctx, getState());
  enterRule(_localctx, 484, MySQLParser::RuleLockOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4285);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 449, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4276);
      match(MySQLParser::READ_SYMBOL);
      setState(4278);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LOCAL_SYMBOL) {
        setState(4277);
        match(MySQLParser::LOCAL_SYMBOL);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4282);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 448, _ctx)) {
      case 1: {
        setState(4280);

        if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
        setState(4281);
        match(MySQLParser::LOW_PRIORITY_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(4284);
      match(MySQLParser::WRITE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- XaStatementContext ------------------------------------------------------------------

MySQLParser::XaStatementContext::XaStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::XaStatementContext::XA_SYMBOL() {
  return getToken(MySQLParser::XA_SYMBOL, 0);
}

MySQLParser::XidContext* MySQLParser::XaStatementContext::xid() {
  return getRuleContext<MySQLParser::XidContext>(0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::PREPARE_SYMBOL() {
  return getToken(MySQLParser::PREPARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::COMMIT_SYMBOL() {
  return getToken(MySQLParser::COMMIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::ROLLBACK_SYMBOL() {
  return getToken(MySQLParser::ROLLBACK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::RECOVER_SYMBOL() {
  return getToken(MySQLParser::RECOVER_SYMBOL, 0);
}

MySQLParser::XaConvertContext* MySQLParser::XaStatementContext::xaConvert() {
  return getRuleContext<MySQLParser::XaConvertContext>(0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::BEGIN_SYMBOL() {
  return getToken(MySQLParser::BEGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::SUSPEND_SYMBOL() {
  return getToken(MySQLParser::SUSPEND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::ONE_SYMBOL() {
  return getToken(MySQLParser::ONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::PHASE_SYMBOL() {
  return getToken(MySQLParser::PHASE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::JOIN_SYMBOL() {
  return getToken(MySQLParser::JOIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::RESUME_SYMBOL() {
  return getToken(MySQLParser::RESUME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaStatementContext::MIGRATE_SYMBOL() {
  return getToken(MySQLParser::MIGRATE_SYMBOL, 0);
}


size_t MySQLParser::XaStatementContext::getRuleIndex() const {
  return MySQLParser::RuleXaStatement;
}

void MySQLParser::XaStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterXaStatement(this);
}

void MySQLParser::XaStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitXaStatement(this);
}


std::any MySQLParser::XaStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitXaStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::XaStatementContext* MySQLParser::xaStatement() {
  XaStatementContext *_localctx = _tracker.createInstance<XaStatementContext>(_ctx, getState());
  enterRule(_localctx, 486, MySQLParser::RuleXaStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4287);
    match(MySQLParser::XA_SYMBOL);
    setState(4314);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::BEGIN_SYMBOL:
      case MySQLParser::START_SYMBOL: {
        setState(4288);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::BEGIN_SYMBOL || _la == MySQLParser::START_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(4289);
        xid();
        setState(4291);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::JOIN_SYMBOL || _la == MySQLParser::RESUME_SYMBOL) {
          setState(4290);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::JOIN_SYMBOL || _la == MySQLParser::RESUME_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        break;
      }

      case MySQLParser::END_SYMBOL: {
        setState(4293);
        match(MySQLParser::END_SYMBOL);
        setState(4294);
        xid();
        setState(4300);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::SUSPEND_SYMBOL) {
          setState(4295);
          match(MySQLParser::SUSPEND_SYMBOL);
          setState(4298);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::FOR_SYMBOL) {
            setState(4296);
            match(MySQLParser::FOR_SYMBOL);
            setState(4297);
            match(MySQLParser::MIGRATE_SYMBOL);
          }
        }
        break;
      }

      case MySQLParser::PREPARE_SYMBOL: {
        setState(4302);
        match(MySQLParser::PREPARE_SYMBOL);
        setState(4303);
        xid();
        break;
      }

      case MySQLParser::COMMIT_SYMBOL: {
        setState(4304);
        match(MySQLParser::COMMIT_SYMBOL);
        setState(4305);
        xid();
        setState(4308);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ONE_SYMBOL) {
          setState(4306);
          match(MySQLParser::ONE_SYMBOL);
          setState(4307);
          match(MySQLParser::PHASE_SYMBOL);
        }
        break;
      }

      case MySQLParser::ROLLBACK_SYMBOL: {
        setState(4310);
        match(MySQLParser::ROLLBACK_SYMBOL);
        setState(4311);
        xid();
        break;
      }

      case MySQLParser::RECOVER_SYMBOL: {
        setState(4312);
        match(MySQLParser::RECOVER_SYMBOL);
        setState(4313);
        xaConvert();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- XaConvertContext ------------------------------------------------------------------

MySQLParser::XaConvertContext::XaConvertContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::XaConvertContext::CONVERT_SYMBOL() {
  return getToken(MySQLParser::CONVERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::XaConvertContext::XID_SYMBOL() {
  return getToken(MySQLParser::XID_SYMBOL, 0);
}


size_t MySQLParser::XaConvertContext::getRuleIndex() const {
  return MySQLParser::RuleXaConvert;
}

void MySQLParser::XaConvertContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterXaConvert(this);
}

void MySQLParser::XaConvertContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitXaConvert(this);
}


std::any MySQLParser::XaConvertContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitXaConvert(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::XaConvertContext* MySQLParser::xaConvert() {
  XaConvertContext *_localctx = _tracker.createInstance<XaConvertContext>(_ctx, getState());
  enterRule(_localctx, 488, MySQLParser::RuleXaConvert);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4322);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 456, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4316);

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(4319);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::CONVERT_SYMBOL) {
        setState(4317);
        match(MySQLParser::CONVERT_SYMBOL);
        setState(4318);
        match(MySQLParser::XID_SYMBOL);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);

      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- XidContext ------------------------------------------------------------------

MySQLParser::XidContext::XidContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TextStringContext *> MySQLParser::XidContext::textString() {
  return getRuleContexts<MySQLParser::TextStringContext>();
}

MySQLParser::TextStringContext* MySQLParser::XidContext::textString(size_t i) {
  return getRuleContext<MySQLParser::TextStringContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::XidContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::XidContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

MySQLParser::Ulong_numberContext* MySQLParser::XidContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}


size_t MySQLParser::XidContext::getRuleIndex() const {
  return MySQLParser::RuleXid;
}

void MySQLParser::XidContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterXid(this);
}

void MySQLParser::XidContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitXid(this);
}


std::any MySQLParser::XidContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitXid(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::XidContext* MySQLParser::xid() {
  XidContext *_localctx = _tracker.createInstance<XidContext>(_ctx, getState());
  enterRule(_localctx, 490, MySQLParser::RuleXid);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4324);
    textString();
    setState(4331);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4325);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4326);
      textString();
      setState(4329);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(4327);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4328);
        ulong_number();
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplicationStatementContext ------------------------------------------------------------------

MySQLParser::ReplicationStatementContext::ReplicationStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::PURGE_SYMBOL() {
  return getToken(MySQLParser::PURGE_SYMBOL, 0);
}

MySQLParser::PurgeOptionsContext* MySQLParser::ReplicationStatementContext::purgeOptions() {
  return getRuleContext<MySQLParser::PurgeOptionsContext>(0);
}

MySQLParser::ChangeReplicationSourceContext* MySQLParser::ReplicationStatementContext::changeReplicationSource() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceContext>(0);
}

MySQLParser::ChangeReplicationFilterContext* MySQLParser::ReplicationStatementContext::changeReplicationFilter() {
  return getRuleContext<MySQLParser::ChangeReplicationFilterContext>(0);
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::RESET_SYMBOL() {
  return getToken(MySQLParser::RESET_SYMBOL, 0);
}

std::vector<MySQLParser::ResetOptionContext *> MySQLParser::ReplicationStatementContext::resetOption() {
  return getRuleContexts<MySQLParser::ResetOptionContext>();
}

MySQLParser::ResetOptionContext* MySQLParser::ReplicationStatementContext::resetOption(size_t i) {
  return getRuleContext<MySQLParser::ResetOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ReplicationStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::PERSIST_SYMBOL() {
  return getToken(MySQLParser::PERSIST_SYMBOL, 0);
}

MySQLParser::IfExistsIdentifierContext* MySQLParser::ReplicationStatementContext::ifExistsIdentifier() {
  return getRuleContext<MySQLParser::IfExistsIdentifierContext>(0);
}

MySQLParser::StartReplicaStatementContext* MySQLParser::ReplicationStatementContext::startReplicaStatement() {
  return getRuleContext<MySQLParser::StartReplicaStatementContext>(0);
}

MySQLParser::StopReplicaStatementContext* MySQLParser::ReplicationStatementContext::stopReplicaStatement() {
  return getRuleContext<MySQLParser::StopReplicaStatementContext>(0);
}

MySQLParser::GroupReplicationContext* MySQLParser::ReplicationStatementContext::groupReplication() {
  return getRuleContext<MySQLParser::GroupReplicationContext>(0);
}


size_t MySQLParser::ReplicationStatementContext::getRuleIndex() const {
  return MySQLParser::RuleReplicationStatement;
}

void MySQLParser::ReplicationStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplicationStatement(this);
}

void MySQLParser::ReplicationStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplicationStatement(this);
}


std::any MySQLParser::ReplicationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplicationStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplicationStatementContext* MySQLParser::replicationStatement() {
  ReplicationStatementContext *_localctx = _tracker.createInstance<ReplicationStatementContext>(_ctx, getState());
  enterRule(_localctx, 492, MySQLParser::RuleReplicationStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4356);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 461, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4333);
      match(MySQLParser::PURGE_SYMBOL);
      setState(4334);
      purgeOptions();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4335);
      changeReplicationSource();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4336);
      changeReplicationFilter();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4337);
      match(MySQLParser::RESET_SYMBOL);
      setState(4338);
      resetOption();
      setState(4343);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(4339);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4340);
        resetOption();
        setState(4345);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4346);

      if (!(serverVersion > 80000)) throw FailedPredicateException(this, "serverVersion > 80000");
      setState(4347);
      match(MySQLParser::RESET_SYMBOL);
      setState(4348);
      match(MySQLParser::PERSIST_SYMBOL);
      setState(4350);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 460, _ctx)) {
      case 1: {
        setState(4349);
        ifExistsIdentifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(4352);
      startReplicaStatement();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(4353);
      stopReplicaStatement();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(4354);

      if (!(serverVersion > 50706)) throw FailedPredicateException(this, "serverVersion > 50706");
      setState(4355);
      groupReplication();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PurgeOptionsContext ------------------------------------------------------------------

MySQLParser::PurgeOptionsContext::PurgeOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PurgeOptionsContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PurgeOptionsContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PurgeOptionsContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PurgeOptionsContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::PurgeOptionsContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::PurgeOptionsContext::BEFORE_SYMBOL() {
  return getToken(MySQLParser::BEFORE_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::PurgeOptionsContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::PurgeOptionsContext::getRuleIndex() const {
  return MySQLParser::RulePurgeOptions;
}

void MySQLParser::PurgeOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPurgeOptions(this);
}

void MySQLParser::PurgeOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPurgeOptions(this);
}


std::any MySQLParser::PurgeOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPurgeOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PurgeOptionsContext* MySQLParser::purgeOptions() {
  PurgeOptionsContext *_localctx = _tracker.createInstance<PurgeOptionsContext>(_ctx, getState());
  enterRule(_localctx, 494, MySQLParser::RulePurgeOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4361);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 462, _ctx)) {
    case 1: {
      setState(4358);
      match(MySQLParser::BINARY_SYMBOL);
      break;
    }

    case 2: {
      setState(4359);

      if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
      setState(4360);
      match(MySQLParser::MASTER_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(4363);
    match(MySQLParser::LOGS_SYMBOL);
    setState(4368);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::TO_SYMBOL: {
        setState(4364);
        match(MySQLParser::TO_SYMBOL);
        setState(4365);
        textLiteral();
        break;
      }

      case MySQLParser::BEFORE_SYMBOL: {
        setState(4366);
        match(MySQLParser::BEFORE_SYMBOL);
        setState(4367);
        expr(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResetOptionContext ------------------------------------------------------------------

MySQLParser::ResetOptionContext::ResetOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::MasterOrBinaryLogsAndGtidsContext* MySQLParser::ResetOptionContext::masterOrBinaryLogsAndGtids() {
  return getRuleContext<MySQLParser::MasterOrBinaryLogsAndGtidsContext>(0);
}

MySQLParser::SourceResetOptionsContext* MySQLParser::ResetOptionContext::sourceResetOptions() {
  return getRuleContext<MySQLParser::SourceResetOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::ResetOptionContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ResetOptionContext::CACHE_SYMBOL() {
  return getToken(MySQLParser::CACHE_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::ResetOptionContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}

tree::TerminalNode* MySQLParser::ResetOptionContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

MySQLParser::ChannelContext* MySQLParser::ResetOptionContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ResetOptionContext::getRuleIndex() const {
  return MySQLParser::RuleResetOption;
}

void MySQLParser::ResetOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResetOption(this);
}

void MySQLParser::ResetOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResetOption(this);
}


std::any MySQLParser::ResetOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResetOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResetOptionContext* MySQLParser::resetOption() {
  ResetOptionContext *_localctx = _tracker.createInstance<ResetOptionContext>(_ctx, getState());
  enterRule(_localctx, 496, MySQLParser::RuleResetOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4384);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 467, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4370);
      masterOrBinaryLogsAndGtids();
      setState(4372);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 464, _ctx)) {
      case 1: {
        setState(4371);
        sourceResetOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4374);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(4375);
      match(MySQLParser::QUERY_SYMBOL);
      setState(4376);
      match(MySQLParser::CACHE_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4377);
      replica();
      setState(4379);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 465, _ctx)) {
      case 1: {
        setState(4378);
        match(MySQLParser::ALL_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(4382);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 466, _ctx)) {
      case 1: {
        setState(4381);
        channel();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MasterOrBinaryLogsAndGtidsContext ------------------------------------------------------------------

MySQLParser::MasterOrBinaryLogsAndGtidsContext::MasterOrBinaryLogsAndGtidsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::MasterOrBinaryLogsAndGtidsContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOrBinaryLogsAndGtidsContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOrBinaryLogsAndGtidsContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOrBinaryLogsAndGtidsContext::AND_SYMBOL() {
  return getToken(MySQLParser::AND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOrBinaryLogsAndGtidsContext::GTIDS_SYMBOL() {
  return getToken(MySQLParser::GTIDS_SYMBOL, 0);
}


size_t MySQLParser::MasterOrBinaryLogsAndGtidsContext::getRuleIndex() const {
  return MySQLParser::RuleMasterOrBinaryLogsAndGtids;
}

void MySQLParser::MasterOrBinaryLogsAndGtidsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterMasterOrBinaryLogsAndGtids(this);
}

void MySQLParser::MasterOrBinaryLogsAndGtidsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitMasterOrBinaryLogsAndGtids(this);
}


std::any MySQLParser::MasterOrBinaryLogsAndGtidsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitMasterOrBinaryLogsAndGtids(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::MasterOrBinaryLogsAndGtidsContext* MySQLParser::masterOrBinaryLogsAndGtids() {
  MasterOrBinaryLogsAndGtidsContext *_localctx = _tracker.createInstance<MasterOrBinaryLogsAndGtidsContext>(_ctx, getState());
  enterRule(_localctx, 498, MySQLParser::RuleMasterOrBinaryLogsAndGtids);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4393);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 468, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4386);

      if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
      setState(4387);
      match(MySQLParser::MASTER_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4388);

      if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
      setState(4389);
      match(MySQLParser::BINARY_SYMBOL);
      setState(4390);
      match(MySQLParser::LOGS_SYMBOL);
      setState(4391);
      match(MySQLParser::AND_SYMBOL);
      setState(4392);
      match(MySQLParser::GTIDS_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceResetOptionsContext ------------------------------------------------------------------

MySQLParser::SourceResetOptionsContext::SourceResetOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SourceResetOptionsContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::SourceResetOptionsContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}


size_t MySQLParser::SourceResetOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleSourceResetOptions;
}

void MySQLParser::SourceResetOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceResetOptions(this);
}

void MySQLParser::SourceResetOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceResetOptions(this);
}


std::any MySQLParser::SourceResetOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceResetOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceResetOptionsContext* MySQLParser::sourceResetOptions() {
  SourceResetOptionsContext *_localctx = _tracker.createInstance<SourceResetOptionsContext>(_ctx, getState());
  enterRule(_localctx, 500, MySQLParser::RuleSourceResetOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4395);

    if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
    setState(4396);
    match(MySQLParser::TO_SYMBOL);
    setState(4397);
    real_ulonglong_number();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplicationSourceContext ------------------------------------------------------------------

MySQLParser::ReplicationSourceContext::ReplicationSourceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReplicationSourceContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicationSourceContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicationSourceContext::SOURCE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SYMBOL, 0);
}


size_t MySQLParser::ReplicationSourceContext::getRuleIndex() const {
  return MySQLParser::RuleReplicationSource;
}

void MySQLParser::ReplicationSourceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplicationSource(this);
}

void MySQLParser::ReplicationSourceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplicationSource(this);
}


std::any MySQLParser::ReplicationSourceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplicationSource(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplicationSourceContext* MySQLParser::replicationSource() {
  ReplicationSourceContext *_localctx = _tracker.createInstance<ReplicationSourceContext>(_ctx, getState());
  enterRule(_localctx, 502, MySQLParser::RuleReplicationSource);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4404);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 469, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4399);

      if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
      setState(4400);
      match(MySQLParser::MASTER_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4401);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(4402);
      match(MySQLParser::REPLICATION_SYMBOL);
      setState(4403);
      match(MySQLParser::SOURCE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceContext::ChangeReplicationSourceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceContext::CHANGE_SYMBOL() {
  return getToken(MySQLParser::CHANGE_SYMBOL, 0);
}

MySQLParser::ReplicationSourceContext* MySQLParser::ChangeReplicationSourceContext::replicationSource() {
  return getRuleContext<MySQLParser::ReplicationSourceContext>(0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::SourceDefinitionsContext* MySQLParser::ChangeReplicationSourceContext::sourceDefinitions() {
  return getRuleContext<MySQLParser::SourceDefinitionsContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::ChangeReplicationSourceContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ChangeReplicationSourceContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSource;
}

void MySQLParser::ChangeReplicationSourceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSource(this);
}

void MySQLParser::ChangeReplicationSourceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSource(this);
}


std::any MySQLParser::ChangeReplicationSourceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSource(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceContext* MySQLParser::changeReplicationSource() {
  ChangeReplicationSourceContext *_localctx = _tracker.createInstance<ChangeReplicationSourceContext>(_ctx, getState());
  enterRule(_localctx, 504, MySQLParser::RuleChangeReplicationSource);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4406);
    match(MySQLParser::CHANGE_SYMBOL);
    setState(4407);
    replicationSource();
    setState(4408);
    match(MySQLParser::TO_SYMBOL);
    setState(4409);
    sourceDefinitions();
    setState(4411);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 470, _ctx)) {
    case 1: {
      setState(4410);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceDefinitionsContext ------------------------------------------------------------------

MySQLParser::SourceDefinitionsContext::SourceDefinitionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SourceDefinitionContext *> MySQLParser::SourceDefinitionsContext::sourceDefinition() {
  return getRuleContexts<MySQLParser::SourceDefinitionContext>();
}

MySQLParser::SourceDefinitionContext* MySQLParser::SourceDefinitionsContext::sourceDefinition(size_t i) {
  return getRuleContext<MySQLParser::SourceDefinitionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::SourceDefinitionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::SourceDefinitionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::SourceDefinitionsContext::getRuleIndex() const {
  return MySQLParser::RuleSourceDefinitions;
}

void MySQLParser::SourceDefinitionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceDefinitions(this);
}

void MySQLParser::SourceDefinitionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceDefinitions(this);
}


std::any MySQLParser::SourceDefinitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceDefinitions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceDefinitionsContext* MySQLParser::sourceDefinitions() {
  SourceDefinitionsContext *_localctx = _tracker.createInstance<SourceDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 506, MySQLParser::RuleSourceDefinitions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4413);
    sourceDefinition();
    setState(4418);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 471, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4414);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4415);
        sourceDefinition(); 
      }
      setState(4420);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 471, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceDefinitionContext ------------------------------------------------------------------

MySQLParser::SourceDefinitionContext::SourceDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ChangeReplicationSourceHostContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceHost() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceHostContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::SourceDefinitionContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::NETWORK_NAMESPACE_SYMBOL() {
  return getToken(MySQLParser::NETWORK_NAMESPACE_SYMBOL, 0);
}

MySQLParser::ChangeReplicationSourceBindContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceBind() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceBindContext>(0);
}

MySQLParser::ChangeReplicationSourceUserContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceUser() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceUserContext>(0);
}

MySQLParser::ChangeReplicationSourcePasswordContext* MySQLParser::SourceDefinitionContext::changeReplicationSourcePassword() {
  return getRuleContext<MySQLParser::ChangeReplicationSourcePasswordContext>(0);
}

MySQLParser::ChangeReplicationSourcePortContext* MySQLParser::SourceDefinitionContext::changeReplicationSourcePort() {
  return getRuleContext<MySQLParser::ChangeReplicationSourcePortContext>(0);
}

MySQLParser::Ulong_numberContext* MySQLParser::SourceDefinitionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

MySQLParser::ChangeReplicationSourceConnectRetryContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceConnectRetry() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceConnectRetryContext>(0);
}

MySQLParser::ChangeReplicationSourceRetryCountContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceRetryCount() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceRetryCountContext>(0);
}

MySQLParser::ChangeReplicationSourceDelayContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceDelay() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceDelayContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSL() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLCAContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLCA() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLCAContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLCApathContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLCApath() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLCApathContext>(0);
}

MySQLParser::ChangeReplicationSourceTLSVersionContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceTLSVersion() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceTLSVersionContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLCertContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLCert() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLCertContext>(0);
}

MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceTLSCiphersuites() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext>(0);
}

MySQLParser::SourceTlsCiphersuitesDefContext* MySQLParser::SourceDefinitionContext::sourceTlsCiphersuitesDef() {
  return getRuleContext<MySQLParser::SourceTlsCiphersuitesDefContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLCipherContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLCipher() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLCipherContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLKeyContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLKey() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLKeyContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLVerifyServerCert() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLCLRContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLCLR() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLCLRContext>(0);
}

MySQLParser::TextLiteralContext* MySQLParser::SourceDefinitionContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::ChangeReplicationSourceSSLCLRpathContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceSSLCLRpath() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceSSLCLRpathContext>(0);
}

MySQLParser::ChangeReplicationSourcePublicKeyContext* MySQLParser::SourceDefinitionContext::changeReplicationSourcePublicKey() {
  return getRuleContext<MySQLParser::ChangeReplicationSourcePublicKeyContext>(0);
}

MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceGetSourcePublicKey() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext>(0);
}

MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceHeartbeatPeriod() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::IGNORE_SERVER_IDS_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SERVER_IDS_SYMBOL, 0);
}

MySQLParser::ServerIdListContext* MySQLParser::SourceDefinitionContext::serverIdList() {
  return getRuleContext<MySQLParser::ServerIdListContext>(0);
}

MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceCompressionAlgorithm() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext>(0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::SourceDefinitionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceZstdCompressionLevel() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext>(0);
}

MySQLParser::ChangeReplicationSourceAutoPositionContext* MySQLParser::SourceDefinitionContext::changeReplicationSourceAutoPosition() {
  return getRuleContext<MySQLParser::ChangeReplicationSourceAutoPositionContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::PRIVILEGE_CHECKS_USER_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL, 0);
}

MySQLParser::PrivilegeCheckDefContext* MySQLParser::SourceDefinitionContext::privilegeCheckDef() {
  return getRuleContext<MySQLParser::PrivilegeCheckDefContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::REQUIRE_ROW_FORMAT_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL, 0);
}

MySQLParser::TablePrimaryKeyCheckDefContext* MySQLParser::SourceDefinitionContext::tablePrimaryKeyCheckDef() {
  return getRuleContext<MySQLParser::TablePrimaryKeyCheckDefContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL() {
  return getToken(MySQLParser::SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::SourceDefinitionContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL() {
  return getToken(MySQLParser::ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL, 0);
}

MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext* MySQLParser::SourceDefinitionContext::assignGtidsToAnonymousTransactionsDefinition() {
  return getRuleContext<MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext>(0);
}

tree::TerminalNode* MySQLParser::SourceDefinitionContext::GTID_ONLY_SYMBOL() {
  return getToken(MySQLParser::GTID_ONLY_SYMBOL, 0);
}

MySQLParser::SourceFileDefContext* MySQLParser::SourceDefinitionContext::sourceFileDef() {
  return getRuleContext<MySQLParser::SourceFileDefContext>(0);
}


size_t MySQLParser::SourceDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleSourceDefinition;
}

void MySQLParser::SourceDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceDefinition(this);
}

void MySQLParser::SourceDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceDefinition(this);
}


std::any MySQLParser::SourceDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceDefinitionContext* MySQLParser::sourceDefinition() {
  SourceDefinitionContext *_localctx = _tracker.createInstance<SourceDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 508, MySQLParser::RuleSourceDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4549);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 472, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4421);
      changeReplicationSourceHost();
      setState(4422);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4423);
      textStringNoLinebreak();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4425);
      match(MySQLParser::NETWORK_NAMESPACE_SYMBOL);
      setState(4426);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4427);
      textStringNoLinebreak();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4428);
      changeReplicationSourceBind();
      setState(4429);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4430);
      textStringNoLinebreak();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4432);
      changeReplicationSourceUser();
      setState(4433);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4434);
      textStringNoLinebreak();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4436);
      changeReplicationSourcePassword();
      setState(4437);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4438);
      textStringNoLinebreak();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(4440);
      changeReplicationSourcePort();
      setState(4441);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4442);
      ulong_number();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(4444);
      changeReplicationSourceConnectRetry();
      setState(4445);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4446);
      ulong_number();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(4448);
      changeReplicationSourceRetryCount();
      setState(4449);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4450);
      ulong_number();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(4452);
      changeReplicationSourceDelay();
      setState(4453);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4454);
      ulong_number();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(4456);
      changeReplicationSourceSSL();
      setState(4457);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4458);
      ulong_number();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(4460);
      changeReplicationSourceSSLCA();
      setState(4461);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4462);
      textStringNoLinebreak();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(4464);
      changeReplicationSourceSSLCApath();
      setState(4465);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4466);
      textStringNoLinebreak();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(4468);
      changeReplicationSourceTLSVersion();
      setState(4469);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4470);
      textStringNoLinebreak();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(4472);
      changeReplicationSourceSSLCert();
      setState(4473);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4474);
      textStringNoLinebreak();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(4476);
      changeReplicationSourceTLSCiphersuites();
      setState(4477);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4478);
      sourceTlsCiphersuitesDef();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(4480);
      changeReplicationSourceSSLCipher();
      setState(4481);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4482);
      textStringNoLinebreak();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(4484);
      changeReplicationSourceSSLKey();
      setState(4485);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4486);
      textStringNoLinebreak();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(4488);
      changeReplicationSourceSSLVerifyServerCert();
      setState(4489);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4490);
      ulong_number();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(4492);
      changeReplicationSourceSSLCLR();
      setState(4493);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4494);
      textLiteral();
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(4496);
      changeReplicationSourceSSLCLRpath();
      setState(4497);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4498);
      textStringNoLinebreak();
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(4500);
      changeReplicationSourcePublicKey();
      setState(4501);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4502);
      textStringNoLinebreak();
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(4504);
      changeReplicationSourceGetSourcePublicKey();
      setState(4505);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4506);
      ulong_number();
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(4508);
      changeReplicationSourceHeartbeatPeriod();
      setState(4509);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4510);
      ulong_number();
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(4512);
      match(MySQLParser::IGNORE_SERVER_IDS_SYMBOL);
      setState(4513);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4514);
      serverIdList();
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(4515);
      changeReplicationSourceCompressionAlgorithm();
      setState(4516);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4517);
      textStringLiteral();
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(4519);
      changeReplicationSourceZstdCompressionLevel();
      setState(4520);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4521);
      ulong_number();
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(4523);
      changeReplicationSourceAutoPosition();
      setState(4524);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4525);
      ulong_number();
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(4527);
      match(MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL);
      setState(4528);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4529);
      privilegeCheckDef();
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(4530);
      match(MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL);
      setState(4531);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4532);
      ulong_number();
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(4533);
      match(MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL);
      setState(4534);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4535);
      tablePrimaryKeyCheckDef();
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(4536);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(4537);
      match(MySQLParser::SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL);
      setState(4538);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4539);
      real_ulong_number();
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(4540);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(4541);
      match(MySQLParser::ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL);
      setState(4542);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4543);
      assignGtidsToAnonymousTransactionsDefinition();
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(4544);

      if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
      setState(4545);
      match(MySQLParser::GTID_ONLY_SYMBOL);
      setState(4546);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4547);
      real_ulong_number();
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(4548);
      sourceFileDef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceAutoPositionContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceAutoPositionContext::ChangeReplicationSourceAutoPositionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceAutoPositionContext::MASTER_AUTO_POSITION_SYMBOL() {
  return getToken(MySQLParser::MASTER_AUTO_POSITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceAutoPositionContext::SOURCE_AUTO_POSITION_SYMBOL() {
  return getToken(MySQLParser::SOURCE_AUTO_POSITION_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceAutoPositionContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceAutoPosition;
}

void MySQLParser::ChangeReplicationSourceAutoPositionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceAutoPosition(this);
}

void MySQLParser::ChangeReplicationSourceAutoPositionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceAutoPosition(this);
}


std::any MySQLParser::ChangeReplicationSourceAutoPositionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceAutoPosition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceAutoPositionContext* MySQLParser::changeReplicationSourceAutoPosition() {
  ChangeReplicationSourceAutoPositionContext *_localctx = _tracker.createInstance<ChangeReplicationSourceAutoPositionContext>(_ctx, getState());
  enterRule(_localctx, 510, MySQLParser::RuleChangeReplicationSourceAutoPosition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4551);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_AUTO_POSITION_SYMBOL || _la == MySQLParser::SOURCE_AUTO_POSITION_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceHostContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceHostContext::ChangeReplicationSourceHostContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceHostContext::MASTER_HOST_SYMBOL() {
  return getToken(MySQLParser::MASTER_HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceHostContext::SOURCE_HOST_SYMBOL() {
  return getToken(MySQLParser::SOURCE_HOST_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceHostContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceHost;
}

void MySQLParser::ChangeReplicationSourceHostContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceHost(this);
}

void MySQLParser::ChangeReplicationSourceHostContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceHost(this);
}


std::any MySQLParser::ChangeReplicationSourceHostContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceHost(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceHostContext* MySQLParser::changeReplicationSourceHost() {
  ChangeReplicationSourceHostContext *_localctx = _tracker.createInstance<ChangeReplicationSourceHostContext>(_ctx, getState());
  enterRule(_localctx, 512, MySQLParser::RuleChangeReplicationSourceHost);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4553);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_HOST_SYMBOL || _la == MySQLParser::SOURCE_HOST_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceBindContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceBindContext::ChangeReplicationSourceBindContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceBindContext::MASTER_BIND_SYMBOL() {
  return getToken(MySQLParser::MASTER_BIND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceBindContext::SOURCE_BIND_SYMBOL() {
  return getToken(MySQLParser::SOURCE_BIND_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceBindContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceBind;
}

void MySQLParser::ChangeReplicationSourceBindContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceBind(this);
}

void MySQLParser::ChangeReplicationSourceBindContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceBind(this);
}


std::any MySQLParser::ChangeReplicationSourceBindContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceBind(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceBindContext* MySQLParser::changeReplicationSourceBind() {
  ChangeReplicationSourceBindContext *_localctx = _tracker.createInstance<ChangeReplicationSourceBindContext>(_ctx, getState());
  enterRule(_localctx, 514, MySQLParser::RuleChangeReplicationSourceBind);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4555);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_BIND_SYMBOL || _la == MySQLParser::SOURCE_BIND_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceUserContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceUserContext::ChangeReplicationSourceUserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceUserContext::MASTER_USER_SYMBOL() {
  return getToken(MySQLParser::MASTER_USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceUserContext::SOURCE_USER_SYMBOL() {
  return getToken(MySQLParser::SOURCE_USER_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceUserContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceUser;
}

void MySQLParser::ChangeReplicationSourceUserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceUser(this);
}

void MySQLParser::ChangeReplicationSourceUserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceUser(this);
}


std::any MySQLParser::ChangeReplicationSourceUserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceUserContext* MySQLParser::changeReplicationSourceUser() {
  ChangeReplicationSourceUserContext *_localctx = _tracker.createInstance<ChangeReplicationSourceUserContext>(_ctx, getState());
  enterRule(_localctx, 516, MySQLParser::RuleChangeReplicationSourceUser);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4557);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_USER_SYMBOL || _la == MySQLParser::SOURCE_USER_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourcePasswordContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourcePasswordContext::ChangeReplicationSourcePasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourcePasswordContext::MASTER_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::MASTER_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourcePasswordContext::SOURCE_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::SOURCE_PASSWORD_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourcePasswordContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourcePassword;
}

void MySQLParser::ChangeReplicationSourcePasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourcePassword(this);
}

void MySQLParser::ChangeReplicationSourcePasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourcePassword(this);
}


std::any MySQLParser::ChangeReplicationSourcePasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourcePassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourcePasswordContext* MySQLParser::changeReplicationSourcePassword() {
  ChangeReplicationSourcePasswordContext *_localctx = _tracker.createInstance<ChangeReplicationSourcePasswordContext>(_ctx, getState());
  enterRule(_localctx, 518, MySQLParser::RuleChangeReplicationSourcePassword);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4559);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_PASSWORD_SYMBOL || _la == MySQLParser::SOURCE_PASSWORD_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourcePortContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourcePortContext::ChangeReplicationSourcePortContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourcePortContext::MASTER_PORT_SYMBOL() {
  return getToken(MySQLParser::MASTER_PORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourcePortContext::SOURCE_PORT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_PORT_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourcePortContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourcePort;
}

void MySQLParser::ChangeReplicationSourcePortContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourcePort(this);
}

void MySQLParser::ChangeReplicationSourcePortContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourcePort(this);
}


std::any MySQLParser::ChangeReplicationSourcePortContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourcePort(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourcePortContext* MySQLParser::changeReplicationSourcePort() {
  ChangeReplicationSourcePortContext *_localctx = _tracker.createInstance<ChangeReplicationSourcePortContext>(_ctx, getState());
  enterRule(_localctx, 520, MySQLParser::RuleChangeReplicationSourcePort);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4561);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_PORT_SYMBOL || _la == MySQLParser::SOURCE_PORT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceConnectRetryContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceConnectRetryContext::ChangeReplicationSourceConnectRetryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceConnectRetryContext::MASTER_CONNECT_RETRY_SYMBOL() {
  return getToken(MySQLParser::MASTER_CONNECT_RETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceConnectRetryContext::SOURCE_CONNECT_RETRY_SYMBOL() {
  return getToken(MySQLParser::SOURCE_CONNECT_RETRY_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceConnectRetryContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceConnectRetry;
}

void MySQLParser::ChangeReplicationSourceConnectRetryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceConnectRetry(this);
}

void MySQLParser::ChangeReplicationSourceConnectRetryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceConnectRetry(this);
}


std::any MySQLParser::ChangeReplicationSourceConnectRetryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceConnectRetry(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceConnectRetryContext* MySQLParser::changeReplicationSourceConnectRetry() {
  ChangeReplicationSourceConnectRetryContext *_localctx = _tracker.createInstance<ChangeReplicationSourceConnectRetryContext>(_ctx, getState());
  enterRule(_localctx, 522, MySQLParser::RuleChangeReplicationSourceConnectRetry);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4563);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_CONNECT_RETRY_SYMBOL || _la == MySQLParser::SOURCE_CONNECT_RETRY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceRetryCountContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceRetryCountContext::ChangeReplicationSourceRetryCountContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceRetryCountContext::MASTER_RETRY_COUNT_SYMBOL() {
  return getToken(MySQLParser::MASTER_RETRY_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceRetryCountContext::SOURCE_RETRY_COUNT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_RETRY_COUNT_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceRetryCountContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceRetryCount;
}

void MySQLParser::ChangeReplicationSourceRetryCountContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceRetryCount(this);
}

void MySQLParser::ChangeReplicationSourceRetryCountContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceRetryCount(this);
}


std::any MySQLParser::ChangeReplicationSourceRetryCountContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceRetryCount(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceRetryCountContext* MySQLParser::changeReplicationSourceRetryCount() {
  ChangeReplicationSourceRetryCountContext *_localctx = _tracker.createInstance<ChangeReplicationSourceRetryCountContext>(_ctx, getState());
  enterRule(_localctx, 524, MySQLParser::RuleChangeReplicationSourceRetryCount);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4565);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_RETRY_COUNT_SYMBOL || _la == MySQLParser::SOURCE_RETRY_COUNT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceDelayContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceDelayContext::ChangeReplicationSourceDelayContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceDelayContext::MASTER_DELAY_SYMBOL() {
  return getToken(MySQLParser::MASTER_DELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceDelayContext::SOURCE_DELAY_SYMBOL() {
  return getToken(MySQLParser::SOURCE_DELAY_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceDelayContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceDelay;
}

void MySQLParser::ChangeReplicationSourceDelayContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceDelay(this);
}

void MySQLParser::ChangeReplicationSourceDelayContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceDelay(this);
}


std::any MySQLParser::ChangeReplicationSourceDelayContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceDelay(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceDelayContext* MySQLParser::changeReplicationSourceDelay() {
  ChangeReplicationSourceDelayContext *_localctx = _tracker.createInstance<ChangeReplicationSourceDelayContext>(_ctx, getState());
  enterRule(_localctx, 526, MySQLParser::RuleChangeReplicationSourceDelay);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4567);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_DELAY_SYMBOL || _la == MySQLParser::SOURCE_DELAY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLContext::ChangeReplicationSourceSSLContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLContext::MASTER_SSL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLContext::SOURCE_SSL_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSL;
}

void MySQLParser::ChangeReplicationSourceSSLContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSL(this);
}

void MySQLParser::ChangeReplicationSourceSSLContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSL(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSL(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLContext* MySQLParser::changeReplicationSourceSSL() {
  ChangeReplicationSourceSSLContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLContext>(_ctx, getState());
  enterRule(_localctx, 528, MySQLParser::RuleChangeReplicationSourceSSL);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4569);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_SYMBOL || _la == MySQLParser::SOURCE_SSL_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLCAContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLCAContext::ChangeReplicationSourceSSLCAContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCAContext::MASTER_SSL_CA_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCAContext::SOURCE_SSL_CA_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CA_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLCAContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLCA;
}

void MySQLParser::ChangeReplicationSourceSSLCAContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLCA(this);
}

void MySQLParser::ChangeReplicationSourceSSLCAContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLCA(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLCAContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLCA(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLCAContext* MySQLParser::changeReplicationSourceSSLCA() {
  ChangeReplicationSourceSSLCAContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLCAContext>(_ctx, getState());
  enterRule(_localctx, 530, MySQLParser::RuleChangeReplicationSourceSSLCA);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4571);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_CA_SYMBOL || _la == MySQLParser::SOURCE_SSL_CA_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLCApathContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLCApathContext::ChangeReplicationSourceSSLCApathContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCApathContext::MASTER_SSL_CAPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CAPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCApathContext::SOURCE_SSL_CAPATH_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CAPATH_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLCApathContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLCApath;
}

void MySQLParser::ChangeReplicationSourceSSLCApathContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLCApath(this);
}

void MySQLParser::ChangeReplicationSourceSSLCApathContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLCApath(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLCApathContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLCApath(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLCApathContext* MySQLParser::changeReplicationSourceSSLCApath() {
  ChangeReplicationSourceSSLCApathContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLCApathContext>(_ctx, getState());
  enterRule(_localctx, 532, MySQLParser::RuleChangeReplicationSourceSSLCApath);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4573);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_CAPATH_SYMBOL || _la == MySQLParser::SOURCE_SSL_CAPATH_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLCipherContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLCipherContext::ChangeReplicationSourceSSLCipherContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCipherContext::MASTER_SSL_CIPHER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCipherContext::SOURCE_SSL_CIPHER_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CIPHER_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLCipherContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLCipher;
}

void MySQLParser::ChangeReplicationSourceSSLCipherContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLCipher(this);
}

void MySQLParser::ChangeReplicationSourceSSLCipherContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLCipher(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLCipherContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLCipher(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLCipherContext* MySQLParser::changeReplicationSourceSSLCipher() {
  ChangeReplicationSourceSSLCipherContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLCipherContext>(_ctx, getState());
  enterRule(_localctx, 534, MySQLParser::RuleChangeReplicationSourceSSLCipher);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4575);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_CIPHER_SYMBOL || _la == MySQLParser::SOURCE_SSL_CIPHER_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLCLRContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLCLRContext::ChangeReplicationSourceSSLCLRContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCLRContext::MASTER_SSL_CRL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCLRContext::SOURCE_SSL_CRL_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CRL_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLCLRContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLCLR;
}

void MySQLParser::ChangeReplicationSourceSSLCLRContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLCLR(this);
}

void MySQLParser::ChangeReplicationSourceSSLCLRContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLCLR(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLCLRContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLCLR(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLCLRContext* MySQLParser::changeReplicationSourceSSLCLR() {
  ChangeReplicationSourceSSLCLRContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLCLRContext>(_ctx, getState());
  enterRule(_localctx, 536, MySQLParser::RuleChangeReplicationSourceSSLCLR);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4577);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_CRL_SYMBOL || _la == MySQLParser::SOURCE_SSL_CRL_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLCLRpathContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLCLRpathContext::ChangeReplicationSourceSSLCLRpathContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCLRpathContext::MASTER_SSL_CRLPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRLPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCLRpathContext::SOURCE_SSL_CRLPATH_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CRLPATH_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLCLRpathContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLCLRpath;
}

void MySQLParser::ChangeReplicationSourceSSLCLRpathContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLCLRpath(this);
}

void MySQLParser::ChangeReplicationSourceSSLCLRpathContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLCLRpath(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLCLRpathContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLCLRpath(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLCLRpathContext* MySQLParser::changeReplicationSourceSSLCLRpath() {
  ChangeReplicationSourceSSLCLRpathContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLCLRpathContext>(_ctx, getState());
  enterRule(_localctx, 538, MySQLParser::RuleChangeReplicationSourceSSLCLRpath);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4579);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_CRLPATH_SYMBOL || _la == MySQLParser::SOURCE_SSL_CRLPATH_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLKeyContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLKeyContext::ChangeReplicationSourceSSLKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLKeyContext::MASTER_SSL_KEY_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLKeyContext::SOURCE_SSL_KEY_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_KEY_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLKeyContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLKey;
}

void MySQLParser::ChangeReplicationSourceSSLKeyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLKey(this);
}

void MySQLParser::ChangeReplicationSourceSSLKeyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLKey(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLKey(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLKeyContext* MySQLParser::changeReplicationSourceSSLKey() {
  ChangeReplicationSourceSSLKeyContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLKeyContext>(_ctx, getState());
  enterRule(_localctx, 540, MySQLParser::RuleChangeReplicationSourceSSLKey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4581);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_KEY_SYMBOL || _la == MySQLParser::SOURCE_SSL_KEY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLVerifyServerCertContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::ChangeReplicationSourceSSLVerifyServerCertContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLVerifyServerCert;
}

void MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLVerifyServerCert(this);
}

void MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLVerifyServerCert(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLVerifyServerCert(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLVerifyServerCertContext* MySQLParser::changeReplicationSourceSSLVerifyServerCert() {
  ChangeReplicationSourceSSLVerifyServerCertContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLVerifyServerCertContext>(_ctx, getState());
  enterRule(_localctx, 542, MySQLParser::RuleChangeReplicationSourceSSLVerifyServerCert);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4583);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL || _la == MySQLParser::SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceTLSVersionContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceTLSVersionContext::ChangeReplicationSourceTLSVersionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceTLSVersionContext::MASTER_TLS_VERSION_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_VERSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceTLSVersionContext::SOURCE_TLS_VERSION_SYMBOL() {
  return getToken(MySQLParser::SOURCE_TLS_VERSION_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceTLSVersionContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceTLSVersion;
}

void MySQLParser::ChangeReplicationSourceTLSVersionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceTLSVersion(this);
}

void MySQLParser::ChangeReplicationSourceTLSVersionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceTLSVersion(this);
}


std::any MySQLParser::ChangeReplicationSourceTLSVersionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceTLSVersion(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceTLSVersionContext* MySQLParser::changeReplicationSourceTLSVersion() {
  ChangeReplicationSourceTLSVersionContext *_localctx = _tracker.createInstance<ChangeReplicationSourceTLSVersionContext>(_ctx, getState());
  enterRule(_localctx, 544, MySQLParser::RuleChangeReplicationSourceTLSVersion);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4585);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_TLS_VERSION_SYMBOL || _la == MySQLParser::SOURCE_TLS_VERSION_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceTLSCiphersuitesContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::ChangeReplicationSourceTLSCiphersuitesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::MASTER_TLS_CIPHERSUITES_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::SOURCE_TLS_CIPHERSUITES_SYMBOL() {
  return getToken(MySQLParser::SOURCE_TLS_CIPHERSUITES_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceTLSCiphersuites;
}

void MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceTLSCiphersuites(this);
}

void MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceTLSCiphersuites(this);
}


std::any MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceTLSCiphersuites(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceTLSCiphersuitesContext* MySQLParser::changeReplicationSourceTLSCiphersuites() {
  ChangeReplicationSourceTLSCiphersuitesContext *_localctx = _tracker.createInstance<ChangeReplicationSourceTLSCiphersuitesContext>(_ctx, getState());
  enterRule(_localctx, 546, MySQLParser::RuleChangeReplicationSourceTLSCiphersuites);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4587);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL

    || _la == MySQLParser::SOURCE_TLS_CIPHERSUITES_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceSSLCertContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceSSLCertContext::ChangeReplicationSourceSSLCertContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCertContext::MASTER_SSL_CERT_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceSSLCertContext::SOURCE_SSL_CERT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CERT_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceSSLCertContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceSSLCert;
}

void MySQLParser::ChangeReplicationSourceSSLCertContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceSSLCert(this);
}

void MySQLParser::ChangeReplicationSourceSSLCertContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceSSLCert(this);
}


std::any MySQLParser::ChangeReplicationSourceSSLCertContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceSSLCert(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceSSLCertContext* MySQLParser::changeReplicationSourceSSLCert() {
  ChangeReplicationSourceSSLCertContext *_localctx = _tracker.createInstance<ChangeReplicationSourceSSLCertContext>(_ctx, getState());
  enterRule(_localctx, 548, MySQLParser::RuleChangeReplicationSourceSSLCert);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4589);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_SSL_CERT_SYMBOL || _la == MySQLParser::SOURCE_SSL_CERT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourcePublicKeyContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourcePublicKeyContext::ChangeReplicationSourcePublicKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourcePublicKeyContext::MASTER_PUBLIC_KEY_PATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourcePublicKeyContext::SOURCE_PUBLIC_KEY_PATH_SYMBOL() {
  return getToken(MySQLParser::SOURCE_PUBLIC_KEY_PATH_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourcePublicKeyContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourcePublicKey;
}

void MySQLParser::ChangeReplicationSourcePublicKeyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourcePublicKey(this);
}

void MySQLParser::ChangeReplicationSourcePublicKeyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourcePublicKey(this);
}


std::any MySQLParser::ChangeReplicationSourcePublicKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourcePublicKey(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourcePublicKeyContext* MySQLParser::changeReplicationSourcePublicKey() {
  ChangeReplicationSourcePublicKeyContext *_localctx = _tracker.createInstance<ChangeReplicationSourcePublicKeyContext>(_ctx, getState());
  enterRule(_localctx, 550, MySQLParser::RuleChangeReplicationSourcePublicKey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4591);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL

    || _la == MySQLParser::SOURCE_PUBLIC_KEY_PATH_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceGetSourcePublicKeyContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::ChangeReplicationSourceGetSourcePublicKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::GET_MASTER_PUBLIC_KEY_SYMBOL() {
  return getToken(MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::GET_SOURCE_PUBLIC_KEY_SYMBOL() {
  return getToken(MySQLParser::GET_SOURCE_PUBLIC_KEY_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceGetSourcePublicKey;
}

void MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceGetSourcePublicKey(this);
}

void MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceGetSourcePublicKey(this);
}


std::any MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceGetSourcePublicKey(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceGetSourcePublicKeyContext* MySQLParser::changeReplicationSourceGetSourcePublicKey() {
  ChangeReplicationSourceGetSourcePublicKeyContext *_localctx = _tracker.createInstance<ChangeReplicationSourceGetSourcePublicKeyContext>(_ctx, getState());
  enterRule(_localctx, 552, MySQLParser::RuleChangeReplicationSourceGetSourcePublicKey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4593);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL

    || _la == MySQLParser::GET_SOURCE_PUBLIC_KEY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceHeartbeatPeriodContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::ChangeReplicationSourceHeartbeatPeriodContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::MASTER_HEARTBEAT_PERIOD_SYMBOL() {
  return getToken(MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::SOURCE_HEARTBEAT_PERIOD_SYMBOL() {
  return getToken(MySQLParser::SOURCE_HEARTBEAT_PERIOD_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceHeartbeatPeriod;
}

void MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceHeartbeatPeriod(this);
}

void MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceHeartbeatPeriod(this);
}


std::any MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceHeartbeatPeriod(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceHeartbeatPeriodContext* MySQLParser::changeReplicationSourceHeartbeatPeriod() {
  ChangeReplicationSourceHeartbeatPeriodContext *_localctx = _tracker.createInstance<ChangeReplicationSourceHeartbeatPeriodContext>(_ctx, getState());
  enterRule(_localctx, 554, MySQLParser::RuleChangeReplicationSourceHeartbeatPeriod);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4595);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL || _la == MySQLParser::SOURCE_HEARTBEAT_PERIOD_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceCompressionAlgorithmContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::ChangeReplicationSourceCompressionAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::MASTER_COMPRESSION_ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::SOURCE_COMPRESSION_ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::SOURCE_COMPRESSION_ALGORITHM_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceCompressionAlgorithm;
}

void MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceCompressionAlgorithm(this);
}

void MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceCompressionAlgorithm(this);
}


std::any MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceCompressionAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceCompressionAlgorithmContext* MySQLParser::changeReplicationSourceCompressionAlgorithm() {
  ChangeReplicationSourceCompressionAlgorithmContext *_localctx = _tracker.createInstance<ChangeReplicationSourceCompressionAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 556, MySQLParser::RuleChangeReplicationSourceCompressionAlgorithm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4597);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL

    || _la == MySQLParser::SOURCE_COMPRESSION_ALGORITHM_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationSourceZstdCompressionLevelContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::ChangeReplicationSourceZstdCompressionLevelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL() {
  return getToken(MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL() {
  return getToken(MySQLParser::SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL, 0);
}


size_t MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationSourceZstdCompressionLevel;
}

void MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationSourceZstdCompressionLevel(this);
}

void MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationSourceZstdCompressionLevel(this);
}


std::any MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationSourceZstdCompressionLevel(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationSourceZstdCompressionLevelContext* MySQLParser::changeReplicationSourceZstdCompressionLevel() {
  ChangeReplicationSourceZstdCompressionLevelContext *_localctx = _tracker.createInstance<ChangeReplicationSourceZstdCompressionLevelContext>(_ctx, getState());
  enterRule(_localctx, 558, MySQLParser::RuleChangeReplicationSourceZstdCompressionLevel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4599);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL

    || _la == MySQLParser::SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrivilegeCheckDefContext ------------------------------------------------------------------

MySQLParser::PrivilegeCheckDefContext::PrivilegeCheckDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserIdentifierOrTextContext* MySQLParser::PrivilegeCheckDefContext::userIdentifierOrText() {
  return getRuleContext<MySQLParser::UserIdentifierOrTextContext>(0);
}

tree::TerminalNode* MySQLParser::PrivilegeCheckDefContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}


size_t MySQLParser::PrivilegeCheckDefContext::getRuleIndex() const {
  return MySQLParser::RulePrivilegeCheckDef;
}

void MySQLParser::PrivilegeCheckDefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrivilegeCheckDef(this);
}

void MySQLParser::PrivilegeCheckDefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrivilegeCheckDef(this);
}


std::any MySQLParser::PrivilegeCheckDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPrivilegeCheckDef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PrivilegeCheckDefContext* MySQLParser::privilegeCheckDef() {
  PrivilegeCheckDefContext *_localctx = _tracker.createInstance<PrivilegeCheckDefContext>(_ctx, getState());
  enterRule(_localctx, 560, MySQLParser::RulePrivilegeCheckDef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4603);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 473, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4601);
      userIdentifierOrText();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4602);
      match(MySQLParser::NULL_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablePrimaryKeyCheckDefContext ------------------------------------------------------------------

MySQLParser::TablePrimaryKeyCheckDefContext::TablePrimaryKeyCheckDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TablePrimaryKeyCheckDefContext::STREAM_SYMBOL() {
  return getToken(MySQLParser::STREAM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TablePrimaryKeyCheckDefContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TablePrimaryKeyCheckDefContext::OFF_SYMBOL() {
  return getToken(MySQLParser::OFF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TablePrimaryKeyCheckDefContext::GENERATE_SYMBOL() {
  return getToken(MySQLParser::GENERATE_SYMBOL, 0);
}


size_t MySQLParser::TablePrimaryKeyCheckDefContext::getRuleIndex() const {
  return MySQLParser::RuleTablePrimaryKeyCheckDef;
}

void MySQLParser::TablePrimaryKeyCheckDefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTablePrimaryKeyCheckDef(this);
}

void MySQLParser::TablePrimaryKeyCheckDefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTablePrimaryKeyCheckDef(this);
}


std::any MySQLParser::TablePrimaryKeyCheckDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTablePrimaryKeyCheckDef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TablePrimaryKeyCheckDefContext* MySQLParser::tablePrimaryKeyCheckDef() {
  TablePrimaryKeyCheckDefContext *_localctx = _tracker.createInstance<TablePrimaryKeyCheckDefContext>(_ctx, getState());
  enterRule(_localctx, 562, MySQLParser::RuleTablePrimaryKeyCheckDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4605);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ON_SYMBOL || ((((_la - 768) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 768)) & ((1ULL << (MySQLParser::STREAM_SYMBOL - 768))
      | (1ULL << (MySQLParser::OFF_SYMBOL - 768))
      | (1ULL << (MySQLParser::GENERATE_SYMBOL - 768)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignGtidsToAnonymousTransactionsDefinitionContext ------------------------------------------------------------------

MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::AssignGtidsToAnonymousTransactionsDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::OFF_SYMBOL() {
  return getToken(MySQLParser::OFF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleAssignGtidsToAnonymousTransactionsDefinition;
}

void MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAssignGtidsToAnonymousTransactionsDefinition(this);
}

void MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAssignGtidsToAnonymousTransactionsDefinition(this);
}


std::any MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAssignGtidsToAnonymousTransactionsDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AssignGtidsToAnonymousTransactionsDefinitionContext* MySQLParser::assignGtidsToAnonymousTransactionsDefinition() {
  AssignGtidsToAnonymousTransactionsDefinitionContext *_localctx = _tracker.createInstance<AssignGtidsToAnonymousTransactionsDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 564, MySQLParser::RuleAssignGtidsToAnonymousTransactionsDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4610);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 474, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4607);
      match(MySQLParser::OFF_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4608);
      match(MySQLParser::LOCAL_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4609);
      textStringLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceTlsCiphersuitesDefContext ------------------------------------------------------------------

MySQLParser::SourceTlsCiphersuitesDefContext::SourceTlsCiphersuitesDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::SourceTlsCiphersuitesDefContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

tree::TerminalNode* MySQLParser::SourceTlsCiphersuitesDefContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}


size_t MySQLParser::SourceTlsCiphersuitesDefContext::getRuleIndex() const {
  return MySQLParser::RuleSourceTlsCiphersuitesDef;
}

void MySQLParser::SourceTlsCiphersuitesDefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceTlsCiphersuitesDef(this);
}

void MySQLParser::SourceTlsCiphersuitesDefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceTlsCiphersuitesDef(this);
}


std::any MySQLParser::SourceTlsCiphersuitesDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceTlsCiphersuitesDef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceTlsCiphersuitesDefContext* MySQLParser::sourceTlsCiphersuitesDef() {
  SourceTlsCiphersuitesDefContext *_localctx = _tracker.createInstance<SourceTlsCiphersuitesDefContext>(_ctx, getState());
  enterRule(_localctx, 566, MySQLParser::RuleSourceTlsCiphersuitesDef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4614);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 475, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4612);
      textStringNoLinebreak();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4613);
      match(MySQLParser::NULL_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceFileDefContext ------------------------------------------------------------------

MySQLParser::SourceFileDefContext::SourceFileDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SourceLogFileContext* MySQLParser::SourceFileDefContext::sourceLogFile() {
  return getRuleContext<MySQLParser::SourceLogFileContext>(0);
}

tree::TerminalNode* MySQLParser::SourceFileDefContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::SourceFileDefContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

MySQLParser::SourceLogPosContext* MySQLParser::SourceFileDefContext::sourceLogPos() {
  return getRuleContext<MySQLParser::SourceLogPosContext>(0);
}

MySQLParser::UlonglongNumberContext* MySQLParser::SourceFileDefContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

tree::TerminalNode* MySQLParser::SourceFileDefContext::RELAY_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceFileDefContext::RELAY_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_POS_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::SourceFileDefContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}


size_t MySQLParser::SourceFileDefContext::getRuleIndex() const {
  return MySQLParser::RuleSourceFileDef;
}

void MySQLParser::SourceFileDefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceFileDef(this);
}

void MySQLParser::SourceFileDefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceFileDef(this);
}


std::any MySQLParser::SourceFileDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceFileDef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceFileDefContext* MySQLParser::sourceFileDef() {
  SourceFileDefContext *_localctx = _tracker.createInstance<SourceFileDefContext>(_ctx, getState());
  enterRule(_localctx, 568, MySQLParser::RuleSourceFileDef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4630);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::MASTER_LOG_FILE_SYMBOL:
      case MySQLParser::SOURCE_LOG_FILE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4616);
        sourceLogFile();
        setState(4617);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4618);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_LOG_POS_SYMBOL:
      case MySQLParser::SOURCE_LOG_POS_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4620);
        sourceLogPos();
        setState(4621);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4622);
        ulonglongNumber();
        break;
      }

      case MySQLParser::RELAY_LOG_FILE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4624);
        match(MySQLParser::RELAY_LOG_FILE_SYMBOL);
        setState(4625);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4626);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::RELAY_LOG_POS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(4627);
        match(MySQLParser::RELAY_LOG_POS_SYMBOL);
        setState(4628);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4629);
        ulong_number();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceLogFileContext ------------------------------------------------------------------

MySQLParser::SourceLogFileContext::SourceLogFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SourceLogFileContext::MASTER_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceLogFileContext::SOURCE_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_LOG_FILE_SYMBOL, 0);
}


size_t MySQLParser::SourceLogFileContext::getRuleIndex() const {
  return MySQLParser::RuleSourceLogFile;
}

void MySQLParser::SourceLogFileContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceLogFile(this);
}

void MySQLParser::SourceLogFileContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceLogFile(this);
}


std::any MySQLParser::SourceLogFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceLogFile(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceLogFileContext* MySQLParser::sourceLogFile() {
  SourceLogFileContext *_localctx = _tracker.createInstance<SourceLogFileContext>(_ctx, getState());
  enterRule(_localctx, 570, MySQLParser::RuleSourceLogFile);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4632);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_LOG_FILE_SYMBOL || _la == MySQLParser::SOURCE_LOG_FILE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SourceLogPosContext ------------------------------------------------------------------

MySQLParser::SourceLogPosContext::SourceLogPosContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SourceLogPosContext::MASTER_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_POS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SourceLogPosContext::SOURCE_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::SOURCE_LOG_POS_SYMBOL, 0);
}


size_t MySQLParser::SourceLogPosContext::getRuleIndex() const {
  return MySQLParser::RuleSourceLogPos;
}

void MySQLParser::SourceLogPosContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSourceLogPos(this);
}

void MySQLParser::SourceLogPosContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSourceLogPos(this);
}


std::any MySQLParser::SourceLogPosContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSourceLogPos(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SourceLogPosContext* MySQLParser::sourceLogPos() {
  SourceLogPosContext *_localctx = _tracker.createInstance<SourceLogPosContext>(_ctx, getState());
  enterRule(_localctx, 572, MySQLParser::RuleSourceLogPos);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4634);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::MASTER_LOG_POS_SYMBOL || _la == MySQLParser::SOURCE_LOG_POS_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ServerIdListContext ------------------------------------------------------------------

MySQLParser::ServerIdListContext::ServerIdListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ServerIdListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ServerIdListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::Ulong_numberContext *> MySQLParser::ServerIdListContext::ulong_number() {
  return getRuleContexts<MySQLParser::Ulong_numberContext>();
}

MySQLParser::Ulong_numberContext* MySQLParser::ServerIdListContext::ulong_number(size_t i) {
  return getRuleContext<MySQLParser::Ulong_numberContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ServerIdListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ServerIdListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ServerIdListContext::getRuleIndex() const {
  return MySQLParser::RuleServerIdList;
}

void MySQLParser::ServerIdListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterServerIdList(this);
}

void MySQLParser::ServerIdListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitServerIdList(this);
}


std::any MySQLParser::ServerIdListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitServerIdList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ServerIdListContext* MySQLParser::serverIdList() {
  ServerIdListContext *_localctx = _tracker.createInstance<ServerIdListContext>(_ctx, getState());
  enterRule(_localctx, 574, MySQLParser::RuleServerIdList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4636);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(4645);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
      | (1ULL << MySQLParser::LONG_NUMBER)
      | (1ULL << MySQLParser::ULONGLONG_NUMBER)
      | (1ULL << MySQLParser::HEX_NUMBER)
      | (1ULL << MySQLParser::DECIMAL_NUMBER)
      | (1ULL << MySQLParser::FLOAT_NUMBER))) != 0)) {
      setState(4637);
      ulong_number();
      setState(4642);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(4638);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4639);
        ulong_number();
        setState(4644);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(4647);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationFilterContext ------------------------------------------------------------------

MySQLParser::ChangeReplicationFilterContext::ChangeReplicationFilterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChangeReplicationFilterContext::CHANGE_SYMBOL() {
  return getToken(MySQLParser::CHANGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationFilterContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationFilterContext::FILTER_SYMBOL() {
  return getToken(MySQLParser::FILTER_SYMBOL, 0);
}

std::vector<MySQLParser::FilterDefinitionContext *> MySQLParser::ChangeReplicationFilterContext::filterDefinition() {
  return getRuleContexts<MySQLParser::FilterDefinitionContext>();
}

MySQLParser::FilterDefinitionContext* MySQLParser::ChangeReplicationFilterContext::filterDefinition(size_t i) {
  return getRuleContext<MySQLParser::FilterDefinitionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ChangeReplicationFilterContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ChangeReplicationFilterContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

MySQLParser::ChannelContext* MySQLParser::ChangeReplicationFilterContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ChangeReplicationFilterContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplicationFilter;
}

void MySQLParser::ChangeReplicationFilterContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChangeReplicationFilter(this);
}

void MySQLParser::ChangeReplicationFilterContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChangeReplicationFilter(this);
}


std::any MySQLParser::ChangeReplicationFilterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChangeReplicationFilter(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChangeReplicationFilterContext* MySQLParser::changeReplicationFilter() {
  ChangeReplicationFilterContext *_localctx = _tracker.createInstance<ChangeReplicationFilterContext>(_ctx, getState());
  enterRule(_localctx, 576, MySQLParser::RuleChangeReplicationFilter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4649);
    match(MySQLParser::CHANGE_SYMBOL);
    setState(4650);
    match(MySQLParser::REPLICATION_SYMBOL);
    setState(4651);
    match(MySQLParser::FILTER_SYMBOL);
    setState(4652);
    filterDefinition();
    setState(4657);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 479, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4653);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4654);
        filterDefinition(); 
      }
      setState(4659);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 479, _ctx);
    }
    setState(4662);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 480, _ctx)) {
    case 1: {
      setState(4660);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4661);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterDefinitionContext ------------------------------------------------------------------

MySQLParser::FilterDefinitionContext::FilterDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_DO_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_DO_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::FilterDbListContext* MySQLParser::FilterDefinitionContext::filterDbList() {
  return getRuleContext<MySQLParser::FilterDbListContext>(0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_IGNORE_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_IGNORE_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_DO_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_DO_TABLE_SYMBOL, 0);
}

MySQLParser::FilterTableListContext* MySQLParser::FilterDefinitionContext::filterTableList() {
  return getRuleContext<MySQLParser::FilterTableListContext>(0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_IGNORE_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_WILD_DO_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL, 0);
}

MySQLParser::FilterStringListContext* MySQLParser::FilterDefinitionContext::filterStringList() {
  return getRuleContext<MySQLParser::FilterStringListContext>(0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_WILD_IGNORE_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FilterDefinitionContext::REPLICATE_REWRITE_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_REWRITE_DB_SYMBOL, 0);
}

MySQLParser::FilterDbPairListContext* MySQLParser::FilterDefinitionContext::filterDbPairList() {
  return getRuleContext<MySQLParser::FilterDbPairListContext>(0);
}


size_t MySQLParser::FilterDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleFilterDefinition;
}

void MySQLParser::FilterDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterDefinition(this);
}

void MySQLParser::FilterDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterDefinition(this);
}


std::any MySQLParser::FilterDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterDefinitionContext* MySQLParser::filterDefinition() {
  FilterDefinitionContext *_localctx = _tracker.createInstance<FilterDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 578, MySQLParser::RuleFilterDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4713);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REPLICATE_DO_DB_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4664);
        match(MySQLParser::REPLICATE_DO_DB_SYMBOL);
        setState(4665);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4666);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4668);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 481, _ctx)) {
        case 1: {
          setState(4667);
          filterDbList();
          break;
        }

        default:
          break;
        }
        setState(4670);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_IGNORE_DB_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4671);
        match(MySQLParser::REPLICATE_IGNORE_DB_SYMBOL);
        setState(4672);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4673);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4675);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 482, _ctx)) {
        case 1: {
          setState(4674);
          filterDbList();
          break;
        }

        default:
          break;
        }
        setState(4677);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_DO_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4678);
        match(MySQLParser::REPLICATE_DO_TABLE_SYMBOL);
        setState(4679);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4680);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4682);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 483, _ctx)) {
        case 1: {
          setState(4681);
          filterTableList();
          break;
        }

        default:
          break;
        }
        setState(4684);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(4685);
        match(MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL);
        setState(4686);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4687);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4689);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 484, _ctx)) {
        case 1: {
          setState(4688);
          filterTableList();
          break;
        }

        default:
          break;
        }
        setState(4691);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(4692);
        match(MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL);
        setState(4693);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4694);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4696);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 485, _ctx)) {
        case 1: {
          setState(4695);
          filterStringList();
          break;
        }

        default:
          break;
        }
        setState(4698);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(4699);
        match(MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL);
        setState(4700);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4701);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4703);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 486, _ctx)) {
        case 1: {
          setState(4702);
          filterStringList();
          break;
        }

        default:
          break;
        }
        setState(4705);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_REWRITE_DB_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(4706);
        match(MySQLParser::REPLICATE_REWRITE_DB_SYMBOL);
        setState(4707);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4708);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4710);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
          setState(4709);
          filterDbPairList();
        }
        setState(4712);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterDbListContext ------------------------------------------------------------------

MySQLParser::FilterDbListContext::FilterDbListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SchemaRefContext *> MySQLParser::FilterDbListContext::schemaRef() {
  return getRuleContexts<MySQLParser::SchemaRefContext>();
}

MySQLParser::SchemaRefContext* MySQLParser::FilterDbListContext::schemaRef(size_t i) {
  return getRuleContext<MySQLParser::SchemaRefContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::FilterDbListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::FilterDbListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::FilterDbListContext::getRuleIndex() const {
  return MySQLParser::RuleFilterDbList;
}

void MySQLParser::FilterDbListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterDbList(this);
}

void MySQLParser::FilterDbListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterDbList(this);
}


std::any MySQLParser::FilterDbListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterDbList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterDbListContext* MySQLParser::filterDbList() {
  FilterDbListContext *_localctx = _tracker.createInstance<FilterDbListContext>(_ctx, getState());
  enterRule(_localctx, 580, MySQLParser::RuleFilterDbList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4715);
    schemaRef();
    setState(4720);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4716);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4717);
      schemaRef();
      setState(4722);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterTableListContext ------------------------------------------------------------------

MySQLParser::FilterTableListContext::FilterTableListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::FilterTableRefContext *> MySQLParser::FilterTableListContext::filterTableRef() {
  return getRuleContexts<MySQLParser::FilterTableRefContext>();
}

MySQLParser::FilterTableRefContext* MySQLParser::FilterTableListContext::filterTableRef(size_t i) {
  return getRuleContext<MySQLParser::FilterTableRefContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::FilterTableListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::FilterTableListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::FilterTableListContext::getRuleIndex() const {
  return MySQLParser::RuleFilterTableList;
}

void MySQLParser::FilterTableListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterTableList(this);
}

void MySQLParser::FilterTableListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterTableList(this);
}


std::any MySQLParser::FilterTableListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterTableList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterTableListContext* MySQLParser::filterTableList() {
  FilterTableListContext *_localctx = _tracker.createInstance<FilterTableListContext>(_ctx, getState());
  enterRule(_localctx, 582, MySQLParser::RuleFilterTableList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4723);
    filterTableRef();
    setState(4728);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4724);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4725);
      filterTableRef();
      setState(4730);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterStringListContext ------------------------------------------------------------------

MySQLParser::FilterStringListContext::FilterStringListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::FilterWildDbTableStringContext *> MySQLParser::FilterStringListContext::filterWildDbTableString() {
  return getRuleContexts<MySQLParser::FilterWildDbTableStringContext>();
}

MySQLParser::FilterWildDbTableStringContext* MySQLParser::FilterStringListContext::filterWildDbTableString(size_t i) {
  return getRuleContext<MySQLParser::FilterWildDbTableStringContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::FilterStringListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::FilterStringListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::FilterStringListContext::getRuleIndex() const {
  return MySQLParser::RuleFilterStringList;
}

void MySQLParser::FilterStringListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterStringList(this);
}

void MySQLParser::FilterStringListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterStringList(this);
}


std::any MySQLParser::FilterStringListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterStringList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterStringListContext* MySQLParser::filterStringList() {
  FilterStringListContext *_localctx = _tracker.createInstance<FilterStringListContext>(_ctx, getState());
  enterRule(_localctx, 584, MySQLParser::RuleFilterStringList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4731);
    filterWildDbTableString();
    setState(4736);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4732);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4733);
      filterWildDbTableString();
      setState(4738);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterWildDbTableStringContext ------------------------------------------------------------------

MySQLParser::FilterWildDbTableStringContext::FilterWildDbTableStringContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::FilterWildDbTableStringContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}


size_t MySQLParser::FilterWildDbTableStringContext::getRuleIndex() const {
  return MySQLParser::RuleFilterWildDbTableString;
}

void MySQLParser::FilterWildDbTableStringContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterWildDbTableString(this);
}

void MySQLParser::FilterWildDbTableStringContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterWildDbTableString(this);
}


std::any MySQLParser::FilterWildDbTableStringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterWildDbTableString(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterWildDbTableStringContext* MySQLParser::filterWildDbTableString() {
  FilterWildDbTableStringContext *_localctx = _tracker.createInstance<FilterWildDbTableStringContext>(_ctx, getState());
  enterRule(_localctx, 586, MySQLParser::RuleFilterWildDbTableString);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4739);
    textStringNoLinebreak();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterDbPairListContext ------------------------------------------------------------------

MySQLParser::FilterDbPairListContext::FilterDbPairListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SchemaIdentifierPairContext *> MySQLParser::FilterDbPairListContext::schemaIdentifierPair() {
  return getRuleContexts<MySQLParser::SchemaIdentifierPairContext>();
}

MySQLParser::SchemaIdentifierPairContext* MySQLParser::FilterDbPairListContext::schemaIdentifierPair(size_t i) {
  return getRuleContext<MySQLParser::SchemaIdentifierPairContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::FilterDbPairListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::FilterDbPairListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::FilterDbPairListContext::getRuleIndex() const {
  return MySQLParser::RuleFilterDbPairList;
}

void MySQLParser::FilterDbPairListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterDbPairList(this);
}

void MySQLParser::FilterDbPairListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterDbPairList(this);
}


std::any MySQLParser::FilterDbPairListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterDbPairList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterDbPairListContext* MySQLParser::filterDbPairList() {
  FilterDbPairListContext *_localctx = _tracker.createInstance<FilterDbPairListContext>(_ctx, getState());
  enterRule(_localctx, 588, MySQLParser::RuleFilterDbPairList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4741);
    schemaIdentifierPair();
    setState(4746);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4742);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4743);
      schemaIdentifierPair();
      setState(4748);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StartReplicaStatementContext ------------------------------------------------------------------

MySQLParser::StartReplicaStatementContext::StartReplicaStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StartReplicaStatementContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::StartReplicaStatementContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}

MySQLParser::ReplicaThreadOptionsContext* MySQLParser::StartReplicaStatementContext::replicaThreadOptions() {
  return getRuleContext<MySQLParser::ReplicaThreadOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::StartReplicaStatementContext::UNTIL_SYMBOL() {
  return getToken(MySQLParser::UNTIL_SYMBOL, 0);
}

MySQLParser::ReplicaUntilContext* MySQLParser::StartReplicaStatementContext::replicaUntil() {
  return getRuleContext<MySQLParser::ReplicaUntilContext>(0);
}

MySQLParser::UserOptionContext* MySQLParser::StartReplicaStatementContext::userOption() {
  return getRuleContext<MySQLParser::UserOptionContext>(0);
}

MySQLParser::PasswordOptionContext* MySQLParser::StartReplicaStatementContext::passwordOption() {
  return getRuleContext<MySQLParser::PasswordOptionContext>(0);
}

MySQLParser::DefaultAuthOptionContext* MySQLParser::StartReplicaStatementContext::defaultAuthOption() {
  return getRuleContext<MySQLParser::DefaultAuthOptionContext>(0);
}

MySQLParser::PluginDirOptionContext* MySQLParser::StartReplicaStatementContext::pluginDirOption() {
  return getRuleContext<MySQLParser::PluginDirOptionContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::StartReplicaStatementContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::StartReplicaStatementContext::getRuleIndex() const {
  return MySQLParser::RuleStartReplicaStatement;
}

void MySQLParser::StartReplicaStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStartReplicaStatement(this);
}

void MySQLParser::StartReplicaStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStartReplicaStatement(this);
}


std::any MySQLParser::StartReplicaStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStartReplicaStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StartReplicaStatementContext* MySQLParser::startReplicaStatement() {
  StartReplicaStatementContext *_localctx = _tracker.createInstance<StartReplicaStatementContext>(_ctx, getState());
  enterRule(_localctx, 590, MySQLParser::RuleStartReplicaStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4749);
    match(MySQLParser::START_SYMBOL);
    setState(4750);
    replica();
    setState(4752);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 493, _ctx)) {
    case 1: {
      setState(4751);
      replicaThreadOptions();
      break;
    }

    default:
      break;
    }
    setState(4756);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 494, _ctx)) {
    case 1: {
      setState(4754);
      match(MySQLParser::UNTIL_SYMBOL);
      setState(4755);
      replicaUntil();
      break;
    }

    default:
      break;
    }
    setState(4759);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 495, _ctx)) {
    case 1: {
      setState(4758);
      userOption();
      break;
    }

    default:
      break;
    }
    setState(4762);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 496, _ctx)) {
    case 1: {
      setState(4761);
      passwordOption();
      break;
    }

    default:
      break;
    }
    setState(4765);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 497, _ctx)) {
    case 1: {
      setState(4764);
      defaultAuthOption();
      break;
    }

    default:
      break;
    }
    setState(4768);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 498, _ctx)) {
    case 1: {
      setState(4767);
      pluginDirOption();
      break;
    }

    default:
      break;
    }
    setState(4771);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 499, _ctx)) {
    case 1: {
      setState(4770);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StopReplicaStatementContext ------------------------------------------------------------------

MySQLParser::StopReplicaStatementContext::StopReplicaStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StopReplicaStatementContext::STOP_SYMBOL() {
  return getToken(MySQLParser::STOP_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::StopReplicaStatementContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}

MySQLParser::ReplicaThreadOptionsContext* MySQLParser::StopReplicaStatementContext::replicaThreadOptions() {
  return getRuleContext<MySQLParser::ReplicaThreadOptionsContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::StopReplicaStatementContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::StopReplicaStatementContext::getRuleIndex() const {
  return MySQLParser::RuleStopReplicaStatement;
}

void MySQLParser::StopReplicaStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStopReplicaStatement(this);
}

void MySQLParser::StopReplicaStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStopReplicaStatement(this);
}


std::any MySQLParser::StopReplicaStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStopReplicaStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StopReplicaStatementContext* MySQLParser::stopReplicaStatement() {
  StopReplicaStatementContext *_localctx = _tracker.createInstance<StopReplicaStatementContext>(_ctx, getState());
  enterRule(_localctx, 592, MySQLParser::RuleStopReplicaStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4773);
    match(MySQLParser::STOP_SYMBOL);
    setState(4774);
    replica();
    setState(4776);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 500, _ctx)) {
    case 1: {
      setState(4775);
      replicaThreadOptions();
      break;
    }

    default:
      break;
    }
    setState(4779);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 501, _ctx)) {
    case 1: {
      setState(4778);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplicaUntilContext ------------------------------------------------------------------

MySQLParser::ReplicaUntilContext::ReplicaUntilContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SourceFileDefContext *> MySQLParser::ReplicaUntilContext::sourceFileDef() {
  return getRuleContexts<MySQLParser::SourceFileDefContext>();
}

MySQLParser::SourceFileDefContext* MySQLParser::ReplicaUntilContext::sourceFileDef(size_t i) {
  return getRuleContext<MySQLParser::SourceFileDefContext>(i);
}

tree::TerminalNode* MySQLParser::ReplicaUntilContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringContext* MySQLParser::ReplicaUntilContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::ReplicaUntilContext::SQL_AFTER_MTS_GAPS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicaUntilContext::SQL_BEFORE_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_BEFORE_GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicaUntilContext::SQL_AFTER_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_GTIDS_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ReplicaUntilContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ReplicaUntilContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ReplicaUntilContext::getRuleIndex() const {
  return MySQLParser::RuleReplicaUntil;
}

void MySQLParser::ReplicaUntilContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplicaUntil(this);
}

void MySQLParser::ReplicaUntilContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplicaUntil(this);
}


std::any MySQLParser::ReplicaUntilContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplicaUntil(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplicaUntilContext* MySQLParser::replicaUntil() {
  ReplicaUntilContext *_localctx = _tracker.createInstance<ReplicaUntilContext>(_ctx, getState());
  enterRule(_localctx, 594, MySQLParser::RuleReplicaUntil);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4786);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::MASTER_LOG_FILE_SYMBOL:
      case MySQLParser::MASTER_LOG_POS_SYMBOL:
      case MySQLParser::RELAY_LOG_FILE_SYMBOL:
      case MySQLParser::RELAY_LOG_POS_SYMBOL:
      case MySQLParser::SOURCE_LOG_FILE_SYMBOL:
      case MySQLParser::SOURCE_LOG_POS_SYMBOL: {
        setState(4781);
        sourceFileDef();
        break;
      }

      case MySQLParser::SQL_AFTER_GTIDS_SYMBOL:
      case MySQLParser::SQL_BEFORE_GTIDS_SYMBOL: {
        setState(4782);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::SQL_AFTER_GTIDS_SYMBOL

        || _la == MySQLParser::SQL_BEFORE_GTIDS_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(4783);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4784);
        textString();
        break;
      }

      case MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL: {
        setState(4785);
        match(MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(4792);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 503, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4788);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4789);
        sourceFileDef(); 
      }
      setState(4794);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 503, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserOptionContext ------------------------------------------------------------------

MySQLParser::UserOptionContext::UserOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UserOptionContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringContext* MySQLParser::UserOptionContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::UserOptionContext::getRuleIndex() const {
  return MySQLParser::RuleUserOption;
}

void MySQLParser::UserOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserOption(this);
}

void MySQLParser::UserOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserOption(this);
}


std::any MySQLParser::UserOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserOptionContext* MySQLParser::userOption() {
  UserOptionContext *_localctx = _tracker.createInstance<UserOptionContext>(_ctx, getState());
  enterRule(_localctx, 596, MySQLParser::RuleUserOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4795);
    match(MySQLParser::USER_SYMBOL);
    setState(4796);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4797);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PasswordOptionContext ------------------------------------------------------------------

MySQLParser::PasswordOptionContext::PasswordOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PasswordOptionContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PasswordOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringContext* MySQLParser::PasswordOptionContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::PasswordOptionContext::getRuleIndex() const {
  return MySQLParser::RulePasswordOption;
}

void MySQLParser::PasswordOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPasswordOption(this);
}

void MySQLParser::PasswordOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPasswordOption(this);
}


std::any MySQLParser::PasswordOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPasswordOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PasswordOptionContext* MySQLParser::passwordOption() {
  PasswordOptionContext *_localctx = _tracker.createInstance<PasswordOptionContext>(_ctx, getState());
  enterRule(_localctx, 598, MySQLParser::RulePasswordOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4799);
    match(MySQLParser::PASSWORD_SYMBOL);
    setState(4800);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4801);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultAuthOptionContext ------------------------------------------------------------------

MySQLParser::DefaultAuthOptionContext::DefaultAuthOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DefaultAuthOptionContext::DEFAULT_AUTH_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_AUTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DefaultAuthOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringContext* MySQLParser::DefaultAuthOptionContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::DefaultAuthOptionContext::getRuleIndex() const {
  return MySQLParser::RuleDefaultAuthOption;
}

void MySQLParser::DefaultAuthOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDefaultAuthOption(this);
}

void MySQLParser::DefaultAuthOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDefaultAuthOption(this);
}


std::any MySQLParser::DefaultAuthOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDefaultAuthOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DefaultAuthOptionContext* MySQLParser::defaultAuthOption() {
  DefaultAuthOptionContext *_localctx = _tracker.createInstance<DefaultAuthOptionContext>(_ctx, getState());
  enterRule(_localctx, 600, MySQLParser::RuleDefaultAuthOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4803);
    match(MySQLParser::DEFAULT_AUTH_SYMBOL);
    setState(4804);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4805);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PluginDirOptionContext ------------------------------------------------------------------

MySQLParser::PluginDirOptionContext::PluginDirOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PluginDirOptionContext::PLUGIN_DIR_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_DIR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PluginDirOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringContext* MySQLParser::PluginDirOptionContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::PluginDirOptionContext::getRuleIndex() const {
  return MySQLParser::RulePluginDirOption;
}

void MySQLParser::PluginDirOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPluginDirOption(this);
}

void MySQLParser::PluginDirOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPluginDirOption(this);
}


std::any MySQLParser::PluginDirOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPluginDirOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PluginDirOptionContext* MySQLParser::pluginDirOption() {
  PluginDirOptionContext *_localctx = _tracker.createInstance<PluginDirOptionContext>(_ctx, getState());
  enterRule(_localctx, 602, MySQLParser::RulePluginDirOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4807);
    match(MySQLParser::PLUGIN_DIR_SYMBOL);
    setState(4808);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4809);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplicaThreadOptionsContext ------------------------------------------------------------------

MySQLParser::ReplicaThreadOptionsContext::ReplicaThreadOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::ReplicaThreadOptionContext *> MySQLParser::ReplicaThreadOptionsContext::replicaThreadOption() {
  return getRuleContexts<MySQLParser::ReplicaThreadOptionContext>();
}

MySQLParser::ReplicaThreadOptionContext* MySQLParser::ReplicaThreadOptionsContext::replicaThreadOption(size_t i) {
  return getRuleContext<MySQLParser::ReplicaThreadOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ReplicaThreadOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ReplicaThreadOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ReplicaThreadOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleReplicaThreadOptions;
}

void MySQLParser::ReplicaThreadOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplicaThreadOptions(this);
}

void MySQLParser::ReplicaThreadOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplicaThreadOptions(this);
}


std::any MySQLParser::ReplicaThreadOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplicaThreadOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplicaThreadOptionsContext* MySQLParser::replicaThreadOptions() {
  ReplicaThreadOptionsContext *_localctx = _tracker.createInstance<ReplicaThreadOptionsContext>(_ctx, getState());
  enterRule(_localctx, 604, MySQLParser::RuleReplicaThreadOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4811);
    replicaThreadOption();
    setState(4816);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 504, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4812);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4813);
        replicaThreadOption(); 
      }
      setState(4818);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 504, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplicaThreadOptionContext ------------------------------------------------------------------

MySQLParser::ReplicaThreadOptionContext::ReplicaThreadOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReplicaThreadOptionContext::SQL_THREAD_SYMBOL() {
  return getToken(MySQLParser::SQL_THREAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicaThreadOptionContext::RELAY_THREAD_SYMBOL() {
  return getToken(MySQLParser::RELAY_THREAD_SYMBOL, 0);
}


size_t MySQLParser::ReplicaThreadOptionContext::getRuleIndex() const {
  return MySQLParser::RuleReplicaThreadOption;
}

void MySQLParser::ReplicaThreadOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplicaThreadOption(this);
}

void MySQLParser::ReplicaThreadOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplicaThreadOption(this);
}


std::any MySQLParser::ReplicaThreadOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplicaThreadOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplicaThreadOptionContext* MySQLParser::replicaThreadOption() {
  ReplicaThreadOptionContext *_localctx = _tracker.createInstance<ReplicaThreadOptionContext>(_ctx, getState());
  enterRule(_localctx, 606, MySQLParser::RuleReplicaThreadOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4819);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::RELAY_THREAD_SYMBOL || _la == MySQLParser::SQL_THREAD_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupReplicationContext ------------------------------------------------------------------

MySQLParser::GroupReplicationContext::GroupReplicationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GroupReplicationContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupReplicationContext::GROUP_REPLICATION_SYMBOL() {
  return getToken(MySQLParser::GROUP_REPLICATION_SYMBOL, 0);
}

MySQLParser::GroupReplicationStartOptionsContext* MySQLParser::GroupReplicationContext::groupReplicationStartOptions() {
  return getRuleContext<MySQLParser::GroupReplicationStartOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::GroupReplicationContext::STOP_SYMBOL() {
  return getToken(MySQLParser::STOP_SYMBOL, 0);
}


size_t MySQLParser::GroupReplicationContext::getRuleIndex() const {
  return MySQLParser::RuleGroupReplication;
}

void MySQLParser::GroupReplicationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupReplication(this);
}

void MySQLParser::GroupReplicationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupReplication(this);
}


std::any MySQLParser::GroupReplicationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupReplication(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupReplicationContext* MySQLParser::groupReplication() {
  GroupReplicationContext *_localctx = _tracker.createInstance<GroupReplicationContext>(_ctx, getState());
  enterRule(_localctx, 608, MySQLParser::RuleGroupReplication);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4829);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::START_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4821);
        match(MySQLParser::START_SYMBOL);
        setState(4822);
        match(MySQLParser::GROUP_REPLICATION_SYMBOL);
        setState(4825);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 505, _ctx)) {
        case 1: {
          setState(4823);

          if (!(serverVersion >= 80021)) throw FailedPredicateException(this, "serverVersion >= 80021");
          setState(4824);
          groupReplicationStartOptions();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::STOP_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4827);
        match(MySQLParser::STOP_SYMBOL);
        setState(4828);
        match(MySQLParser::GROUP_REPLICATION_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupReplicationStartOptionsContext ------------------------------------------------------------------

MySQLParser::GroupReplicationStartOptionsContext::GroupReplicationStartOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::GroupReplicationStartOptionContext *> MySQLParser::GroupReplicationStartOptionsContext::groupReplicationStartOption() {
  return getRuleContexts<MySQLParser::GroupReplicationStartOptionContext>();
}

MySQLParser::GroupReplicationStartOptionContext* MySQLParser::GroupReplicationStartOptionsContext::groupReplicationStartOption(size_t i) {
  return getRuleContext<MySQLParser::GroupReplicationStartOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::GroupReplicationStartOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::GroupReplicationStartOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::GroupReplicationStartOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleGroupReplicationStartOptions;
}

void MySQLParser::GroupReplicationStartOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupReplicationStartOptions(this);
}

void MySQLParser::GroupReplicationStartOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupReplicationStartOptions(this);
}


std::any MySQLParser::GroupReplicationStartOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupReplicationStartOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupReplicationStartOptionsContext* MySQLParser::groupReplicationStartOptions() {
  GroupReplicationStartOptionsContext *_localctx = _tracker.createInstance<GroupReplicationStartOptionsContext>(_ctx, getState());
  enterRule(_localctx, 610, MySQLParser::RuleGroupReplicationStartOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4831);
    groupReplicationStartOption();
    setState(4836);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4832);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4833);
      groupReplicationStartOption();
      setState(4838);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupReplicationStartOptionContext ------------------------------------------------------------------

MySQLParser::GroupReplicationStartOptionContext::GroupReplicationStartOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::GroupReplicationUserContext* MySQLParser::GroupReplicationStartOptionContext::groupReplicationUser() {
  return getRuleContext<MySQLParser::GroupReplicationUserContext>(0);
}

MySQLParser::GroupReplicationPasswordContext* MySQLParser::GroupReplicationStartOptionContext::groupReplicationPassword() {
  return getRuleContext<MySQLParser::GroupReplicationPasswordContext>(0);
}

MySQLParser::GroupReplicationPluginAuthContext* MySQLParser::GroupReplicationStartOptionContext::groupReplicationPluginAuth() {
  return getRuleContext<MySQLParser::GroupReplicationPluginAuthContext>(0);
}


size_t MySQLParser::GroupReplicationStartOptionContext::getRuleIndex() const {
  return MySQLParser::RuleGroupReplicationStartOption;
}

void MySQLParser::GroupReplicationStartOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupReplicationStartOption(this);
}

void MySQLParser::GroupReplicationStartOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupReplicationStartOption(this);
}


std::any MySQLParser::GroupReplicationStartOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupReplicationStartOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupReplicationStartOptionContext* MySQLParser::groupReplicationStartOption() {
  GroupReplicationStartOptionContext *_localctx = _tracker.createInstance<GroupReplicationStartOptionContext>(_ctx, getState());
  enterRule(_localctx, 612, MySQLParser::RuleGroupReplicationStartOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4842);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::USER_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4839);
        groupReplicationUser();
        break;
      }

      case MySQLParser::PASSWORD_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4840);
        groupReplicationPassword();
        break;
      }

      case MySQLParser::DEFAULT_AUTH_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4841);
        groupReplicationPluginAuth();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupReplicationUserContext ------------------------------------------------------------------

MySQLParser::GroupReplicationUserContext::GroupReplicationUserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GroupReplicationUserContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupReplicationUserContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::GroupReplicationUserContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}


size_t MySQLParser::GroupReplicationUserContext::getRuleIndex() const {
  return MySQLParser::RuleGroupReplicationUser;
}

void MySQLParser::GroupReplicationUserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupReplicationUser(this);
}

void MySQLParser::GroupReplicationUserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupReplicationUser(this);
}


std::any MySQLParser::GroupReplicationUserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupReplicationUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupReplicationUserContext* MySQLParser::groupReplicationUser() {
  GroupReplicationUserContext *_localctx = _tracker.createInstance<GroupReplicationUserContext>(_ctx, getState());
  enterRule(_localctx, 614, MySQLParser::RuleGroupReplicationUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4844);
    match(MySQLParser::USER_SYMBOL);
    setState(4845);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4846);
    textStringNoLinebreak();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupReplicationPasswordContext ------------------------------------------------------------------

MySQLParser::GroupReplicationPasswordContext::GroupReplicationPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GroupReplicationPasswordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupReplicationPasswordContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::GroupReplicationPasswordContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}


size_t MySQLParser::GroupReplicationPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleGroupReplicationPassword;
}

void MySQLParser::GroupReplicationPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupReplicationPassword(this);
}

void MySQLParser::GroupReplicationPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupReplicationPassword(this);
}


std::any MySQLParser::GroupReplicationPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupReplicationPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupReplicationPasswordContext* MySQLParser::groupReplicationPassword() {
  GroupReplicationPasswordContext *_localctx = _tracker.createInstance<GroupReplicationPasswordContext>(_ctx, getState());
  enterRule(_localctx, 616, MySQLParser::RuleGroupReplicationPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4848);
    match(MySQLParser::PASSWORD_SYMBOL);
    setState(4849);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4850);
    textStringNoLinebreak();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupReplicationPluginAuthContext ------------------------------------------------------------------

MySQLParser::GroupReplicationPluginAuthContext::GroupReplicationPluginAuthContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GroupReplicationPluginAuthContext::DEFAULT_AUTH_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_AUTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupReplicationPluginAuthContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::GroupReplicationPluginAuthContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}


size_t MySQLParser::GroupReplicationPluginAuthContext::getRuleIndex() const {
  return MySQLParser::RuleGroupReplicationPluginAuth;
}

void MySQLParser::GroupReplicationPluginAuthContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupReplicationPluginAuth(this);
}

void MySQLParser::GroupReplicationPluginAuthContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupReplicationPluginAuth(this);
}


std::any MySQLParser::GroupReplicationPluginAuthContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupReplicationPluginAuth(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupReplicationPluginAuthContext* MySQLParser::groupReplicationPluginAuth() {
  GroupReplicationPluginAuthContext *_localctx = _tracker.createInstance<GroupReplicationPluginAuthContext>(_ctx, getState());
  enterRule(_localctx, 618, MySQLParser::RuleGroupReplicationPluginAuth);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4852);
    match(MySQLParser::DEFAULT_AUTH_SYMBOL);
    setState(4853);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(4854);
    textStringNoLinebreak();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplicaContext ------------------------------------------------------------------

MySQLParser::ReplicaContext::ReplicaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReplicaContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicaContext::REPLICA_SYMBOL() {
  return getToken(MySQLParser::REPLICA_SYMBOL, 0);
}


size_t MySQLParser::ReplicaContext::getRuleIndex() const {
  return MySQLParser::RuleReplica;
}

void MySQLParser::ReplicaContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplica(this);
}

void MySQLParser::ReplicaContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplica(this);
}


std::any MySQLParser::ReplicaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplica(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplicaContext* MySQLParser::replica() {
  ReplicaContext *_localctx = _tracker.createInstance<ReplicaContext>(_ctx, getState());
  enterRule(_localctx, 620, MySQLParser::RuleReplica);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4859);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 509, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4856);
      match(MySQLParser::SLAVE_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4857);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(4858);
      match(MySQLParser::REPLICA_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PreparedStatementContext ------------------------------------------------------------------

MySQLParser::PreparedStatementContext::PreparedStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::PreparedStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::PreparedStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PreparedStatementContext::PREPARE_SYMBOL() {
  return getToken(MySQLParser::PREPARE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::PreparedStatementContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::UserVariableContext* MySQLParser::PreparedStatementContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

MySQLParser::ExecuteStatementContext* MySQLParser::PreparedStatementContext::executeStatement() {
  return getRuleContext<MySQLParser::ExecuteStatementContext>(0);
}

tree::TerminalNode* MySQLParser::PreparedStatementContext::DEALLOCATE_SYMBOL() {
  return getToken(MySQLParser::DEALLOCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PreparedStatementContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}


size_t MySQLParser::PreparedStatementContext::getRuleIndex() const {
  return MySQLParser::RulePreparedStatement;
}

void MySQLParser::PreparedStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPreparedStatement(this);
}

void MySQLParser::PreparedStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPreparedStatement(this);
}


std::any MySQLParser::PreparedStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPreparedStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PreparedStatementContext* MySQLParser::preparedStatement() {
  PreparedStatementContext *_localctx = _tracker.createInstance<PreparedStatementContext>(_ctx, getState());
  enterRule(_localctx, 622, MySQLParser::RulePreparedStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4872);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PREPARE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4861);
        antlrcpp::downCast<PreparedStatementContext *>(_localctx)->type = match(MySQLParser::PREPARE_SYMBOL);
        setState(4862);
        identifier();
        setState(4863);
        match(MySQLParser::FROM_SYMBOL);
        setState(4866);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 510, _ctx)) {
        case 1: {
          setState(4864);
          textLiteral();
          break;
        }

        case 2: {
          setState(4865);
          userVariable();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::EXECUTE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4868);
        executeStatement();
        break;
      }

      case MySQLParser::DEALLOCATE_SYMBOL:
      case MySQLParser::DROP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4869);
        antlrcpp::downCast<PreparedStatementContext *>(_localctx)->type = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::DEALLOCATE_SYMBOL

        || _la == MySQLParser::DROP_SYMBOL)) {
          antlrcpp::downCast<PreparedStatementContext *>(_localctx)->type = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(4870);
        match(MySQLParser::PREPARE_SYMBOL);
        setState(4871);
        identifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExecuteStatementContext ------------------------------------------------------------------

MySQLParser::ExecuteStatementContext::ExecuteStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExecuteStatementContext::EXECUTE_SYMBOL() {
  return getToken(MySQLParser::EXECUTE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::ExecuteStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::ExecuteStatementContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::ExecuteVarListContext* MySQLParser::ExecuteStatementContext::executeVarList() {
  return getRuleContext<MySQLParser::ExecuteVarListContext>(0);
}


size_t MySQLParser::ExecuteStatementContext::getRuleIndex() const {
  return MySQLParser::RuleExecuteStatement;
}

void MySQLParser::ExecuteStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExecuteStatement(this);
}

void MySQLParser::ExecuteStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExecuteStatement(this);
}


std::any MySQLParser::ExecuteStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExecuteStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExecuteStatementContext* MySQLParser::executeStatement() {
  ExecuteStatementContext *_localctx = _tracker.createInstance<ExecuteStatementContext>(_ctx, getState());
  enterRule(_localctx, 624, MySQLParser::RuleExecuteStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4874);
    match(MySQLParser::EXECUTE_SYMBOL);
    setState(4875);
    identifier();
    setState(4878);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::USING_SYMBOL) {
      setState(4876);
      match(MySQLParser::USING_SYMBOL);
      setState(4877);
      executeVarList();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExecuteVarListContext ------------------------------------------------------------------

MySQLParser::ExecuteVarListContext::ExecuteVarListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::UserVariableContext *> MySQLParser::ExecuteVarListContext::userVariable() {
  return getRuleContexts<MySQLParser::UserVariableContext>();
}

MySQLParser::UserVariableContext* MySQLParser::ExecuteVarListContext::userVariable(size_t i) {
  return getRuleContext<MySQLParser::UserVariableContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ExecuteVarListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ExecuteVarListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ExecuteVarListContext::getRuleIndex() const {
  return MySQLParser::RuleExecuteVarList;
}

void MySQLParser::ExecuteVarListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExecuteVarList(this);
}

void MySQLParser::ExecuteVarListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExecuteVarList(this);
}


std::any MySQLParser::ExecuteVarListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExecuteVarList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExecuteVarListContext* MySQLParser::executeVarList() {
  ExecuteVarListContext *_localctx = _tracker.createInstance<ExecuteVarListContext>(_ctx, getState());
  enterRule(_localctx, 626, MySQLParser::RuleExecuteVarList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4880);
    userVariable();
    setState(4885);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4881);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4882);
      userVariable();
      setState(4887);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CloneStatementContext ------------------------------------------------------------------

MySQLParser::CloneStatementContext::CloneStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CloneStatementContext::CLONE_SYMBOL() {
  return getToken(MySQLParser::CLONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::CloneStatementContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::REMOTE_SYMBOL() {
  return getToken(MySQLParser::REMOTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::INSTANCE_SYMBOL() {
  return getToken(MySQLParser::INSTANCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::CloneStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::COLON_SYMBOL() {
  return getToken(MySQLParser::COLON_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::CloneStatementContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::EqualContext* MySQLParser::CloneStatementContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CloneStatementContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

MySQLParser::DataDirSSLContext* MySQLParser::CloneStatementContext::dataDirSSL() {
  return getRuleContext<MySQLParser::DataDirSSLContext>(0);
}


size_t MySQLParser::CloneStatementContext::getRuleIndex() const {
  return MySQLParser::RuleCloneStatement;
}

void MySQLParser::CloneStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCloneStatement(this);
}

void MySQLParser::CloneStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCloneStatement(this);
}


std::any MySQLParser::CloneStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCloneStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CloneStatementContext* MySQLParser::cloneStatement() {
  CloneStatementContext *_localctx = _tracker.createInstance<CloneStatementContext>(_ctx, getState());
  enterRule(_localctx, 628, MySQLParser::RuleCloneStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4888);
    match(MySQLParser::CLONE_SYMBOL);
    setState(4913);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 517, _ctx)) {
    case 1: {
      setState(4889);
      match(MySQLParser::LOCAL_SYMBOL);
      setState(4890);
      match(MySQLParser::DATA_SYMBOL);
      setState(4891);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(4893);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 514, _ctx)) {
      case 1: {
        setState(4892);
        equal();
        break;
      }

      default:
        break;
      }
      setState(4895);
      textStringLiteral();
      break;
    }

    case 2: {
      setState(4896);
      match(MySQLParser::REMOTE_SYMBOL);
      setState(4899);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(4897);
        match(MySQLParser::FOR_SYMBOL);
        setState(4898);
        match(MySQLParser::REPLICATION_SYMBOL);
      }
      break;
    }

    case 3: {
      setState(4901);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(4902);
      match(MySQLParser::INSTANCE_SYMBOL);
      setState(4903);
      match(MySQLParser::FROM_SYMBOL);
      setState(4904);
      user();
      setState(4905);
      match(MySQLParser::COLON_SYMBOL);
      setState(4906);
      ulong_number();
      setState(4907);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(4908);
      match(MySQLParser::BY_SYMBOL);
      setState(4909);
      textStringLiteral();
      setState(4911);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DATA_SYMBOL || _la == MySQLParser::REQUIRE_SYMBOL) {
        setState(4910);
        dataDirSSL();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DataDirSSLContext ------------------------------------------------------------------

MySQLParser::DataDirSSLContext::DataDirSSLContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SslContext* MySQLParser::DataDirSSLContext::ssl() {
  return getRuleContext<MySQLParser::SslContext>(0);
}

tree::TerminalNode* MySQLParser::DataDirSSLContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataDirSSLContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::DataDirSSLContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

MySQLParser::EqualContext* MySQLParser::DataDirSSLContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}


size_t MySQLParser::DataDirSSLContext::getRuleIndex() const {
  return MySQLParser::RuleDataDirSSL;
}

void MySQLParser::DataDirSSLContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDataDirSSL(this);
}

void MySQLParser::DataDirSSLContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDataDirSSL(this);
}


std::any MySQLParser::DataDirSSLContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDataDirSSL(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DataDirSSLContext* MySQLParser::dataDirSSL() {
  DataDirSSLContext *_localctx = _tracker.createInstance<DataDirSSLContext>(_ctx, getState());
  enterRule(_localctx, 630, MySQLParser::RuleDataDirSSL);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4925);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REQUIRE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4915);
        ssl();
        break;
      }

      case MySQLParser::DATA_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4916);
        match(MySQLParser::DATA_SYMBOL);
        setState(4917);
        match(MySQLParser::DIRECTORY_SYMBOL);
        setState(4919);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 518, _ctx)) {
        case 1: {
          setState(4918);
          equal();
          break;
        }

        default:
          break;
        }
        setState(4921);
        textStringLiteral();
        setState(4923);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REQUIRE_SYMBOL) {
          setState(4922);
          ssl();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SslContext ------------------------------------------------------------------

MySQLParser::SslContext::SslContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SslContext::REQUIRE_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SslContext::SSL_SYMBOL() {
  return getToken(MySQLParser::SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SslContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}


size_t MySQLParser::SslContext::getRuleIndex() const {
  return MySQLParser::RuleSsl;
}

void MySQLParser::SslContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSsl(this);
}

void MySQLParser::SslContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSsl(this);
}


std::any MySQLParser::SslContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSsl(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SslContext* MySQLParser::ssl() {
  SslContext *_localctx = _tracker.createInstance<SslContext>(_ctx, getState());
  enterRule(_localctx, 632, MySQLParser::RuleSsl);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4927);
    match(MySQLParser::REQUIRE_SYMBOL);
    setState(4929);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::NO_SYMBOL) {
      setState(4928);
      match(MySQLParser::NO_SYMBOL);
    }
    setState(4931);
    match(MySQLParser::SSL_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AccountManagementStatementContext ------------------------------------------------------------------

MySQLParser::AccountManagementStatementContext::AccountManagementStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AlterUserStatementContext* MySQLParser::AccountManagementStatementContext::alterUserStatement() {
  return getRuleContext<MySQLParser::AlterUserStatementContext>(0);
}

MySQLParser::CreateUserStatementContext* MySQLParser::AccountManagementStatementContext::createUserStatement() {
  return getRuleContext<MySQLParser::CreateUserStatementContext>(0);
}

MySQLParser::DropUserStatementContext* MySQLParser::AccountManagementStatementContext::dropUserStatement() {
  return getRuleContext<MySQLParser::DropUserStatementContext>(0);
}

MySQLParser::GrantStatementContext* MySQLParser::AccountManagementStatementContext::grantStatement() {
  return getRuleContext<MySQLParser::GrantStatementContext>(0);
}

MySQLParser::RenameUserStatementContext* MySQLParser::AccountManagementStatementContext::renameUserStatement() {
  return getRuleContext<MySQLParser::RenameUserStatementContext>(0);
}

MySQLParser::RevokeStatementContext* MySQLParser::AccountManagementStatementContext::revokeStatement() {
  return getRuleContext<MySQLParser::RevokeStatementContext>(0);
}

MySQLParser::SetRoleStatementContext* MySQLParser::AccountManagementStatementContext::setRoleStatement() {
  return getRuleContext<MySQLParser::SetRoleStatementContext>(0);
}


size_t MySQLParser::AccountManagementStatementContext::getRuleIndex() const {
  return MySQLParser::RuleAccountManagementStatement;
}

void MySQLParser::AccountManagementStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAccountManagementStatement(this);
}

void MySQLParser::AccountManagementStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAccountManagementStatement(this);
}


std::any MySQLParser::AccountManagementStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAccountManagementStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AccountManagementStatementContext* MySQLParser::accountManagementStatement() {
  AccountManagementStatementContext *_localctx = _tracker.createInstance<AccountManagementStatementContext>(_ctx, getState());
  enterRule(_localctx, 634, MySQLParser::RuleAccountManagementStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4941);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 522, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4933);
      alterUserStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4934);
      createUserStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4935);
      dropUserStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4936);
      grantStatement();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4937);
      renameUserStatement();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(4938);
      revokeStatement();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(4939);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4940);
      setRoleStatement();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterUserStatementContext ------------------------------------------------------------------

MySQLParser::AlterUserStatementContext::AlterUserStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterUserStatementContext::ALTER_SYMBOL() {
  return getToken(MySQLParser::ALTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUserStatementContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::CreateUserTailContext* MySQLParser::AlterUserStatementContext::createUserTail() {
  return getRuleContext<MySQLParser::CreateUserTailContext>(0);
}

MySQLParser::UserFunctionContext* MySQLParser::AlterUserStatementContext::userFunction() {
  return getRuleContext<MySQLParser::UserFunctionContext>(0);
}

MySQLParser::IdentifiedByPasswordContext* MySQLParser::AlterUserStatementContext::identifiedByPassword() {
  return getRuleContext<MySQLParser::IdentifiedByPasswordContext>(0);
}

MySQLParser::UserContext* MySQLParser::AlterUserStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::AlterUserStatementContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}

MySQLParser::CreateUserListContext* MySQLParser::AlterUserStatementContext::createUserList() {
  return getRuleContext<MySQLParser::CreateUserListContext>(0);
}

MySQLParser::AlterUserListContext* MySQLParser::AlterUserStatementContext::alterUserList() {
  return getRuleContext<MySQLParser::AlterUserListContext>(0);
}

MySQLParser::DiscardOldPasswordContext* MySQLParser::AlterUserStatementContext::discardOldPassword() {
  return getRuleContext<MySQLParser::DiscardOldPasswordContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserStatementContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUserStatementContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

MySQLParser::IdentifiedByRandomPasswordContext* MySQLParser::AlterUserStatementContext::identifiedByRandomPassword() {
  return getRuleContext<MySQLParser::IdentifiedByRandomPasswordContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserStatementContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUserStatementContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::AlterUserStatementContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}

MySQLParser::ReplacePasswordContext* MySQLParser::AlterUserStatementContext::replacePassword() {
  return getRuleContext<MySQLParser::ReplacePasswordContext>(0);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::AlterUserStatementContext::retainCurrentPassword() {
  return getRuleContext<MySQLParser::RetainCurrentPasswordContext>(0);
}

MySQLParser::UserRegistrationContext* MySQLParser::AlterUserStatementContext::userRegistration() {
  return getRuleContext<MySQLParser::UserRegistrationContext>(0);
}


size_t MySQLParser::AlterUserStatementContext::getRuleIndex() const {
  return MySQLParser::RuleAlterUserStatement;
}

void MySQLParser::AlterUserStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterUserStatement(this);
}

void MySQLParser::AlterUserStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterUserStatement(this);
}


std::any MySQLParser::AlterUserStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterUserStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterUserStatementContext* MySQLParser::alterUserStatement() {
  AlterUserStatementContext *_localctx = _tracker.createInstance<AlterUserStatementContext>(_ctx, getState());
  enterRule(_localctx, 636, MySQLParser::RuleAlterUserStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4943);
    match(MySQLParser::ALTER_SYMBOL);
    setState(4944);
    match(MySQLParser::USER_SYMBOL);
    setState(4947);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 523, _ctx)) {
    case 1: {
      setState(4945);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(4946);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(4998);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 533, _ctx)) {
    case 1: {
      setState(4953);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 524, _ctx)) {
      case 1: {
        setState(4949);

        if (!(serverVersion < 80014)) throw FailedPredicateException(this, "serverVersion < 80014");
        setState(4950);
        createUserList();
        break;
      }

      case 2: {
        setState(4951);

        if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
        setState(4952);
        alterUserList();
        break;
      }

      default:
        break;
      }
      setState(4955);
      createUserTail();
      break;
    }

    case 2: {
      setState(4957);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4958);
      userFunction();
      setState(4977);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 529, _ctx)) {
      case 1: {
        setState(4961);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 525, _ctx)) {
        case 1: {
          setState(4959);
          identifiedByRandomPassword();
          break;
        }

        case 2: {
          setState(4960);
          identifiedByPassword();
          break;
        }

        default:
          break;
        }
        setState(4965);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 526, _ctx)) {
        case 1: {
          setState(4963);

          if (!(serverVersion >= 80013)) throw FailedPredicateException(this, "serverVersion >= 80013");
          setState(4964);
          replacePassword();
          break;
        }

        default:
          break;
        }
        setState(4969);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 527, _ctx)) {
        case 1: {
          setState(4967);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(4968);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(4971);

        if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
        setState(4972);
        discardOldPassword();
        break;
      }

      case 3: {
        setState(4973);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(4975);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
          | (1ULL << MySQLParser::LONG_NUMBER)
          | (1ULL << MySQLParser::ULONGLONG_NUMBER)
          | (1ULL << MySQLParser::DECIMAL_NUMBER)
          | (1ULL << MySQLParser::FLOAT_NUMBER))) != 0)) {
          setState(4974);
          userRegistration();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      setState(4979);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(4980);
      userFunction();
      setState(4981);
      identifiedByPassword();
      break;
    }

    case 4: {
      setState(4983);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4984);
      user();
      setState(4996);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 532, _ctx)) {
      case 1: {
        setState(4985);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(4986);
        match(MySQLParser::ROLE_SYMBOL);
        setState(4990);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 530, _ctx)) {
        case 1: {
          setState(4987);
          match(MySQLParser::ALL_SYMBOL);
          break;
        }

        case 2: {
          setState(4988);
          match(MySQLParser::NONE_SYMBOL);
          break;
        }

        case 3: {
          setState(4989);
          roleList();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(4992);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(4994);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if ((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
          | (1ULL << MySQLParser::LONG_NUMBER)
          | (1ULL << MySQLParser::ULONGLONG_NUMBER)
          | (1ULL << MySQLParser::DECIMAL_NUMBER)
          | (1ULL << MySQLParser::FLOAT_NUMBER))) != 0)) {
          setState(4993);
          userRegistration();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterUserListContext ------------------------------------------------------------------

MySQLParser::AlterUserListContext::AlterUserListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::AlterUserContext *> MySQLParser::AlterUserListContext::alterUser() {
  return getRuleContexts<MySQLParser::AlterUserContext>();
}

MySQLParser::AlterUserContext* MySQLParser::AlterUserListContext::alterUser(size_t i) {
  return getRuleContext<MySQLParser::AlterUserContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterUserListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterUserListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::AlterUserListContext::getRuleIndex() const {
  return MySQLParser::RuleAlterUserList;
}

void MySQLParser::AlterUserListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterUserList(this);
}

void MySQLParser::AlterUserListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterUserList(this);
}


std::any MySQLParser::AlterUserListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterUserList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterUserListContext* MySQLParser::alterUserList() {
  AlterUserListContext *_localctx = _tracker.createInstance<AlterUserListContext>(_ctx, getState());
  enterRule(_localctx, 638, MySQLParser::RuleAlterUserList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(5000);
    alterUser();
    setState(5005);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 534, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(5001);
        match(MySQLParser::COMMA_SYMBOL);
        setState(5002);
        alterUser(); 
      }
      setState(5007);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 534, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterUserContext ------------------------------------------------------------------

MySQLParser::AlterUserContext::AlterUserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OldAlterUserContext* MySQLParser::AlterUserContext::oldAlterUser() {
  return getRuleContext<MySQLParser::OldAlterUserContext>(0);
}

MySQLParser::UserContext* MySQLParser::AlterUserContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

MySQLParser::IdentifiedByPasswordContext* MySQLParser::AlterUserContext::identifiedByPassword() {
  return getRuleContext<MySQLParser::IdentifiedByPasswordContext>(0);
}

MySQLParser::IdentifiedByRandomPasswordContext* MySQLParser::AlterUserContext::identifiedByRandomPassword() {
  return getRuleContext<MySQLParser::IdentifiedByRandomPasswordContext>(0);
}

MySQLParser::IdentifiedWithPluginContext* MySQLParser::AlterUserContext::identifiedWithPlugin() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginContext>(0);
}

MySQLParser::IdentifiedWithPluginAsAuthContext* MySQLParser::AlterUserContext::identifiedWithPluginAsAuth() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginAsAuthContext>(0);
}

MySQLParser::IdentifiedWithPluginByPasswordContext* MySQLParser::AlterUserContext::identifiedWithPluginByPassword() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginByPasswordContext>(0);
}

MySQLParser::IdentifiedWithPluginByRandomPasswordContext* MySQLParser::AlterUserContext::identifiedWithPluginByRandomPassword() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginByRandomPasswordContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterUserContext::ADD_SYMBOL() {
  return getTokens(MySQLParser::ADD_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterUserContext::ADD_SYMBOL(size_t i) {
  return getToken(MySQLParser::ADD_SYMBOL, i);
}

std::vector<MySQLParser::FactorContext *> MySQLParser::AlterUserContext::factor() {
  return getRuleContexts<MySQLParser::FactorContext>();
}

MySQLParser::FactorContext* MySQLParser::AlterUserContext::factor(size_t i) {
  return getRuleContext<MySQLParser::FactorContext>(i);
}

std::vector<MySQLParser::IdentificationContext *> MySQLParser::AlterUserContext::identification() {
  return getRuleContexts<MySQLParser::IdentificationContext>();
}

MySQLParser::IdentificationContext* MySQLParser::AlterUserContext::identification(size_t i) {
  return getRuleContext<MySQLParser::IdentificationContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterUserContext::MODIFY_SYMBOL() {
  return getTokens(MySQLParser::MODIFY_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterUserContext::MODIFY_SYMBOL(size_t i) {
  return getToken(MySQLParser::MODIFY_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::AlterUserContext::DROP_SYMBOL() {
  return getTokens(MySQLParser::DROP_SYMBOL);
}

tree::TerminalNode* MySQLParser::AlterUserContext::DROP_SYMBOL(size_t i) {
  return getToken(MySQLParser::DROP_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::AlterUserContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::AlterUserContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::AlterUserContext::retainCurrentPassword() {
  return getRuleContext<MySQLParser::RetainCurrentPasswordContext>(0);
}

MySQLParser::DiscardOldPasswordContext* MySQLParser::AlterUserContext::discardOldPassword() {
  return getRuleContext<MySQLParser::DiscardOldPasswordContext>(0);
}


size_t MySQLParser::AlterUserContext::getRuleIndex() const {
  return MySQLParser::RuleAlterUser;
}

void MySQLParser::AlterUserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterUser(this);
}

void MySQLParser::AlterUserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterUser(this);
}


std::any MySQLParser::AlterUserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterUserContext* MySQLParser::alterUser() {
  AlterUserContext *_localctx = _tracker.createInstance<AlterUserContext>(_ctx, getState());
  enterRule(_localctx, 640, MySQLParser::RuleAlterUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5086);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 551, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5008);

      if (!(serverVersion < 80025)) throw FailedPredicateException(this, "serverVersion < 80025");
      setState(5009);
      oldAlterUser();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5010);

      if (!(serverVersion >= 80025)) throw FailedPredicateException(this, "serverVersion >= 80025");

      setState(5011);
      user();
      setState(5084);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 550, _ctx)) {
      case 1: {
        setState(5012);
        identifiedByPassword();
        setState(5021);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 537, _ctx)) {
        case 1: {
          setState(5013);
          match(MySQLParser::REPLACE_SYMBOL);
          setState(5014);
          textStringLiteral();
          setState(5016);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 535, _ctx)) {
          case 1: {
            setState(5015);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        case 2: {
          setState(5019);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 536, _ctx)) {
          case 1: {
            setState(5018);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(5023);
        identifiedByRandomPassword();
        setState(5032);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 540, _ctx)) {
        case 1: {
          setState(5025);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 538, _ctx)) {
          case 1: {
            setState(5024);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        case 2: {
          setState(5027);
          match(MySQLParser::REPLACE_SYMBOL);
          setState(5028);
          textStringLiteral();
          setState(5030);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 539, _ctx)) {
          case 1: {
            setState(5029);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        }
        break;
      }

      case 3: {
        setState(5034);
        identifiedWithPlugin();
        break;
      }

      case 4: {
        setState(5035);
        identifiedWithPluginAsAuth();
        setState(5037);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 541, _ctx)) {
        case 1: {
          setState(5036);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 5: {
        setState(5039);
        identifiedWithPluginByPassword();
        setState(5048);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 544, _ctx)) {
        case 1: {
          setState(5040);
          match(MySQLParser::REPLACE_SYMBOL);
          setState(5041);
          textStringLiteral();
          setState(5043);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 542, _ctx)) {
          case 1: {
            setState(5042);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        case 2: {
          setState(5046);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 543, _ctx)) {
          case 1: {
            setState(5045);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        }
        break;
      }

      case 6: {
        setState(5050);
        identifiedWithPluginByRandomPassword();
        setState(5052);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 545, _ctx)) {
        case 1: {
          setState(5051);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 7: {
        setState(5055);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 546, _ctx)) {
        case 1: {
          setState(5054);
          discardOldPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 8: {
        setState(5057);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(5058);
        match(MySQLParser::ADD_SYMBOL);
        setState(5059);
        factor();
        setState(5060);
        identification();
        setState(5065);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 547, _ctx)) {
        case 1: {
          setState(5061);
          match(MySQLParser::ADD_SYMBOL);
          setState(5062);
          factor();
          setState(5063);
          identification();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 9: {
        setState(5067);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(5068);
        match(MySQLParser::MODIFY_SYMBOL);
        setState(5069);
        factor();
        setState(5070);
        identification();
        setState(5075);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 548, _ctx)) {
        case 1: {
          setState(5071);
          match(MySQLParser::MODIFY_SYMBOL);
          setState(5072);
          factor();
          setState(5073);
          identification();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 10: {
        setState(5077);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(5078);
        match(MySQLParser::DROP_SYMBOL);
        setState(5079);
        factor();
        setState(5082);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 549, _ctx)) {
        case 1: {
          setState(5080);
          match(MySQLParser::DROP_SYMBOL);
          setState(5081);
          factor();
          break;
        }

        default:
          break;
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OldAlterUserContext ------------------------------------------------------------------

MySQLParser::OldAlterUserContext::OldAlterUserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserContext* MySQLParser::OldAlterUserContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::OldAlterUserContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OldAlterUserContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::OldAlterUserContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::OldAlterUserContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OldAlterUserContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

MySQLParser::ReplacePasswordContext* MySQLParser::OldAlterUserContext::replacePassword() {
  return getRuleContext<MySQLParser::ReplacePasswordContext>(0);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::OldAlterUserContext::retainCurrentPassword() {
  return getRuleContext<MySQLParser::RetainCurrentPasswordContext>(0);
}

tree::TerminalNode* MySQLParser::OldAlterUserContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::OldAlterUserContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::OldAlterUserContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::TextStringHashContext* MySQLParser::OldAlterUserContext::textStringHash() {
  return getRuleContext<MySQLParser::TextStringHashContext>(0);
}

MySQLParser::DiscardOldPasswordContext* MySQLParser::OldAlterUserContext::discardOldPassword() {
  return getRuleContext<MySQLParser::DiscardOldPasswordContext>(0);
}


size_t MySQLParser::OldAlterUserContext::getRuleIndex() const {
  return MySQLParser::RuleOldAlterUser;
}

void MySQLParser::OldAlterUserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOldAlterUser(this);
}

void MySQLParser::OldAlterUserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOldAlterUser(this);
}


std::any MySQLParser::OldAlterUserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOldAlterUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OldAlterUserContext* MySQLParser::oldAlterUser() {
  OldAlterUserContext *_localctx = _tracker.createInstance<OldAlterUserContext>(_ctx, getState());
  enterRule(_localctx, 642, MySQLParser::RuleOldAlterUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5145);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 563, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5088);
      user();
      setState(5089);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(5090);
      match(MySQLParser::BY_SYMBOL);
      setState(5109);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 556, _ctx)) {
      case 1: {
        setState(5091);
        textString();
        setState(5094);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 552, _ctx)) {
        case 1: {
          setState(5092);

          if (!(serverVersion >= 80013)) throw FailedPredicateException(this, "serverVersion >= 80013");
          setState(5093);
          replacePassword();
          break;
        }

        default:
          break;
        }
        setState(5098);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 553, _ctx)) {
        case 1: {
          setState(5096);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(5097);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(5100);

        if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
        setState(5101);
        match(MySQLParser::RANDOM_SYMBOL);
        setState(5102);
        match(MySQLParser::PASSWORD_SYMBOL);
        setState(5104);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 554, _ctx)) {
        case 1: {
          setState(5103);
          replacePassword();
          break;
        }

        default:
          break;
        }
        setState(5107);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 555, _ctx)) {
        case 1: {
          setState(5106);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5111);
      user();
      setState(5112);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(5113);
      match(MySQLParser::WITH_SYMBOL);

      setState(5114);
      textOrIdentifier();
      setState(5138);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 561, _ctx)) {
      case 1: {
        setState(5115);
        match(MySQLParser::BY_SYMBOL);
        setState(5116);
        textString();
        setState(5119);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 557, _ctx)) {
        case 1: {
          setState(5117);

          if (!(serverVersion >= 80013)) throw FailedPredicateException(this, "serverVersion >= 80013");
          setState(5118);
          replacePassword();
          break;
        }

        default:
          break;
        }
        setState(5123);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 558, _ctx)) {
        case 1: {
          setState(5121);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(5122);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(5125);
        match(MySQLParser::AS_SYMBOL);
        setState(5126);
        textStringHash();
        setState(5129);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 559, _ctx)) {
        case 1: {
          setState(5127);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(5128);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 3: {
        setState(5131);

        if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
        setState(5132);
        match(MySQLParser::BY_SYMBOL);
        setState(5133);
        match(MySQLParser::RANDOM_SYMBOL);
        setState(5134);
        match(MySQLParser::PASSWORD_SYMBOL);
        setState(5136);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 560, _ctx)) {
        case 1: {
          setState(5135);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5140);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(5141);
      user();
      setState(5143);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 562, _ctx)) {
      case 1: {
        setState(5142);
        discardOldPassword();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserFunctionContext ------------------------------------------------------------------

MySQLParser::UserFunctionContext::UserFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UserFunctionContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::ParenthesesContext* MySQLParser::UserFunctionContext::parentheses() {
  return getRuleContext<MySQLParser::ParenthesesContext>(0);
}


size_t MySQLParser::UserFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleUserFunction;
}

void MySQLParser::UserFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserFunction(this);
}

void MySQLParser::UserFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserFunction(this);
}


std::any MySQLParser::UserFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserFunctionContext* MySQLParser::userFunction() {
  UserFunctionContext *_localctx = _tracker.createInstance<UserFunctionContext>(_ctx, getState());
  enterRule(_localctx, 644, MySQLParser::RuleUserFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5147);
    match(MySQLParser::USER_SYMBOL);
    setState(5148);
    parentheses();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUserStatementContext ------------------------------------------------------------------

MySQLParser::CreateUserStatementContext::CreateUserStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateUserStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUserStatementContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::CreateUserListContext* MySQLParser::CreateUserStatementContext::createUserList() {
  return getRuleContext<MySQLParser::CreateUserListContext>(0);
}

MySQLParser::DefaultRoleClauseContext* MySQLParser::CreateUserStatementContext::defaultRoleClause() {
  return getRuleContext<MySQLParser::DefaultRoleClauseContext>(0);
}

MySQLParser::CreateUserTailContext* MySQLParser::CreateUserStatementContext::createUserTail() {
  return getRuleContext<MySQLParser::CreateUserTailContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateUserStatementContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::CreateUserStatementContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUserStatement;
}

void MySQLParser::CreateUserStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUserStatement(this);
}

void MySQLParser::CreateUserStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUserStatement(this);
}


std::any MySQLParser::CreateUserStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUserStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUserStatementContext* MySQLParser::createUserStatement() {
  CreateUserStatementContext *_localctx = _tracker.createInstance<CreateUserStatementContext>(_ctx, getState());
  enterRule(_localctx, 646, MySQLParser::RuleCreateUserStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5150);
    match(MySQLParser::CREATE_SYMBOL);
    setState(5151);
    match(MySQLParser::USER_SYMBOL);
    setState(5154);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 564, _ctx)) {
    case 1: {
      setState(5152);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(5153);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(5156);
    createUserList();
    setState(5157);
    defaultRoleClause();
    setState(5158);
    createUserTail();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUserTailContext ------------------------------------------------------------------

MySQLParser::CreateUserTailContext::CreateUserTailContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RequireClauseContext* MySQLParser::CreateUserTailContext::requireClause() {
  return getRuleContext<MySQLParser::RequireClauseContext>(0);
}

MySQLParser::ConnectOptionsContext* MySQLParser::CreateUserTailContext::connectOptions() {
  return getRuleContext<MySQLParser::ConnectOptionsContext>(0);
}

std::vector<MySQLParser::AccountLockPasswordExpireOptionsContext *> MySQLParser::CreateUserTailContext::accountLockPasswordExpireOptions() {
  return getRuleContexts<MySQLParser::AccountLockPasswordExpireOptionsContext>();
}

MySQLParser::AccountLockPasswordExpireOptionsContext* MySQLParser::CreateUserTailContext::accountLockPasswordExpireOptions(size_t i) {
  return getRuleContext<MySQLParser::AccountLockPasswordExpireOptionsContext>(i);
}

MySQLParser::UserAttributesContext* MySQLParser::CreateUserTailContext::userAttributes() {
  return getRuleContext<MySQLParser::UserAttributesContext>(0);
}


size_t MySQLParser::CreateUserTailContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUserTail;
}

void MySQLParser::CreateUserTailContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUserTail(this);
}

void MySQLParser::CreateUserTailContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUserTail(this);
}


std::any MySQLParser::CreateUserTailContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUserTail(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUserTailContext* MySQLParser::createUserTail() {
  CreateUserTailContext *_localctx = _tracker.createInstance<CreateUserTailContext>(_ctx, getState());
  enterRule(_localctx, 648, MySQLParser::RuleCreateUserTail);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(5178);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 569, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5160);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(5162);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 565, _ctx)) {
      case 1: {
        setState(5161);
        requireClause();
        break;
      }

      default:
        break;
      }
      setState(5165);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 566, _ctx)) {
      case 1: {
        setState(5164);
        connectOptions();
        break;
      }

      default:
        break;
      }
      setState(5170);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 567, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(5167);
          accountLockPasswordExpireOptions(); 
        }
        setState(5172);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 567, _ctx);
      }
      setState(5175);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 568, _ctx)) {
      case 1: {
        setState(5173);

        if (!(serverVersion >= 80021)) throw FailedPredicateException(this, "serverVersion >= 80021");
        setState(5174);
        userAttributes();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);

      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserAttributesContext ------------------------------------------------------------------

MySQLParser::UserAttributesContext::UserAttributesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UserAttributesContext::ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::ATTRIBUTE_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::UserAttributesContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::UserAttributesContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}


size_t MySQLParser::UserAttributesContext::getRuleIndex() const {
  return MySQLParser::RuleUserAttributes;
}

void MySQLParser::UserAttributesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserAttributes(this);
}

void MySQLParser::UserAttributesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserAttributes(this);
}


std::any MySQLParser::UserAttributesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserAttributes(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserAttributesContext* MySQLParser::userAttributes() {
  UserAttributesContext *_localctx = _tracker.createInstance<UserAttributesContext>(_ctx, getState());
  enterRule(_localctx, 650, MySQLParser::RuleUserAttributes);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5184);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ATTRIBUTE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5180);
        match(MySQLParser::ATTRIBUTE_SYMBOL);
        setState(5181);
        textStringLiteral();
        break;
      }

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5182);
        match(MySQLParser::COMMENT_SYMBOL);
        setState(5183);
        textStringLiteral();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultRoleClauseContext ------------------------------------------------------------------

MySQLParser::DefaultRoleClauseContext::DefaultRoleClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DefaultRoleClauseContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DefaultRoleClauseContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::DefaultRoleClauseContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}


size_t MySQLParser::DefaultRoleClauseContext::getRuleIndex() const {
  return MySQLParser::RuleDefaultRoleClause;
}

void MySQLParser::DefaultRoleClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDefaultRoleClause(this);
}

void MySQLParser::DefaultRoleClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDefaultRoleClause(this);
}


std::any MySQLParser::DefaultRoleClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDefaultRoleClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DefaultRoleClauseContext* MySQLParser::defaultRoleClause() {
  DefaultRoleClauseContext *_localctx = _tracker.createInstance<DefaultRoleClauseContext>(_ctx, getState());
  enterRule(_localctx, 652, MySQLParser::RuleDefaultRoleClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5193);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 572, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5186);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5190);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 571, _ctx)) {
      case 1: {
        setState(5187);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(5188);
        match(MySQLParser::ROLE_SYMBOL);
        setState(5189);
        roleList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);

      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RequireClauseContext ------------------------------------------------------------------

MySQLParser::RequireClauseContext::RequireClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RequireClauseContext::REQUIRE_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_SYMBOL, 0);
}

MySQLParser::RequireListContext* MySQLParser::RequireClauseContext::requireList() {
  return getRuleContext<MySQLParser::RequireListContext>(0);
}

tree::TerminalNode* MySQLParser::RequireClauseContext::SSL_SYMBOL() {
  return getToken(MySQLParser::SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RequireClauseContext::X509_SYMBOL() {
  return getToken(MySQLParser::X509_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RequireClauseContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}


size_t MySQLParser::RequireClauseContext::getRuleIndex() const {
  return MySQLParser::RuleRequireClause;
}

void MySQLParser::RequireClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRequireClause(this);
}

void MySQLParser::RequireClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRequireClause(this);
}


std::any MySQLParser::RequireClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRequireClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RequireClauseContext* MySQLParser::requireClause() {
  RequireClauseContext *_localctx = _tracker.createInstance<RequireClauseContext>(_ctx, getState());
  enterRule(_localctx, 654, MySQLParser::RuleRequireClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5195);
    match(MySQLParser::REQUIRE_SYMBOL);
    setState(5198);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CIPHER_SYMBOL:
      case MySQLParser::ISSUER_SYMBOL:
      case MySQLParser::SUBJECT_SYMBOL: {
        setState(5196);
        requireList();
        break;
      }

      case MySQLParser::NONE_SYMBOL:
      case MySQLParser::SSL_SYMBOL:
      case MySQLParser::X509_SYMBOL: {
        setState(5197);
        antlrcpp::downCast<RequireClauseContext *>(_localctx)->option = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::NONE_SYMBOL || _la == MySQLParser::SSL_SYMBOL || _la == MySQLParser::X509_SYMBOL)) {
          antlrcpp::downCast<RequireClauseContext *>(_localctx)->option = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConnectOptionsContext ------------------------------------------------------------------

MySQLParser::ConnectOptionsContext::ConnectOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ConnectOptionsContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ConnectOptionsContext::MAX_QUERIES_PER_HOUR_SYMBOL() {
  return getTokens(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL);
}

tree::TerminalNode* MySQLParser::ConnectOptionsContext::MAX_QUERIES_PER_HOUR_SYMBOL(size_t i) {
  return getToken(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL, i);
}

std::vector<MySQLParser::Ulong_numberContext *> MySQLParser::ConnectOptionsContext::ulong_number() {
  return getRuleContexts<MySQLParser::Ulong_numberContext>();
}

MySQLParser::Ulong_numberContext* MySQLParser::ConnectOptionsContext::ulong_number(size_t i) {
  return getRuleContext<MySQLParser::Ulong_numberContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ConnectOptionsContext::MAX_UPDATES_PER_HOUR_SYMBOL() {
  return getTokens(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL);
}

tree::TerminalNode* MySQLParser::ConnectOptionsContext::MAX_UPDATES_PER_HOUR_SYMBOL(size_t i) {
  return getToken(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::ConnectOptionsContext::MAX_CONNECTIONS_PER_HOUR_SYMBOL() {
  return getTokens(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL);
}

tree::TerminalNode* MySQLParser::ConnectOptionsContext::MAX_CONNECTIONS_PER_HOUR_SYMBOL(size_t i) {
  return getToken(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::ConnectOptionsContext::MAX_USER_CONNECTIONS_SYMBOL() {
  return getTokens(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL);
}

tree::TerminalNode* MySQLParser::ConnectOptionsContext::MAX_USER_CONNECTIONS_SYMBOL(size_t i) {
  return getToken(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL, i);
}


size_t MySQLParser::ConnectOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleConnectOptions;
}

void MySQLParser::ConnectOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConnectOptions(this);
}

void MySQLParser::ConnectOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConnectOptions(this);
}


std::any MySQLParser::ConnectOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitConnectOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ConnectOptionsContext* MySQLParser::connectOptions() {
  ConnectOptionsContext *_localctx = _tracker.createInstance<ConnectOptionsContext>(_ctx, getState());
  enterRule(_localctx, 656, MySQLParser::RuleConnectOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(5200);
    match(MySQLParser::WITH_SYMBOL);
    setState(5209); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(5209);
              _errHandler->sync(this);
              switch (_input->LA(1)) {
                case MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL: {
                  setState(5201);
                  match(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL);
                  setState(5202);
                  ulong_number();
                  break;
                }

                case MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL: {
                  setState(5203);
                  match(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL);
                  setState(5204);
                  ulong_number();
                  break;
                }

                case MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL: {
                  setState(5205);
                  match(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL);
                  setState(5206);
                  ulong_number();
                  break;
                }

                case MySQLParser::MAX_USER_CONNECTIONS_SYMBOL: {
                  setState(5207);
                  match(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL);
                  setState(5208);
                  ulong_number();
                  break;
                }

              default:
                throw NoViableAltException(this);
              }
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(5211); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 575, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AccountLockPasswordExpireOptionsContext ------------------------------------------------------------------

MySQLParser::AccountLockPasswordExpireOptionsContext::AccountLockPasswordExpireOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::ACCOUNT_SYMBOL() {
  return getToken(MySQLParser::ACCOUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::UNLOCK_SYMBOL() {
  return getToken(MySQLParser::UNLOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::EXPIRE_SYMBOL() {
  return getToken(MySQLParser::EXPIRE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::HISTORY_SYMBOL() {
  return getToken(MySQLParser::HISTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::REUSE_SYMBOL() {
  return getToken(MySQLParser::REUSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::REQUIRE_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::AccountLockPasswordExpireOptionsContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::DAY_SYMBOL() {
  return getToken(MySQLParser::DAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::NEVER_SYMBOL() {
  return getToken(MySQLParser::NEVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::OPTIONAL_SYMBOL() {
  return getToken(MySQLParser::OPTIONAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::FAILED_LOGIN_ATTEMPTS_SYMBOL() {
  return getToken(MySQLParser::FAILED_LOGIN_ATTEMPTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::PASSWORD_LOCK_TIME_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_LOCK_TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AccountLockPasswordExpireOptionsContext::UNBOUNDED_SYMBOL() {
  return getToken(MySQLParser::UNBOUNDED_SYMBOL, 0);
}


size_t MySQLParser::AccountLockPasswordExpireOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleAccountLockPasswordExpireOptions;
}

void MySQLParser::AccountLockPasswordExpireOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAccountLockPasswordExpireOptions(this);
}

void MySQLParser::AccountLockPasswordExpireOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAccountLockPasswordExpireOptions(this);
}


std::any MySQLParser::AccountLockPasswordExpireOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAccountLockPasswordExpireOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AccountLockPasswordExpireOptionsContext* MySQLParser::accountLockPasswordExpireOptions() {
  AccountLockPasswordExpireOptionsContext *_localctx = _tracker.createInstance<AccountLockPasswordExpireOptionsContext>(_ctx, getState());
  enterRule(_localctx, 658, MySQLParser::RuleAccountLockPasswordExpireOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5255);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 582, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5213);
      match(MySQLParser::ACCOUNT_SYMBOL);
      setState(5214);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LOCK_SYMBOL || _la == MySQLParser::UNLOCK_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5215);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(5244);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 580, _ctx)) {
      case 1: {
        setState(5216);
        match(MySQLParser::EXPIRE_SYMBOL);
        setState(5223);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 576, _ctx)) {
        case 1: {
          setState(5217);
          match(MySQLParser::INTERVAL_SYMBOL);
          setState(5218);
          real_ulong_number();
          setState(5219);
          match(MySQLParser::DAY_SYMBOL);
          break;
        }

        case 2: {
          setState(5221);
          match(MySQLParser::NEVER_SYMBOL);
          break;
        }

        case 3: {
          setState(5222);
          match(MySQLParser::DEFAULT_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(5225);
        match(MySQLParser::HISTORY_SYMBOL);
        setState(5228);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::INT_NUMBER:
          case MySQLParser::LONG_NUMBER:
          case MySQLParser::ULONGLONG_NUMBER:
          case MySQLParser::HEX_NUMBER: {
            setState(5226);
            real_ulong_number();
            break;
          }

          case MySQLParser::DEFAULT_SYMBOL: {
            setState(5227);
            match(MySQLParser::DEFAULT_SYMBOL);
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        break;
      }

      case 3: {
        setState(5230);
        match(MySQLParser::REUSE_SYMBOL);
        setState(5231);
        match(MySQLParser::INTERVAL_SYMBOL);
        setState(5236);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::INT_NUMBER:
          case MySQLParser::LONG_NUMBER:
          case MySQLParser::ULONGLONG_NUMBER:
          case MySQLParser::HEX_NUMBER: {
            setState(5232);
            real_ulong_number();
            setState(5233);
            match(MySQLParser::DAY_SYMBOL);
            break;
          }

          case MySQLParser::DEFAULT_SYMBOL: {
            setState(5235);
            match(MySQLParser::DEFAULT_SYMBOL);
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        break;
      }

      case 4: {
        setState(5238);

        if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
        setState(5239);
        match(MySQLParser::REQUIRE_SYMBOL);
        setState(5240);
        match(MySQLParser::CURRENT_SYMBOL);
        setState(5242);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 579, _ctx)) {
        case 1: {
          setState(5241);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::DEFAULT_SYMBOL || _la == MySQLParser::OPTIONAL_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          break;
        }

        default:
          break;
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5246);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(5247);
      match(MySQLParser::FAILED_LOGIN_ATTEMPTS_SYMBOL);
      setState(5248);
      real_ulong_number();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5249);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(5250);
      match(MySQLParser::PASSWORD_LOCK_TIME_SYMBOL);
      setState(5253);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::INT_NUMBER:
        case MySQLParser::LONG_NUMBER:
        case MySQLParser::ULONGLONG_NUMBER:
        case MySQLParser::HEX_NUMBER: {
          setState(5251);
          real_ulong_number();
          break;
        }

        case MySQLParser::UNBOUNDED_SYMBOL: {
          setState(5252);
          match(MySQLParser::UNBOUNDED_SYMBOL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropUserStatementContext ------------------------------------------------------------------

MySQLParser::DropUserStatementContext::DropUserStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropUserStatementContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropUserStatementContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::DropUserStatementContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropUserStatementContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropUserStatementContext::getRuleIndex() const {
  return MySQLParser::RuleDropUserStatement;
}

void MySQLParser::DropUserStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropUserStatement(this);
}

void MySQLParser::DropUserStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropUserStatement(this);
}


std::any MySQLParser::DropUserStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropUserStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropUserStatementContext* MySQLParser::dropUserStatement() {
  DropUserStatementContext *_localctx = _tracker.createInstance<DropUserStatementContext>(_ctx, getState());
  enterRule(_localctx, 660, MySQLParser::RuleDropUserStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5257);
    match(MySQLParser::DROP_SYMBOL);
    setState(5258);
    match(MySQLParser::USER_SYMBOL);
    setState(5261);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 583, _ctx)) {
    case 1: {
      setState(5259);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(5260);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(5263);
    userList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrantStatementContext ------------------------------------------------------------------

MySQLParser::GrantStatementContext::GrantStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::GrantStatementContext::GRANT_SYMBOL() {
  return getTokens(MySQLParser::GRANT_SYMBOL);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::GRANT_SYMBOL(size_t i) {
  return getToken(MySQLParser::GRANT_SYMBOL, i);
}

MySQLParser::RoleOrPrivilegesListContext* MySQLParser::GrantStatementContext::roleOrPrivilegesList() {
  return getRuleContext<MySQLParser::RoleOrPrivilegesListContext>(0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::GrantStatementContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::GrantIdentifierContext* MySQLParser::GrantStatementContext::grantIdentifier() {
  return getRuleContext<MySQLParser::GrantIdentifierContext>(0);
}

MySQLParser::GrantTargetListContext* MySQLParser::GrantStatementContext::grantTargetList() {
  return getRuleContext<MySQLParser::GrantTargetListContext>(0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::GrantStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::ADMIN_SYMBOL() {
  return getToken(MySQLParser::ADMIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

MySQLParser::AclTypeContext* MySQLParser::GrantStatementContext::aclType() {
  return getRuleContext<MySQLParser::AclTypeContext>(0);
}

MySQLParser::VersionedRequireClauseContext* MySQLParser::GrantStatementContext::versionedRequireClause() {
  return getRuleContext<MySQLParser::VersionedRequireClauseContext>(0);
}

MySQLParser::GrantOptionsContext* MySQLParser::GrantStatementContext::grantOptions() {
  return getRuleContext<MySQLParser::GrantOptionsContext>(0);
}

MySQLParser::GrantAsContext* MySQLParser::GrantStatementContext::grantAs() {
  return getRuleContext<MySQLParser::GrantAsContext>(0);
}

tree::TerminalNode* MySQLParser::GrantStatementContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}


size_t MySQLParser::GrantStatementContext::getRuleIndex() const {
  return MySQLParser::RuleGrantStatement;
}

void MySQLParser::GrantStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrantStatement(this);
}

void MySQLParser::GrantStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrantStatement(this);
}


std::any MySQLParser::GrantStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGrantStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GrantStatementContext* MySQLParser::grantStatement() {
  GrantStatementContext *_localctx = _tracker.createInstance<GrantStatementContext>(_ctx, getState());
  enterRule(_localctx, 662, MySQLParser::RuleGrantStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5265);
    match(MySQLParser::GRANT_SYMBOL);
    setState(5308);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 592, _ctx)) {
    case 1: {
      setState(5266);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5267);
      roleOrPrivilegesList();
      setState(5268);
      match(MySQLParser::TO_SYMBOL);
      setState(5269);
      userList();
      setState(5273);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(5270);
        match(MySQLParser::WITH_SYMBOL);
        setState(5271);
        match(MySQLParser::ADMIN_SYMBOL);
        setState(5272);
        match(MySQLParser::OPTION_SYMBOL);
      }
      break;
    }

    case 2: {
      setState(5280);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 586, _ctx)) {
      case 1: {
        setState(5275);
        roleOrPrivilegesList();
        break;
      }

      case 2: {
        setState(5276);
        match(MySQLParser::ALL_SYMBOL);
        setState(5278);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::PRIVILEGES_SYMBOL) {
          setState(5277);
          match(MySQLParser::PRIVILEGES_SYMBOL);
        }
        break;
      }

      default:
        break;
      }
      setState(5282);
      match(MySQLParser::ON_SYMBOL);
      setState(5284);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 587, _ctx)) {
      case 1: {
        setState(5283);
        aclType();
        break;
      }

      default:
        break;
      }
      setState(5286);
      grantIdentifier();
      setState(5287);
      match(MySQLParser::TO_SYMBOL);
      setState(5288);
      grantTargetList();
      setState(5290);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 588, _ctx)) {
      case 1: {
        setState(5289);
        versionedRequireClause();
        break;
      }

      default:
        break;
      }
      setState(5293);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(5292);
        grantOptions();
      }
      setState(5296);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::AS_SYMBOL) {
        setState(5295);
        grantAs();
      }
      break;
    }

    case 3: {
      setState(5298);
      match(MySQLParser::PROXY_SYMBOL);
      setState(5299);
      match(MySQLParser::ON_SYMBOL);
      setState(5300);
      user();
      setState(5301);
      match(MySQLParser::TO_SYMBOL);
      setState(5302);
      grantTargetList();
      setState(5306);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(5303);
        match(MySQLParser::WITH_SYMBOL);
        setState(5304);
        match(MySQLParser::GRANT_SYMBOL);
        setState(5305);
        match(MySQLParser::OPTION_SYMBOL);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrantTargetListContext ------------------------------------------------------------------

MySQLParser::GrantTargetListContext::GrantTargetListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CreateUserListContext* MySQLParser::GrantTargetListContext::createUserList() {
  return getRuleContext<MySQLParser::CreateUserListContext>(0);
}

MySQLParser::UserListContext* MySQLParser::GrantTargetListContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}


size_t MySQLParser::GrantTargetListContext::getRuleIndex() const {
  return MySQLParser::RuleGrantTargetList;
}

void MySQLParser::GrantTargetListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrantTargetList(this);
}

void MySQLParser::GrantTargetListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrantTargetList(this);
}


std::any MySQLParser::GrantTargetListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGrantTargetList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GrantTargetListContext* MySQLParser::grantTargetList() {
  GrantTargetListContext *_localctx = _tracker.createInstance<GrantTargetListContext>(_ctx, getState());
  enterRule(_localctx, 664, MySQLParser::RuleGrantTargetList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5314);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 593, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5310);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(5311);
      createUserList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5312);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(5313);
      userList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrantOptionsContext ------------------------------------------------------------------

MySQLParser::GrantOptionsContext::GrantOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GrantOptionsContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::GrantOptionContext* MySQLParser::GrantOptionsContext::grantOption() {
  return getRuleContext<MySQLParser::GrantOptionContext>(0);
}


size_t MySQLParser::GrantOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleGrantOptions;
}

void MySQLParser::GrantOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrantOptions(this);
}

void MySQLParser::GrantOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrantOptions(this);
}


std::any MySQLParser::GrantOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGrantOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GrantOptionsContext* MySQLParser::grantOptions() {
  GrantOptionsContext *_localctx = _tracker.createInstance<GrantOptionsContext>(_ctx, getState());
  enterRule(_localctx, 666, MySQLParser::RuleGrantOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5316);
    match(MySQLParser::WITH_SYMBOL);
    setState(5317);
    grantOption();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExceptRoleListContext ------------------------------------------------------------------

MySQLParser::ExceptRoleListContext::ExceptRoleListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExceptRoleListContext::EXCEPT_SYMBOL() {
  return getToken(MySQLParser::EXCEPT_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::ExceptRoleListContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}


size_t MySQLParser::ExceptRoleListContext::getRuleIndex() const {
  return MySQLParser::RuleExceptRoleList;
}

void MySQLParser::ExceptRoleListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExceptRoleList(this);
}

void MySQLParser::ExceptRoleListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExceptRoleList(this);
}


std::any MySQLParser::ExceptRoleListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExceptRoleList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExceptRoleListContext* MySQLParser::exceptRoleList() {
  ExceptRoleListContext *_localctx = _tracker.createInstance<ExceptRoleListContext>(_ctx, getState());
  enterRule(_localctx, 668, MySQLParser::RuleExceptRoleList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5319);
    match(MySQLParser::EXCEPT_SYMBOL);
    setState(5320);
    roleList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WithRolesContext ------------------------------------------------------------------

MySQLParser::WithRolesContext::WithRolesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WithRolesContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WithRolesContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::WithRolesContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}

tree::TerminalNode* MySQLParser::WithRolesContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WithRolesContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WithRolesContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::ExceptRoleListContext* MySQLParser::WithRolesContext::exceptRoleList() {
  return getRuleContext<MySQLParser::ExceptRoleListContext>(0);
}


size_t MySQLParser::WithRolesContext::getRuleIndex() const {
  return MySQLParser::RuleWithRoles;
}

void MySQLParser::WithRolesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWithRoles(this);
}

void MySQLParser::WithRolesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWithRoles(this);
}


std::any MySQLParser::WithRolesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWithRoles(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WithRolesContext* MySQLParser::withRoles() {
  WithRolesContext *_localctx = _tracker.createInstance<WithRolesContext>(_ctx, getState());
  enterRule(_localctx, 670, MySQLParser::RuleWithRoles);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5322);
    match(MySQLParser::WITH_SYMBOL);
    setState(5323);
    match(MySQLParser::ROLE_SYMBOL);
    setState(5331);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 595, _ctx)) {
    case 1: {
      setState(5324);
      roleList();
      break;
    }

    case 2: {
      setState(5325);
      match(MySQLParser::ALL_SYMBOL);
      setState(5327);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXCEPT_SYMBOL) {
        setState(5326);
        exceptRoleList();
      }
      break;
    }

    case 3: {
      setState(5329);
      match(MySQLParser::NONE_SYMBOL);
      break;
    }

    case 4: {
      setState(5330);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrantAsContext ------------------------------------------------------------------

MySQLParser::GrantAsContext::GrantAsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GrantAsContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantAsContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::WithRolesContext* MySQLParser::GrantAsContext::withRoles() {
  return getRuleContext<MySQLParser::WithRolesContext>(0);
}


size_t MySQLParser::GrantAsContext::getRuleIndex() const {
  return MySQLParser::RuleGrantAs;
}

void MySQLParser::GrantAsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrantAs(this);
}

void MySQLParser::GrantAsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrantAs(this);
}


std::any MySQLParser::GrantAsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGrantAs(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GrantAsContext* MySQLParser::grantAs() {
  GrantAsContext *_localctx = _tracker.createInstance<GrantAsContext>(_ctx, getState());
  enterRule(_localctx, 672, MySQLParser::RuleGrantAs);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5333);
    match(MySQLParser::AS_SYMBOL);
    setState(5334);
    match(MySQLParser::USER_SYMBOL);
    setState(5336);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::WITH_SYMBOL) {
      setState(5335);
      withRoles();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VersionedRequireClauseContext ------------------------------------------------------------------

MySQLParser::VersionedRequireClauseContext::VersionedRequireClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RequireClauseContext* MySQLParser::VersionedRequireClauseContext::requireClause() {
  return getRuleContext<MySQLParser::RequireClauseContext>(0);
}


size_t MySQLParser::VersionedRequireClauseContext::getRuleIndex() const {
  return MySQLParser::RuleVersionedRequireClause;
}

void MySQLParser::VersionedRequireClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterVersionedRequireClause(this);
}

void MySQLParser::VersionedRequireClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitVersionedRequireClause(this);
}


std::any MySQLParser::VersionedRequireClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitVersionedRequireClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::VersionedRequireClauseContext* MySQLParser::versionedRequireClause() {
  VersionedRequireClauseContext *_localctx = _tracker.createInstance<VersionedRequireClauseContext>(_ctx, getState());
  enterRule(_localctx, 674, MySQLParser::RuleVersionedRequireClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5338);

    if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
    setState(5339);
    requireClause();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RenameUserStatementContext ------------------------------------------------------------------

MySQLParser::RenameUserStatementContext::RenameUserStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RenameUserStatementContext::RENAME_SYMBOL() {
  return getToken(MySQLParser::RENAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RenameUserStatementContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

std::vector<MySQLParser::UserContext *> MySQLParser::RenameUserStatementContext::user() {
  return getRuleContexts<MySQLParser::UserContext>();
}

MySQLParser::UserContext* MySQLParser::RenameUserStatementContext::user(size_t i) {
  return getRuleContext<MySQLParser::UserContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::RenameUserStatementContext::TO_SYMBOL() {
  return getTokens(MySQLParser::TO_SYMBOL);
}

tree::TerminalNode* MySQLParser::RenameUserStatementContext::TO_SYMBOL(size_t i) {
  return getToken(MySQLParser::TO_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::RenameUserStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::RenameUserStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::RenameUserStatementContext::getRuleIndex() const {
  return MySQLParser::RuleRenameUserStatement;
}

void MySQLParser::RenameUserStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRenameUserStatement(this);
}

void MySQLParser::RenameUserStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRenameUserStatement(this);
}


std::any MySQLParser::RenameUserStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRenameUserStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RenameUserStatementContext* MySQLParser::renameUserStatement() {
  RenameUserStatementContext *_localctx = _tracker.createInstance<RenameUserStatementContext>(_ctx, getState());
  enterRule(_localctx, 676, MySQLParser::RuleRenameUserStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5341);
    match(MySQLParser::RENAME_SYMBOL);
    setState(5342);
    match(MySQLParser::USER_SYMBOL);
    setState(5343);
    user();
    setState(5344);
    match(MySQLParser::TO_SYMBOL);
    setState(5345);
    user();
    setState(5353);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5346);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5347);
      user();
      setState(5348);
      match(MySQLParser::TO_SYMBOL);
      setState(5349);
      user();
      setState(5355);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RevokeStatementContext ------------------------------------------------------------------

MySQLParser::RevokeStatementContext::RevokeStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::REVOKE_SYMBOL() {
  return getToken(MySQLParser::REVOKE_SYMBOL, 0);
}

MySQLParser::RoleOrPrivilegesListContext* MySQLParser::RevokeStatementContext::roleOrPrivilegesList() {
  return getRuleContext<MySQLParser::RoleOrPrivilegesListContext>(0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::RevokeStatementContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::GrantIdentifierContext* MySQLParser::RevokeStatementContext::grantIdentifier() {
  return getRuleContext<MySQLParser::GrantIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::RevokeStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::RevokeStatementContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}

MySQLParser::IgnoreUnknownUserContext* MySQLParser::RevokeStatementContext::ignoreUnknownUser() {
  return getRuleContext<MySQLParser::IgnoreUnknownUserContext>(0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::GRANT_SYMBOL() {
  return getToken(MySQLParser::GRANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

MySQLParser::AclTypeContext* MySQLParser::RevokeStatementContext::aclType() {
  return getRuleContext<MySQLParser::AclTypeContext>(0);
}

tree::TerminalNode* MySQLParser::RevokeStatementContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}


size_t MySQLParser::RevokeStatementContext::getRuleIndex() const {
  return MySQLParser::RuleRevokeStatement;
}

void MySQLParser::RevokeStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRevokeStatement(this);
}

void MySQLParser::RevokeStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRevokeStatement(this);
}


std::any MySQLParser::RevokeStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRevokeStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RevokeStatementContext* MySQLParser::revokeStatement() {
  RevokeStatementContext *_localctx = _tracker.createInstance<RevokeStatementContext>(_ctx, getState());
  enterRule(_localctx, 678, MySQLParser::RuleRevokeStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5356);
    match(MySQLParser::REVOKE_SYMBOL);
    setState(5359);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 598, _ctx)) {
    case 1: {
      setState(5357);

      if (!(serverVersion >= 80030)) throw FailedPredicateException(this, "serverVersion >= 80030");
      setState(5358);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(5398);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 603, _ctx)) {
    case 1: {
      setState(5361);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5362);
      roleOrPrivilegesList();
      setState(5363);
      match(MySQLParser::FROM_SYMBOL);
      setState(5364);
      userList();
      break;
    }

    case 2: {
      setState(5366);
      roleOrPrivilegesList();
      setState(5367);
      match(MySQLParser::ON_SYMBOL);
      setState(5369);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 599, _ctx)) {
      case 1: {
        setState(5368);
        aclType();
        break;
      }

      default:
        break;
      }
      setState(5371);
      grantIdentifier();
      setState(5372);
      match(MySQLParser::FROM_SYMBOL);
      setState(5373);
      userList();
      break;
    }

    case 3: {
      setState(5375);
      match(MySQLParser::ALL_SYMBOL);
      setState(5377);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 600, _ctx)) {
      case 1: {
        setState(5376);
        match(MySQLParser::PRIVILEGES_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5388);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 602, _ctx)) {
      case 1: {
        setState(5379);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(5380);
        match(MySQLParser::ON_SYMBOL);
        setState(5382);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 601, _ctx)) {
        case 1: {
          setState(5381);
          aclType();
          break;
        }

        default:
          break;
        }
        setState(5384);
        grantIdentifier();
        break;
      }

      case 2: {
        setState(5385);
        match(MySQLParser::COMMA_SYMBOL);
        setState(5386);
        match(MySQLParser::GRANT_SYMBOL);
        setState(5387);
        match(MySQLParser::OPTION_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5390);
      match(MySQLParser::FROM_SYMBOL);
      setState(5391);
      userList();
      break;
    }

    case 4: {
      setState(5392);
      match(MySQLParser::PROXY_SYMBOL);
      setState(5393);
      match(MySQLParser::ON_SYMBOL);
      setState(5394);
      user();
      setState(5395);
      match(MySQLParser::FROM_SYMBOL);
      setState(5396);
      userList();
      break;
    }

    default:
      break;
    }
    setState(5402);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 604, _ctx)) {
    case 1: {
      setState(5400);

      if (!(serverVersion >= 80030)) throw FailedPredicateException(this, "serverVersion >= 80030");
      setState(5401);
      ignoreUnknownUser();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AclTypeContext ------------------------------------------------------------------

MySQLParser::AclTypeContext::AclTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AclTypeContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AclTypeContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AclTypeContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AclTypeContext::LIBRARY_SYMBOL() {
  return getToken(MySQLParser::LIBRARY_SYMBOL, 0);
}


size_t MySQLParser::AclTypeContext::getRuleIndex() const {
  return MySQLParser::RuleAclType;
}

void MySQLParser::AclTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAclType(this);
}

void MySQLParser::AclTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAclType(this);
}


std::any MySQLParser::AclTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAclType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AclTypeContext* MySQLParser::aclType() {
  AclTypeContext *_localctx = _tracker.createInstance<AclTypeContext>(_ctx, getState());
  enterRule(_localctx, 680, MySQLParser::RuleAclType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5404);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::FUNCTION_SYMBOL || _la == MySQLParser::PROCEDURE_SYMBOL || _la == MySQLParser::TABLE_SYMBOL || _la == MySQLParser::LIBRARY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleOrPrivilegesListContext ------------------------------------------------------------------

MySQLParser::RoleOrPrivilegesListContext::RoleOrPrivilegesListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::RoleOrPrivilegeContext *> MySQLParser::RoleOrPrivilegesListContext::roleOrPrivilege() {
  return getRuleContexts<MySQLParser::RoleOrPrivilegeContext>();
}

MySQLParser::RoleOrPrivilegeContext* MySQLParser::RoleOrPrivilegesListContext::roleOrPrivilege(size_t i) {
  return getRuleContext<MySQLParser::RoleOrPrivilegeContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::RoleOrPrivilegesListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegesListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::RoleOrPrivilegesListContext::getRuleIndex() const {
  return MySQLParser::RuleRoleOrPrivilegesList;
}

void MySQLParser::RoleOrPrivilegesListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleOrPrivilegesList(this);
}

void MySQLParser::RoleOrPrivilegesListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleOrPrivilegesList(this);
}


std::any MySQLParser::RoleOrPrivilegesListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleOrPrivilegesList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleOrPrivilegesListContext* MySQLParser::roleOrPrivilegesList() {
  RoleOrPrivilegesListContext *_localctx = _tracker.createInstance<RoleOrPrivilegesListContext>(_ctx, getState());
  enterRule(_localctx, 682, MySQLParser::RuleRoleOrPrivilegesList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5406);
    roleOrPrivilege();
    setState(5411);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5407);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5408);
      roleOrPrivilege();
      setState(5413);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleOrPrivilegeContext ------------------------------------------------------------------

MySQLParser::RoleOrPrivilegeContext::RoleOrPrivilegeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoleIdentifierOrTextContext* MySQLParser::RoleOrPrivilegeContext::roleIdentifierOrText() {
  return getRuleContext<MySQLParser::RoleIdentifierOrTextContext>(0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::RoleOrPrivilegeContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::SIMPLE_IDENTIFIER() {
  return getToken(MySQLParser::SIMPLE_IDENTIFIER, 0);
}

MySQLParser::ColumnInternalRefListContext* MySQLParser::RoleOrPrivilegeContext::columnInternalRefList() {
  return getRuleContext<MySQLParser::ColumnInternalRefListContext>(0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::SELECT_SYMBOL() {
  return getToken(MySQLParser::SELECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::INSERT_SYMBOL() {
  return getToken(MySQLParser::INSERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::REFERENCES_SYMBOL() {
  return getToken(MySQLParser::REFERENCES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::DELETE_SYMBOL() {
  return getToken(MySQLParser::DELETE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::USAGE_SYMBOL() {
  return getToken(MySQLParser::USAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::EXECUTE_SYMBOL() {
  return getToken(MySQLParser::EXECUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::RELOAD_SYMBOL() {
  return getToken(MySQLParser::RELOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::SHUTDOWN_SYMBOL() {
  return getToken(MySQLParser::SHUTDOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::PROCESS_SYMBOL() {
  return getToken(MySQLParser::PROCESS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::FILE_SYMBOL() {
  return getToken(MySQLParser::FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::SUPER_SYMBOL() {
  return getToken(MySQLParser::SUPER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::TRIGGER_SYMBOL() {
  return getToken(MySQLParser::TRIGGER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::GRANT_SYMBOL() {
  return getToken(MySQLParser::GRANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::DATABASES_SYMBOL() {
  return getToken(MySQLParser::DATABASES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::TEMPORARY_SYMBOL() {
  return getToken(MySQLParser::TEMPORARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::ROUTINE_SYMBOL() {
  return getToken(MySQLParser::ROUTINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::CLIENT_SYMBOL() {
  return getToken(MySQLParser::CLIENT_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::RoleOrPrivilegeContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::ALTER_SYMBOL() {
  return getToken(MySQLParser::ALTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}


size_t MySQLParser::RoleOrPrivilegeContext::getRuleIndex() const {
  return MySQLParser::RuleRoleOrPrivilege;
}

void MySQLParser::RoleOrPrivilegeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleOrPrivilege(this);
}

void MySQLParser::RoleOrPrivilegeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleOrPrivilege(this);
}


std::any MySQLParser::RoleOrPrivilegeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleOrPrivilege(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleOrPrivilegeContext* MySQLParser::roleOrPrivilege() {
  RoleOrPrivilegeContext *_localctx = _tracker.createInstance<RoleOrPrivilegeContext>(_ctx, getState());
  enterRule(_localctx, 684, MySQLParser::RuleRoleOrPrivilege);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5458);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 613, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5414);

      if (!(serverVersion > 80000)) throw FailedPredicateException(this, "serverVersion > 80000");
      setState(5425);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 608, _ctx)) {
      case 1: {
        setState(5415);
        roleIdentifierOrText();
        setState(5417);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
          setState(5416);
          columnInternalRefList();
        }
        break;
      }

      case 2: {
        setState(5419);
        roleIdentifierOrText();
        setState(5420);
        match(MySQLParser::AT_SIGN_SYMBOL);
        setState(5423);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 607, _ctx)) {
        case 1: {
          setState(5421);
          textOrIdentifier();
          break;
        }

        case 2: {
          setState(5422);
          match(MySQLParser::SIMPLE_IDENTIFIER);
          break;
        }

        default:
          break;
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5427);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::INSERT_SYMBOL || _la == MySQLParser::REFERENCES_SYMBOL

      || _la == MySQLParser::SELECT_SYMBOL || _la == MySQLParser::UPDATE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5429);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
        setState(5428);
        columnInternalRefList();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5431);
      _la = _input->LA(1);
      if (!(((((_la - 173) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 173)) & ((1ULL << (MySQLParser::DELETE_SYMBOL - 173))
        | (1ULL << (MySQLParser::DROP_SYMBOL - 173))
        | (1ULL << (MySQLParser::EVENT_SYMBOL - 173))
        | (1ULL << (MySQLParser::EXECUTE_SYMBOL - 173))
        | (1ULL << (MySQLParser::FILE_SYMBOL - 173)))) != 0) || _la == MySQLParser::INDEX_SYMBOL || ((((_la - 453) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 453)) & ((1ULL << (MySQLParser::PROCESS_SYMBOL - 453))
        | (1ULL << (MySQLParser::PROXY_SYMBOL - 453))
        | (1ULL << (MySQLParser::RELOAD_SYMBOL - 453)))) != 0) || _la == MySQLParser::SHUTDOWN_SYMBOL

      || _la == MySQLParser::SUPER_SYMBOL || _la == MySQLParser::TRIGGER_SYMBOL

      || _la == MySQLParser::USAGE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5432);
      match(MySQLParser::GRANT_SYMBOL);
      setState(5433);
      match(MySQLParser::OPTION_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5434);
      match(MySQLParser::SHOW_SYMBOL);
      setState(5435);
      match(MySQLParser::DATABASES_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(5436);
      match(MySQLParser::CREATE_SYMBOL);
      setState(5440);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::TEMPORARY_SYMBOL: {
          setState(5437);
          match(MySQLParser::TEMPORARY_SYMBOL);
          setState(5438);
          antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = match(MySQLParser::TABLES_SYMBOL);
          break;
        }

        case MySQLParser::ROUTINE_SYMBOL:
        case MySQLParser::TABLESPACE_SYMBOL:
        case MySQLParser::USER_SYMBOL:
        case MySQLParser::VIEW_SYMBOL: {
          setState(5439);
          antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::ROUTINE_SYMBOL || ((((_la - 598) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 598)) & ((1ULL << (MySQLParser::TABLESPACE_SYMBOL - 598))
            | (1ULL << (MySQLParser::USER_SYMBOL - 598))
            | (1ULL << (MySQLParser::VIEW_SYMBOL - 598)))) != 0))) {
            antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          break;
        }

        case MySQLParser::COMMA_SYMBOL:
        case MySQLParser::FROM_SYMBOL:
        case MySQLParser::ON_SYMBOL:
        case MySQLParser::TO_SYMBOL: {
          break;
        }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(5442);
      match(MySQLParser::LOCK_SYMBOL);
      setState(5443);
      match(MySQLParser::TABLES_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(5444);
      match(MySQLParser::REPLICATION_SYMBOL);
      setState(5447);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 611, _ctx)) {
      case 1: {
        setState(5445);
        match(MySQLParser::CLIENT_SYMBOL);
        break;
      }

      case 2: {
        setState(5446);
        replica();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(5449);
      match(MySQLParser::SHOW_SYMBOL);
      setState(5450);
      match(MySQLParser::VIEW_SYMBOL);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(5451);
      match(MySQLParser::ALTER_SYMBOL);
      setState(5453);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ROUTINE_SYMBOL) {
        setState(5452);
        match(MySQLParser::ROUTINE_SYMBOL);
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(5455);

      if (!(serverVersion > 80000)) throw FailedPredicateException(this, "serverVersion > 80000");
      setState(5456);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CREATE_SYMBOL

      || _la == MySQLParser::DROP_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5457);
      match(MySQLParser::ROLE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrantIdentifierContext ------------------------------------------------------------------

MySQLParser::GrantIdentifierContext::GrantIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::GrantIdentifierContext::MULT_OPERATOR() {
  return getTokens(MySQLParser::MULT_OPERATOR);
}

tree::TerminalNode* MySQLParser::GrantIdentifierContext::MULT_OPERATOR(size_t i) {
  return getToken(MySQLParser::MULT_OPERATOR, i);
}

tree::TerminalNode* MySQLParser::GrantIdentifierContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_SYMBOL, 0);
}

MySQLParser::SchemaRefContext* MySQLParser::GrantIdentifierContext::schemaRef() {
  return getRuleContext<MySQLParser::SchemaRefContext>(0);
}

MySQLParser::TableRefContext* MySQLParser::GrantIdentifierContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}


size_t MySQLParser::GrantIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleGrantIdentifier;
}

void MySQLParser::GrantIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrantIdentifier(this);
}

void MySQLParser::GrantIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrantIdentifier(this);
}


std::any MySQLParser::GrantIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGrantIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GrantIdentifierContext* MySQLParser::grantIdentifier() {
  GrantIdentifierContext *_localctx = _tracker.createInstance<GrantIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 686, MySQLParser::RuleGrantIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5476);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 616, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5460);
      match(MySQLParser::MULT_OPERATOR);
      setState(5463);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DOT_SYMBOL) {
        setState(5461);
        match(MySQLParser::DOT_SYMBOL);
        setState(5462);
        match(MySQLParser::MULT_OPERATOR);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5465);
      schemaRef();
      setState(5468);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DOT_SYMBOL) {
        setState(5466);
        match(MySQLParser::DOT_SYMBOL);
        setState(5467);
        match(MySQLParser::MULT_OPERATOR);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5470);
      tableRef();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5471);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(5472);
      schemaRef();
      setState(5473);
      match(MySQLParser::DOT_SYMBOL);
      setState(5474);
      tableRef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RequireListContext ------------------------------------------------------------------

MySQLParser::RequireListContext::RequireListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::RequireListElementContext *> MySQLParser::RequireListContext::requireListElement() {
  return getRuleContexts<MySQLParser::RequireListElementContext>();
}

MySQLParser::RequireListElementContext* MySQLParser::RequireListContext::requireListElement(size_t i) {
  return getRuleContext<MySQLParser::RequireListElementContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::RequireListContext::AND_SYMBOL() {
  return getTokens(MySQLParser::AND_SYMBOL);
}

tree::TerminalNode* MySQLParser::RequireListContext::AND_SYMBOL(size_t i) {
  return getToken(MySQLParser::AND_SYMBOL, i);
}


size_t MySQLParser::RequireListContext::getRuleIndex() const {
  return MySQLParser::RuleRequireList;
}

void MySQLParser::RequireListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRequireList(this);
}

void MySQLParser::RequireListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRequireList(this);
}


std::any MySQLParser::RequireListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRequireList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RequireListContext* MySQLParser::requireList() {
  RequireListContext *_localctx = _tracker.createInstance<RequireListContext>(_ctx, getState());
  enterRule(_localctx, 688, MySQLParser::RuleRequireList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(5478);
    requireListElement();
    setState(5485);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 618, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(5480);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::AND_SYMBOL) {
          setState(5479);
          match(MySQLParser::AND_SYMBOL);
        }
        setState(5482);
        requireListElement(); 
      }
      setState(5487);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 618, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RequireListElementContext ------------------------------------------------------------------

MySQLParser::RequireListElementContext::RequireListElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringContext* MySQLParser::RequireListElementContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::RequireListElementContext::CIPHER_SYMBOL() {
  return getToken(MySQLParser::CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RequireListElementContext::ISSUER_SYMBOL() {
  return getToken(MySQLParser::ISSUER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RequireListElementContext::SUBJECT_SYMBOL() {
  return getToken(MySQLParser::SUBJECT_SYMBOL, 0);
}


size_t MySQLParser::RequireListElementContext::getRuleIndex() const {
  return MySQLParser::RuleRequireListElement;
}

void MySQLParser::RequireListElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRequireListElement(this);
}

void MySQLParser::RequireListElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRequireListElement(this);
}


std::any MySQLParser::RequireListElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRequireListElement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RequireListElementContext* MySQLParser::requireListElement() {
  RequireListElementContext *_localctx = _tracker.createInstance<RequireListElementContext>(_ctx, getState());
  enterRule(_localctx, 690, MySQLParser::RuleRequireListElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5494);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CIPHER_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5488);
        antlrcpp::downCast<RequireListElementContext *>(_localctx)->element = match(MySQLParser::CIPHER_SYMBOL);
        setState(5489);
        textString();
        break;
      }

      case MySQLParser::ISSUER_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5490);
        antlrcpp::downCast<RequireListElementContext *>(_localctx)->element = match(MySQLParser::ISSUER_SYMBOL);
        setState(5491);
        textString();
        break;
      }

      case MySQLParser::SUBJECT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(5492);
        antlrcpp::downCast<RequireListElementContext *>(_localctx)->element = match(MySQLParser::SUBJECT_SYMBOL);
        setState(5493);
        textString();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GrantOptionContext ------------------------------------------------------------------

MySQLParser::GrantOptionContext::GrantOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GrantOptionContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantOptionContext::GRANT_SYMBOL() {
  return getToken(MySQLParser::GRANT_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::GrantOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::GrantOptionContext::MAX_QUERIES_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantOptionContext::MAX_UPDATES_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantOptionContext::MAX_CONNECTIONS_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantOptionContext::MAX_USER_CONNECTIONS_SYMBOL() {
  return getToken(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL, 0);
}


size_t MySQLParser::GrantOptionContext::getRuleIndex() const {
  return MySQLParser::RuleGrantOption;
}

void MySQLParser::GrantOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGrantOption(this);
}

void MySQLParser::GrantOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGrantOption(this);
}


std::any MySQLParser::GrantOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGrantOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GrantOptionContext* MySQLParser::grantOption() {
  GrantOptionContext *_localctx = _tracker.createInstance<GrantOptionContext>(_ctx, getState());
  enterRule(_localctx, 692, MySQLParser::RuleGrantOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5509);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 621, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5496);
      antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::GRANT_SYMBOL);
      setState(5497);
      match(MySQLParser::OPTION_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5498);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(5507);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL: {
          setState(5499);
          antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL);
          setState(5500);
          ulong_number();
          break;
        }

        case MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL: {
          setState(5501);
          antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL);
          setState(5502);
          ulong_number();
          break;
        }

        case MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL: {
          setState(5503);
          antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL);
          setState(5504);
          ulong_number();
          break;
        }

        case MySQLParser::MAX_USER_CONNECTIONS_SYMBOL: {
          setState(5505);
          antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL);
          setState(5506);
          ulong_number();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetRoleStatementContext ------------------------------------------------------------------

MySQLParser::SetRoleStatementContext::SetRoleStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

std::vector<MySQLParser::RoleListContext *> MySQLParser::SetRoleStatementContext::roleList() {
  return getRuleContexts<MySQLParser::RoleListContext>();
}

MySQLParser::RoleListContext* MySQLParser::SetRoleStatementContext::roleList(size_t i) {
  return getRuleContext<MySQLParser::RoleListContext>(i);
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetRoleStatementContext::EXCEPT_SYMBOL() {
  return getToken(MySQLParser::EXCEPT_SYMBOL, 0);
}


size_t MySQLParser::SetRoleStatementContext::getRuleIndex() const {
  return MySQLParser::RuleSetRoleStatement;
}

void MySQLParser::SetRoleStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSetRoleStatement(this);
}

void MySQLParser::SetRoleStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSetRoleStatement(this);
}


std::any MySQLParser::SetRoleStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSetRoleStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SetRoleStatementContext* MySQLParser::setRoleStatement() {
  SetRoleStatementContext *_localctx = _tracker.createInstance<SetRoleStatementContext>(_ctx, getState());
  enterRule(_localctx, 694, MySQLParser::RuleSetRoleStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5534);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 624, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5511);
      match(MySQLParser::SET_SYMBOL);
      setState(5512);
      match(MySQLParser::ROLE_SYMBOL);
      setState(5513);
      roleList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5514);
      match(MySQLParser::SET_SYMBOL);
      setState(5515);
      match(MySQLParser::ROLE_SYMBOL);
      setState(5516);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DEFAULT_SYMBOL || _la == MySQLParser::NONE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5517);
      match(MySQLParser::SET_SYMBOL);
      setState(5518);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(5519);
      match(MySQLParser::ROLE_SYMBOL);
      setState(5523);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 622, _ctx)) {
      case 1: {
        setState(5520);
        roleList();
        break;
      }

      case 2: {
        setState(5521);
        match(MySQLParser::NONE_SYMBOL);
        break;
      }

      case 3: {
        setState(5522);
        match(MySQLParser::ALL_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5525);
      match(MySQLParser::TO_SYMBOL);
      setState(5526);
      roleList();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5527);
      match(MySQLParser::SET_SYMBOL);
      setState(5528);
      match(MySQLParser::ROLE_SYMBOL);
      setState(5529);
      match(MySQLParser::ALL_SYMBOL);
      setState(5532);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXCEPT_SYMBOL) {
        setState(5530);
        match(MySQLParser::EXCEPT_SYMBOL);
        setState(5531);
        roleList();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleListContext ------------------------------------------------------------------

MySQLParser::RoleListContext::RoleListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::RoleContext *> MySQLParser::RoleListContext::role() {
  return getRuleContexts<MySQLParser::RoleContext>();
}

MySQLParser::RoleContext* MySQLParser::RoleListContext::role(size_t i) {
  return getRuleContext<MySQLParser::RoleContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::RoleListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::RoleListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::RoleListContext::getRuleIndex() const {
  return MySQLParser::RuleRoleList;
}

void MySQLParser::RoleListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleList(this);
}

void MySQLParser::RoleListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleList(this);
}


std::any MySQLParser::RoleListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleListContext* MySQLParser::roleList() {
  RoleListContext *_localctx = _tracker.createInstance<RoleListContext>(_ctx, getState());
  enterRule(_localctx, 696, MySQLParser::RuleRoleList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(5536);
    role();
    setState(5541);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 625, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(5537);
        match(MySQLParser::COMMA_SYMBOL);
        setState(5538);
        role(); 
      }
      setState(5543);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 625, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleContext ------------------------------------------------------------------

MySQLParser::RoleContext::RoleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoleIdentifierOrTextContext* MySQLParser::RoleContext::roleIdentifierOrText() {
  return getRuleContext<MySQLParser::RoleIdentifierOrTextContext>(0);
}

tree::TerminalNode* MySQLParser::RoleContext::AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::RoleContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::RoleContext::SIMPLE_IDENTIFIER() {
  return getToken(MySQLParser::SIMPLE_IDENTIFIER, 0);
}


size_t MySQLParser::RoleContext::getRuleIndex() const {
  return MySQLParser::RuleRole;
}

void MySQLParser::RoleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRole(this);
}

void MySQLParser::RoleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRole(this);
}


std::any MySQLParser::RoleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRole(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleContext* MySQLParser::role() {
  RoleContext *_localctx = _tracker.createInstance<RoleContext>(_ctx, getState());
  enterRule(_localctx, 698, MySQLParser::RuleRole);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5544);
    roleIdentifierOrText();
    setState(5550);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 627, _ctx)) {
    case 1: {
      setState(5545);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(5548);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 626, _ctx)) {
      case 1: {
        setState(5546);
        textOrIdentifier();
        break;
      }

      case 2: {
        setState(5547);
        match(MySQLParser::SIMPLE_IDENTIFIER);
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableAdministrationStatementContext ------------------------------------------------------------------

MySQLParser::TableAdministrationStatementContext::TableAdministrationStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableRefListContext* MySQLParser::TableAdministrationStatementContext::tableRefList() {
  return getRuleContext<MySQLParser::TableRefListContext>(0);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::ANALYZE_SYMBOL() {
  return getToken(MySQLParser::ANALYZE_SYMBOL, 0);
}

MySQLParser::NoWriteToBinLogContext* MySQLParser::TableAdministrationStatementContext::noWriteToBinLog() {
  return getRuleContext<MySQLParser::NoWriteToBinLogContext>(0);
}

MySQLParser::HistogramContext* MySQLParser::TableAdministrationStatementContext::histogram() {
  return getRuleContext<MySQLParser::HistogramContext>(0);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::CHECK_SYMBOL() {
  return getToken(MySQLParser::CHECK_SYMBOL, 0);
}

std::vector<MySQLParser::CheckOptionContext *> MySQLParser::TableAdministrationStatementContext::checkOption() {
  return getRuleContexts<MySQLParser::CheckOptionContext>();
}

MySQLParser::CheckOptionContext* MySQLParser::TableAdministrationStatementContext::checkOption(size_t i) {
  return getRuleContext<MySQLParser::CheckOptionContext>(i);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::QUICK_SYMBOL() {
  return getToken(MySQLParser::QUICK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::OPTIMIZE_SYMBOL() {
  return getToken(MySQLParser::OPTIMIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableAdministrationStatementContext::REPAIR_SYMBOL() {
  return getToken(MySQLParser::REPAIR_SYMBOL, 0);
}

std::vector<MySQLParser::RepairTypeContext *> MySQLParser::TableAdministrationStatementContext::repairType() {
  return getRuleContexts<MySQLParser::RepairTypeContext>();
}

MySQLParser::RepairTypeContext* MySQLParser::TableAdministrationStatementContext::repairType(size_t i) {
  return getRuleContext<MySQLParser::RepairTypeContext>(i);
}


size_t MySQLParser::TableAdministrationStatementContext::getRuleIndex() const {
  return MySQLParser::RuleTableAdministrationStatement;
}

void MySQLParser::TableAdministrationStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableAdministrationStatement(this);
}

void MySQLParser::TableAdministrationStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableAdministrationStatement(this);
}


std::any MySQLParser::TableAdministrationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableAdministrationStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableAdministrationStatementContext* MySQLParser::tableAdministrationStatement() {
  TableAdministrationStatementContext *_localctx = _tracker.createInstance<TableAdministrationStatementContext>(_ctx, getState());
  enterRule(_localctx, 700, MySQLParser::RuleTableAdministrationStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5595);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ANALYZE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5552);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::ANALYZE_SYMBOL);
        setState(5554);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
          setState(5553);
          noWriteToBinLog();
        }
        setState(5556);
        match(MySQLParser::TABLE_SYMBOL);
        setState(5557);
        tableRefList();
        setState(5560);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 629, _ctx)) {
        case 1: {
          setState(5558);

          if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
          setState(5559);
          histogram();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::CHECK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5562);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::CHECK_SYMBOL);
        setState(5563);
        match(MySQLParser::TABLE_SYMBOL);
        setState(5564);
        tableRefList();
        setState(5568);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::CHANGED_SYMBOL || ((((_la - 219) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 219)) & ((1ULL << (MySQLParser::EXTENDED_SYMBOL - 219))
          | (1ULL << (MySQLParser::FAST_SYMBOL - 219))
          | (1ULL << (MySQLParser::FOR_SYMBOL - 219)))) != 0) || _la == MySQLParser::MEDIUM_SYMBOL || _la == MySQLParser::QUICK_SYMBOL) {
          setState(5565);
          checkOption();
          setState(5570);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case MySQLParser::CHECKSUM_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(5571);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::CHECKSUM_SYMBOL);
        setState(5572);
        match(MySQLParser::TABLE_SYMBOL);
        setState(5573);
        tableRefList();
        setState(5575);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL) {
          setState(5574);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        break;
      }

      case MySQLParser::OPTIMIZE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(5577);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::OPTIMIZE_SYMBOL);
        setState(5579);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
          setState(5578);
          noWriteToBinLog();
        }
        setState(5581);
        match(MySQLParser::TABLE_SYMBOL);
        setState(5582);
        tableRefList();
        break;
      }

      case MySQLParser::REPAIR_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(5583);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::REPAIR_SYMBOL);
        setState(5585);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
          setState(5584);
          noWriteToBinLog();
        }
        setState(5587);
        match(MySQLParser::TABLE_SYMBOL);
        setState(5588);
        tableRefList();
        setState(5592);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL || _la == MySQLParser::USE_FRM_SYMBOL) {
          setState(5589);
          repairType();
          setState(5594);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HistogramAutoUpdateContext ------------------------------------------------------------------

MySQLParser::HistogramAutoUpdateContext::HistogramAutoUpdateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HistogramAutoUpdateContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HistogramAutoUpdateContext::MANUAL_SYMBOL() {
  return getToken(MySQLParser::MANUAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HistogramAutoUpdateContext::AUTO_SYMBOL() {
  return getToken(MySQLParser::AUTO_SYMBOL, 0);
}


size_t MySQLParser::HistogramAutoUpdateContext::getRuleIndex() const {
  return MySQLParser::RuleHistogramAutoUpdate;
}

void MySQLParser::HistogramAutoUpdateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHistogramAutoUpdate(this);
}

void MySQLParser::HistogramAutoUpdateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHistogramAutoUpdate(this);
}


std::any MySQLParser::HistogramAutoUpdateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHistogramAutoUpdate(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HistogramAutoUpdateContext* MySQLParser::histogramAutoUpdate() {
  HistogramAutoUpdateContext *_localctx = _tracker.createInstance<HistogramAutoUpdateContext>(_ctx, getState());
  enterRule(_localctx, 702, MySQLParser::RuleHistogramAutoUpdate);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5597);

    if (!(serverVersion >= 80400)) throw FailedPredicateException(this, "serverVersion >= 80400");
    setState(5598);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::AUTO_SYMBOL

    || _la == MySQLParser::MANUAL_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5599);
    match(MySQLParser::UPDATE_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HistogramUpdateParamContext ------------------------------------------------------------------

MySQLParser::HistogramUpdateParamContext::HistogramUpdateParamContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::HistogramNumBucketsContext* MySQLParser::HistogramUpdateParamContext::histogramNumBuckets() {
  return getRuleContext<MySQLParser::HistogramNumBucketsContext>(0);
}

MySQLParser::HistogramAutoUpdateContext* MySQLParser::HistogramUpdateParamContext::histogramAutoUpdate() {
  return getRuleContext<MySQLParser::HistogramAutoUpdateContext>(0);
}

tree::TerminalNode* MySQLParser::HistogramUpdateParamContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HistogramUpdateParamContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::HistogramUpdateParamContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::HistogramUpdateParamContext::getRuleIndex() const {
  return MySQLParser::RuleHistogramUpdateParam;
}

void MySQLParser::HistogramUpdateParamContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHistogramUpdateParam(this);
}

void MySQLParser::HistogramUpdateParamContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHistogramUpdateParam(this);
}


std::any MySQLParser::HistogramUpdateParamContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHistogramUpdateParam(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HistogramUpdateParamContext* MySQLParser::histogramUpdateParam() {
  HistogramUpdateParamContext *_localctx = _tracker.createInstance<HistogramUpdateParamContext>(_ctx, getState());
  enterRule(_localctx, 704, MySQLParser::RuleHistogramUpdateParam);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5611);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 638, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5602);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 636, _ctx)) {
      case 1: {
        setState(5601);
        histogramNumBuckets();
        break;
      }

      default:
        break;
      }
      setState(5605);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 637, _ctx)) {
      case 1: {
        setState(5604);
        histogramAutoUpdate();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5607);

      if (!(serverVersion >= 80031)) throw FailedPredicateException(this, "serverVersion >= 80031");
      setState(5608);
      match(MySQLParser::USING_SYMBOL);
      setState(5609);
      match(MySQLParser::DATA_SYMBOL);
      setState(5610);
      textStringLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HistogramNumBucketsContext ------------------------------------------------------------------

MySQLParser::HistogramNumBucketsContext::HistogramNumBucketsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HistogramNumBucketsContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HistogramNumBucketsContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::HistogramNumBucketsContext::BUCKETS_SYMBOL() {
  return getToken(MySQLParser::BUCKETS_SYMBOL, 0);
}


size_t MySQLParser::HistogramNumBucketsContext::getRuleIndex() const {
  return MySQLParser::RuleHistogramNumBuckets;
}

void MySQLParser::HistogramNumBucketsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHistogramNumBuckets(this);
}

void MySQLParser::HistogramNumBucketsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHistogramNumBuckets(this);
}


std::any MySQLParser::HistogramNumBucketsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHistogramNumBuckets(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HistogramNumBucketsContext* MySQLParser::histogramNumBuckets() {
  HistogramNumBucketsContext *_localctx = _tracker.createInstance<HistogramNumBucketsContext>(_ctx, getState());
  enterRule(_localctx, 706, MySQLParser::RuleHistogramNumBuckets);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5613);
    match(MySQLParser::WITH_SYMBOL);
    setState(5614);
    match(MySQLParser::INT_NUMBER);
    setState(5615);
    match(MySQLParser::BUCKETS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HistogramContext ------------------------------------------------------------------

MySQLParser::HistogramContext::HistogramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HistogramContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HistogramContext::HISTOGRAM_SYMBOL() {
  return getToken(MySQLParser::HISTOGRAM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HistogramContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::HistogramContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

MySQLParser::HistogramUpdateParamContext* MySQLParser::HistogramContext::histogramUpdateParam() {
  return getRuleContext<MySQLParser::HistogramUpdateParamContext>(0);
}

tree::TerminalNode* MySQLParser::HistogramContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}


size_t MySQLParser::HistogramContext::getRuleIndex() const {
  return MySQLParser::RuleHistogram;
}

void MySQLParser::HistogramContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHistogram(this);
}

void MySQLParser::HistogramContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHistogram(this);
}


std::any MySQLParser::HistogramContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHistogram(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HistogramContext* MySQLParser::histogram() {
  HistogramContext *_localctx = _tracker.createInstance<HistogramContext>(_ctx, getState());
  enterRule(_localctx, 708, MySQLParser::RuleHistogram);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5627);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UPDATE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5617);
        match(MySQLParser::UPDATE_SYMBOL);
        setState(5618);
        match(MySQLParser::HISTOGRAM_SYMBOL);
        setState(5619);
        match(MySQLParser::ON_SYMBOL);
        setState(5620);
        identifierList();
        setState(5621);
        histogramUpdateParam();
        break;
      }

      case MySQLParser::DROP_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5623);
        match(MySQLParser::DROP_SYMBOL);
        setState(5624);
        match(MySQLParser::HISTOGRAM_SYMBOL);
        setState(5625);
        match(MySQLParser::ON_SYMBOL);
        setState(5626);
        identifierList();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CheckOptionContext ------------------------------------------------------------------

MySQLParser::CheckOptionContext::CheckOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CheckOptionContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CheckOptionContext::UPGRADE_SYMBOL() {
  return getToken(MySQLParser::UPGRADE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CheckOptionContext::QUICK_SYMBOL() {
  return getToken(MySQLParser::QUICK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CheckOptionContext::FAST_SYMBOL() {
  return getToken(MySQLParser::FAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CheckOptionContext::MEDIUM_SYMBOL() {
  return getToken(MySQLParser::MEDIUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CheckOptionContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CheckOptionContext::CHANGED_SYMBOL() {
  return getToken(MySQLParser::CHANGED_SYMBOL, 0);
}


size_t MySQLParser::CheckOptionContext::getRuleIndex() const {
  return MySQLParser::RuleCheckOption;
}

void MySQLParser::CheckOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCheckOption(this);
}

void MySQLParser::CheckOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCheckOption(this);
}


std::any MySQLParser::CheckOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCheckOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CheckOptionContext* MySQLParser::checkOption() {
  CheckOptionContext *_localctx = _tracker.createInstance<CheckOptionContext>(_ctx, getState());
  enterRule(_localctx, 710, MySQLParser::RuleCheckOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5632);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FOR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5629);
        match(MySQLParser::FOR_SYMBOL);
        setState(5630);
        match(MySQLParser::UPGRADE_SYMBOL);
        break;
      }

      case MySQLParser::CHANGED_SYMBOL:
      case MySQLParser::EXTENDED_SYMBOL:
      case MySQLParser::FAST_SYMBOL:
      case MySQLParser::MEDIUM_SYMBOL:
      case MySQLParser::QUICK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5631);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::CHANGED_SYMBOL || _la == MySQLParser::EXTENDED_SYMBOL

        || _la == MySQLParser::FAST_SYMBOL || _la == MySQLParser::MEDIUM_SYMBOL || _la == MySQLParser::QUICK_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RepairTypeContext ------------------------------------------------------------------

MySQLParser::RepairTypeContext::RepairTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RepairTypeContext::QUICK_SYMBOL() {
  return getToken(MySQLParser::QUICK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RepairTypeContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RepairTypeContext::USE_FRM_SYMBOL() {
  return getToken(MySQLParser::USE_FRM_SYMBOL, 0);
}


size_t MySQLParser::RepairTypeContext::getRuleIndex() const {
  return MySQLParser::RuleRepairType;
}

void MySQLParser::RepairTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRepairType(this);
}

void MySQLParser::RepairTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRepairType(this);
}


std::any MySQLParser::RepairTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRepairType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RepairTypeContext* MySQLParser::repairType() {
  RepairTypeContext *_localctx = _tracker.createInstance<RepairTypeContext>(_ctx, getState());
  enterRule(_localctx, 712, MySQLParser::RuleRepairType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5634);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL || _la == MySQLParser::USE_FRM_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UninstallStatementContext ------------------------------------------------------------------

MySQLParser::UninstallStatementContext::UninstallStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UninstallStatementContext::UNINSTALL_SYMBOL() {
  return getToken(MySQLParser::UNINSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UninstallStatementContext::PLUGIN_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_SYMBOL, 0);
}

MySQLParser::PluginRefContext* MySQLParser::UninstallStatementContext::pluginRef() {
  return getRuleContext<MySQLParser::PluginRefContext>(0);
}

tree::TerminalNode* MySQLParser::UninstallStatementContext::COMPONENT_SYMBOL() {
  return getToken(MySQLParser::COMPONENT_SYMBOL, 0);
}

std::vector<MySQLParser::ComponentRefContext *> MySQLParser::UninstallStatementContext::componentRef() {
  return getRuleContexts<MySQLParser::ComponentRefContext>();
}

MySQLParser::ComponentRefContext* MySQLParser::UninstallStatementContext::componentRef(size_t i) {
  return getRuleContext<MySQLParser::ComponentRefContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::UninstallStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::UninstallStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::UninstallStatementContext::getRuleIndex() const {
  return MySQLParser::RuleUninstallStatement;
}

void MySQLParser::UninstallStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUninstallStatement(this);
}

void MySQLParser::UninstallStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUninstallStatement(this);
}


std::any MySQLParser::UninstallStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUninstallStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UninstallStatementContext* MySQLParser::uninstallStatement() {
  UninstallStatementContext *_localctx = _tracker.createInstance<UninstallStatementContext>(_ctx, getState());
  enterRule(_localctx, 714, MySQLParser::RuleUninstallStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5636);
    match(MySQLParser::UNINSTALL_SYMBOL);
    setState(5648);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PLUGIN_SYMBOL: {
        setState(5637);
        match(MySQLParser::PLUGIN_SYMBOL);
        setState(5638);
        pluginRef();
        break;
      }

      case MySQLParser::COMPONENT_SYMBOL: {
        setState(5639);
        match(MySQLParser::COMPONENT_SYMBOL);
        setState(5640);
        componentRef();
        setState(5645);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::COMMA_SYMBOL) {
          setState(5641);
          match(MySQLParser::COMMA_SYMBOL);
          setState(5642);
          componentRef();
          setState(5647);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InstallStatementContext ------------------------------------------------------------------

MySQLParser::InstallStatementContext::InstallStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InstallStatementContext::INSTALL_SYMBOL() {
  return getToken(MySQLParser::INSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InstallStatementContext::PLUGIN_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::InstallStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::InstallStatementContext::SONAME_SYMBOL() {
  return getToken(MySQLParser::SONAME_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::InstallStatementContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::InstallStatementContext::COMPONENT_SYMBOL() {
  return getToken(MySQLParser::COMPONENT_SYMBOL, 0);
}

MySQLParser::TextStringLiteralListContext* MySQLParser::InstallStatementContext::textStringLiteralList() {
  return getRuleContext<MySQLParser::TextStringLiteralListContext>(0);
}

MySQLParser::InstallSetValueListContext* MySQLParser::InstallStatementContext::installSetValueList() {
  return getRuleContext<MySQLParser::InstallSetValueListContext>(0);
}


size_t MySQLParser::InstallStatementContext::getRuleIndex() const {
  return MySQLParser::RuleInstallStatement;
}

void MySQLParser::InstallStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInstallStatement(this);
}

void MySQLParser::InstallStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInstallStatement(this);
}


std::any MySQLParser::InstallStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInstallStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InstallStatementContext* MySQLParser::installStatement() {
  InstallStatementContext *_localctx = _tracker.createInstance<InstallStatementContext>(_ctx, getState());
  enterRule(_localctx, 716, MySQLParser::RuleInstallStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5650);
    match(MySQLParser::INSTALL_SYMBOL);
    setState(5661);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PLUGIN_SYMBOL: {
        setState(5651);
        match(MySQLParser::PLUGIN_SYMBOL);
        setState(5652);
        identifier();
        setState(5653);
        match(MySQLParser::SONAME_SYMBOL);
        setState(5654);
        textStringLiteral();
        break;
      }

      case MySQLParser::COMPONENT_SYMBOL: {
        setState(5656);
        match(MySQLParser::COMPONENT_SYMBOL);
        setState(5657);
        textStringLiteralList();
        setState(5659);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 643, _ctx)) {
        case 1: {
          setState(5658);
          installSetValueList();
          break;
        }

        default:
          break;
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InstallOptionTypeContext ------------------------------------------------------------------

MySQLParser::InstallOptionTypeContext::InstallOptionTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InstallOptionTypeContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InstallOptionTypeContext::PERSIST_SYMBOL() {
  return getToken(MySQLParser::PERSIST_SYMBOL, 0);
}


size_t MySQLParser::InstallOptionTypeContext::getRuleIndex() const {
  return MySQLParser::RuleInstallOptionType;
}

void MySQLParser::InstallOptionTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInstallOptionType(this);
}

void MySQLParser::InstallOptionTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInstallOptionType(this);
}


std::any MySQLParser::InstallOptionTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInstallOptionType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InstallOptionTypeContext* MySQLParser::installOptionType() {
  InstallOptionTypeContext *_localctx = _tracker.createInstance<InstallOptionTypeContext>(_ctx, getState());
  enterRule(_localctx, 718, MySQLParser::RuleInstallOptionType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5663);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::GLOBAL_SYMBOL || _la == MySQLParser::PERSIST_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InstallSetRvalueContext ------------------------------------------------------------------

MySQLParser::InstallSetRvalueContext::InstallSetRvalueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::InstallSetRvalueContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::InstallSetRvalueContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}


size_t MySQLParser::InstallSetRvalueContext::getRuleIndex() const {
  return MySQLParser::RuleInstallSetRvalue;
}

void MySQLParser::InstallSetRvalueContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInstallSetRvalue(this);
}

void MySQLParser::InstallSetRvalueContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInstallSetRvalue(this);
}


std::any MySQLParser::InstallSetRvalueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInstallSetRvalue(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InstallSetRvalueContext* MySQLParser::installSetRvalue() {
  InstallSetRvalueContext *_localctx = _tracker.createInstance<InstallSetRvalueContext>(_ctx, getState());
  enterRule(_localctx, 720, MySQLParser::RuleInstallSetRvalue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5667);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 645, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5665);
      expr(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5666);
      match(MySQLParser::ON_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InstallSetValueContext ------------------------------------------------------------------

MySQLParser::InstallSetValueContext::InstallSetValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::InstallOptionTypeContext* MySQLParser::InstallSetValueContext::installOptionType() {
  return getRuleContext<MySQLParser::InstallOptionTypeContext>(0);
}

MySQLParser::LvalueVariableContext* MySQLParser::InstallSetValueContext::lvalueVariable() {
  return getRuleContext<MySQLParser::LvalueVariableContext>(0);
}

MySQLParser::EqualContext* MySQLParser::InstallSetValueContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::InstallSetRvalueContext* MySQLParser::InstallSetValueContext::installSetRvalue() {
  return getRuleContext<MySQLParser::InstallSetRvalueContext>(0);
}


size_t MySQLParser::InstallSetValueContext::getRuleIndex() const {
  return MySQLParser::RuleInstallSetValue;
}

void MySQLParser::InstallSetValueContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInstallSetValue(this);
}

void MySQLParser::InstallSetValueContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInstallSetValue(this);
}


std::any MySQLParser::InstallSetValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInstallSetValue(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InstallSetValueContext* MySQLParser::installSetValue() {
  InstallSetValueContext *_localctx = _tracker.createInstance<InstallSetValueContext>(_ctx, getState());
  enterRule(_localctx, 722, MySQLParser::RuleInstallSetValue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5669);
    installOptionType();
    setState(5670);
    lvalueVariable();
    setState(5671);
    equal();
    setState(5672);
    installSetRvalue();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InstallSetValueListContext ------------------------------------------------------------------

MySQLParser::InstallSetValueListContext::InstallSetValueListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InstallSetValueListContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

std::vector<MySQLParser::InstallSetValueContext *> MySQLParser::InstallSetValueListContext::installSetValue() {
  return getRuleContexts<MySQLParser::InstallSetValueContext>();
}

MySQLParser::InstallSetValueContext* MySQLParser::InstallSetValueListContext::installSetValue(size_t i) {
  return getRuleContext<MySQLParser::InstallSetValueContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::InstallSetValueListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::InstallSetValueListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::InstallSetValueListContext::getRuleIndex() const {
  return MySQLParser::RuleInstallSetValueList;
}

void MySQLParser::InstallSetValueListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInstallSetValueList(this);
}

void MySQLParser::InstallSetValueListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInstallSetValueList(this);
}


std::any MySQLParser::InstallSetValueListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInstallSetValueList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InstallSetValueListContext* MySQLParser::installSetValueList() {
  InstallSetValueListContext *_localctx = _tracker.createInstance<InstallSetValueListContext>(_ctx, getState());
  enterRule(_localctx, 724, MySQLParser::RuleInstallSetValueList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5674);

    if (!(serverVersion >= 80032)) throw FailedPredicateException(this, "serverVersion >= 80032");
    setState(5675);
    match(MySQLParser::SET_SYMBOL);
    setState(5676);
    installSetValue();
    setState(5681);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5677);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5678);
      installSetValue();
      setState(5683);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetStatementContext ------------------------------------------------------------------

MySQLParser::SetStatementContext::SetStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SetStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

MySQLParser::StartOptionValueListContext* MySQLParser::SetStatementContext::startOptionValueList() {
  return getRuleContext<MySQLParser::StartOptionValueListContext>(0);
}


size_t MySQLParser::SetStatementContext::getRuleIndex() const {
  return MySQLParser::RuleSetStatement;
}

void MySQLParser::SetStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSetStatement(this);
}

void MySQLParser::SetStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSetStatement(this);
}


std::any MySQLParser::SetStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSetStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SetStatementContext* MySQLParser::setStatement() {
  SetStatementContext *_localctx = _tracker.createInstance<SetStatementContext>(_ctx, getState());
  enterRule(_localctx, 726, MySQLParser::RuleSetStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5684);
    match(MySQLParser::SET_SYMBOL);
    setState(5685);
    startOptionValueList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StartOptionValueListContext ------------------------------------------------------------------

MySQLParser::StartOptionValueListContext::StartOptionValueListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OptionValueNoOptionTypeContext* MySQLParser::StartOptionValueListContext::optionValueNoOptionType() {
  return getRuleContext<MySQLParser::OptionValueNoOptionTypeContext>(0);
}

MySQLParser::OptionValueListContinuedContext* MySQLParser::StartOptionValueListContext::optionValueListContinued() {
  return getRuleContext<MySQLParser::OptionValueListContinuedContext>(0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::TRANSACTION_SYMBOL() {
  return getToken(MySQLParser::TRANSACTION_SYMBOL, 0);
}

MySQLParser::TransactionCharacteristicsContext* MySQLParser::StartOptionValueListContext::transactionCharacteristics() {
  return getRuleContext<MySQLParser::TransactionCharacteristicsContext>(0);
}

MySQLParser::OptionTypeContext* MySQLParser::StartOptionValueListContext::optionType() {
  return getRuleContext<MySQLParser::OptionTypeContext>(0);
}

MySQLParser::StartOptionValueListFollowingOptionTypeContext* MySQLParser::StartOptionValueListContext::startOptionValueListFollowingOptionType() {
  return getRuleContext<MySQLParser::StartOptionValueListFollowingOptionTypeContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::StartOptionValueListContext::PASSWORD_SYMBOL() {
  return getTokens(MySQLParser::PASSWORD_SYMBOL);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::PASSWORD_SYMBOL(size_t i) {
  return getToken(MySQLParser::PASSWORD_SYMBOL, i);
}

MySQLParser::EqualContext* MySQLParser::StartOptionValueListContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::TextStringContext* MySQLParser::StartOptionValueListContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::OLD_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::OLD_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::StartOptionValueListContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

MySQLParser::ReplacePasswordContext* MySQLParser::StartOptionValueListContext::replacePassword() {
  return getRuleContext<MySQLParser::ReplacePasswordContext>(0);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::StartOptionValueListContext::retainCurrentPassword() {
  return getRuleContext<MySQLParser::RetainCurrentPasswordContext>(0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::TO_SYMBOL() {
  return getToken(MySQLParser::TO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}


size_t MySQLParser::StartOptionValueListContext::getRuleIndex() const {
  return MySQLParser::RuleStartOptionValueList;
}

void MySQLParser::StartOptionValueListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStartOptionValueList(this);
}

void MySQLParser::StartOptionValueListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStartOptionValueList(this);
}


std::any MySQLParser::StartOptionValueListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStartOptionValueList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StartOptionValueListContext* MySQLParser::startOptionValueList() {
  StartOptionValueListContext *_localctx = _tracker.createInstance<StartOptionValueListContext>(_ctx, getState());
  enterRule(_localctx, 728, MySQLParser::RuleStartOptionValueList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5743);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 656, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5687);
      optionValueNoOptionType();
      setState(5688);
      optionValueListContinued();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5690);
      match(MySQLParser::TRANSACTION_SYMBOL);
      setState(5691);
      transactionCharacteristics();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5692);
      optionType();
      setState(5693);
      startOptionValueListFollowingOptionType();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5695);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(5698);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(5696);
        match(MySQLParser::FOR_SYMBOL);
        setState(5697);
        user();
      }
      setState(5700);
      equal();
      setState(5727);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 652, _ctx)) {
      case 1: {
        setState(5701);
        textString();
        setState(5703);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REPLACE_SYMBOL) {
          setState(5702);
          replacePassword();
        }
        setState(5706);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::RETAIN_SYMBOL) {
          setState(5705);
          retainCurrentPassword();
        }
        break;
      }

      case 2: {
        setState(5708);
        textString();
        setState(5710);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REPLACE_SYMBOL) {
          setState(5709);
          replacePassword();
        }
        setState(5713);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::RETAIN_SYMBOL) {
          setState(5712);
          retainCurrentPassword();
        }
        break;
      }

      case 3: {
        setState(5715);

        if (!(serverVersion < 50706)) throw FailedPredicateException(this, "serverVersion < 50706");
        setState(5716);
        match(MySQLParser::OLD_PASSWORD_SYMBOL);
        setState(5717);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(5718);
        textString();
        setState(5719);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case 4: {
        setState(5721);

        if (!(serverVersion < 80014)) throw FailedPredicateException(this, "serverVersion < 80014");
        setState(5722);
        match(MySQLParser::PASSWORD_SYMBOL);
        setState(5723);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(5724);
        textString();
        setState(5725);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5729);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(5730);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(5733);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(5731);
        match(MySQLParser::FOR_SYMBOL);
        setState(5732);
        user();
      }
      setState(5735);
      match(MySQLParser::TO_SYMBOL);
      setState(5736);
      match(MySQLParser::RANDOM_SYMBOL);
      setState(5738);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::REPLACE_SYMBOL) {
        setState(5737);
        replacePassword();
      }
      setState(5741);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::RETAIN_SYMBOL) {
        setState(5740);
        retainCurrentPassword();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TransactionCharacteristicsContext ------------------------------------------------------------------

MySQLParser::TransactionCharacteristicsContext::TransactionCharacteristicsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TransactionAccessModeContext* MySQLParser::TransactionCharacteristicsContext::transactionAccessMode() {
  return getRuleContext<MySQLParser::TransactionAccessModeContext>(0);
}

MySQLParser::IsolationLevelContext* MySQLParser::TransactionCharacteristicsContext::isolationLevel() {
  return getRuleContext<MySQLParser::IsolationLevelContext>(0);
}

tree::TerminalNode* MySQLParser::TransactionCharacteristicsContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}


size_t MySQLParser::TransactionCharacteristicsContext::getRuleIndex() const {
  return MySQLParser::RuleTransactionCharacteristics;
}

void MySQLParser::TransactionCharacteristicsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTransactionCharacteristics(this);
}

void MySQLParser::TransactionCharacteristicsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTransactionCharacteristics(this);
}


std::any MySQLParser::TransactionCharacteristicsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTransactionCharacteristics(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TransactionCharacteristicsContext* MySQLParser::transactionCharacteristics() {
  TransactionCharacteristicsContext *_localctx = _tracker.createInstance<TransactionCharacteristicsContext>(_ctx, getState());
  enterRule(_localctx, 730, MySQLParser::RuleTransactionCharacteristics);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5754);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::READ_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5745);
        transactionAccessMode();
        setState(5747);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ISOLATION_SYMBOL) {
          setState(5746);
          isolationLevel();
        }
        break;
      }

      case MySQLParser::ISOLATION_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5749);
        isolationLevel();
        setState(5752);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(5750);
          match(MySQLParser::COMMA_SYMBOL);
          setState(5751);
          transactionAccessMode();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TransactionAccessModeContext ------------------------------------------------------------------

MySQLParser::TransactionAccessModeContext::TransactionAccessModeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TransactionAccessModeContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionAccessModeContext::WRITE_SYMBOL() {
  return getToken(MySQLParser::WRITE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionAccessModeContext::ONLY_SYMBOL() {
  return getToken(MySQLParser::ONLY_SYMBOL, 0);
}


size_t MySQLParser::TransactionAccessModeContext::getRuleIndex() const {
  return MySQLParser::RuleTransactionAccessMode;
}

void MySQLParser::TransactionAccessModeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTransactionAccessMode(this);
}

void MySQLParser::TransactionAccessModeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTransactionAccessMode(this);
}


std::any MySQLParser::TransactionAccessModeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTransactionAccessMode(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TransactionAccessModeContext* MySQLParser::transactionAccessMode() {
  TransactionAccessModeContext *_localctx = _tracker.createInstance<TransactionAccessModeContext>(_ctx, getState());
  enterRule(_localctx, 732, MySQLParser::RuleTransactionAccessMode);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5756);
    match(MySQLParser::READ_SYMBOL);
    setState(5757);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ONLY_SYMBOL || _la == MySQLParser::WRITE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IsolationLevelContext ------------------------------------------------------------------

MySQLParser::IsolationLevelContext::IsolationLevelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::ISOLATION_SYMBOL() {
  return getToken(MySQLParser::ISOLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::LEVEL_SYMBOL() {
  return getToken(MySQLParser::LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::REPEATABLE_SYMBOL() {
  return getToken(MySQLParser::REPEATABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::SERIALIZABLE_SYMBOL() {
  return getToken(MySQLParser::SERIALIZABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::COMMITTED_SYMBOL() {
  return getToken(MySQLParser::COMMITTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IsolationLevelContext::UNCOMMITTED_SYMBOL() {
  return getToken(MySQLParser::UNCOMMITTED_SYMBOL, 0);
}


size_t MySQLParser::IsolationLevelContext::getRuleIndex() const {
  return MySQLParser::RuleIsolationLevel;
}

void MySQLParser::IsolationLevelContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIsolationLevel(this);
}

void MySQLParser::IsolationLevelContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIsolationLevel(this);
}


std::any MySQLParser::IsolationLevelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIsolationLevel(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IsolationLevelContext* MySQLParser::isolationLevel() {
  IsolationLevelContext *_localctx = _tracker.createInstance<IsolationLevelContext>(_ctx, getState());
  enterRule(_localctx, 734, MySQLParser::RuleIsolationLevel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5759);
    match(MySQLParser::ISOLATION_SYMBOL);
    setState(5760);
    match(MySQLParser::LEVEL_SYMBOL);
    setState(5766);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REPEATABLE_SYMBOL: {
        setState(5761);
        match(MySQLParser::REPEATABLE_SYMBOL);
        setState(5762);
        match(MySQLParser::READ_SYMBOL);
        break;
      }

      case MySQLParser::READ_SYMBOL: {
        setState(5763);
        match(MySQLParser::READ_SYMBOL);
        setState(5764);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::COMMITTED_SYMBOL || _la == MySQLParser::UNCOMMITTED_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      case MySQLParser::SERIALIZABLE_SYMBOL: {
        setState(5765);
        match(MySQLParser::SERIALIZABLE_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionValueListContinuedContext ------------------------------------------------------------------

MySQLParser::OptionValueListContinuedContext::OptionValueListContinuedContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::OptionValueListContinuedContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::OptionValueListContinuedContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

std::vector<MySQLParser::OptionValueContext *> MySQLParser::OptionValueListContinuedContext::optionValue() {
  return getRuleContexts<MySQLParser::OptionValueContext>();
}

MySQLParser::OptionValueContext* MySQLParser::OptionValueListContinuedContext::optionValue(size_t i) {
  return getRuleContext<MySQLParser::OptionValueContext>(i);
}


size_t MySQLParser::OptionValueListContinuedContext::getRuleIndex() const {
  return MySQLParser::RuleOptionValueListContinued;
}

void MySQLParser::OptionValueListContinuedContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionValueListContinued(this);
}

void MySQLParser::OptionValueListContinuedContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionValueListContinued(this);
}


std::any MySQLParser::OptionValueListContinuedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOptionValueListContinued(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OptionValueListContinuedContext* MySQLParser::optionValueListContinued() {
  OptionValueListContinuedContext *_localctx = _tracker.createInstance<OptionValueListContinuedContext>(_ctx, getState());
  enterRule(_localctx, 736, MySQLParser::RuleOptionValueListContinued);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5772);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5768);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5769);
      optionValue();
      setState(5774);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionValueNoOptionTypeContext ------------------------------------------------------------------

MySQLParser::OptionValueNoOptionTypeContext::OptionValueNoOptionTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LvalueVariableContext* MySQLParser::OptionValueNoOptionTypeContext::lvalueVariable() {
  return getRuleContext<MySQLParser::LvalueVariableContext>(0);
}

MySQLParser::EqualContext* MySQLParser::OptionValueNoOptionTypeContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::SetExprOrDefaultContext* MySQLParser::OptionValueNoOptionTypeContext::setExprOrDefault() {
  return getRuleContext<MySQLParser::SetExprOrDefaultContext>(0);
}

MySQLParser::CharsetClauseContext* MySQLParser::OptionValueNoOptionTypeContext::charsetClause() {
  return getRuleContext<MySQLParser::CharsetClauseContext>(0);
}

MySQLParser::UserVariableContext* MySQLParser::OptionValueNoOptionTypeContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

MySQLParser::ExprContext* MySQLParser::OptionValueNoOptionTypeContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::OptionValueNoOptionTypeContext::AT_SIGN_SYMBOL() {
  return getTokens(MySQLParser::AT_SIGN_SYMBOL);
}

tree::TerminalNode* MySQLParser::OptionValueNoOptionTypeContext::AT_SIGN_SYMBOL(size_t i) {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, i);
}

MySQLParser::SetVarIdentTypeContext* MySQLParser::OptionValueNoOptionTypeContext::setVarIdentType() {
  return getRuleContext<MySQLParser::SetVarIdentTypeContext>(0);
}

tree::TerminalNode* MySQLParser::OptionValueNoOptionTypeContext::NAMES_SYMBOL() {
  return getToken(MySQLParser::NAMES_SYMBOL, 0);
}

MySQLParser::CharsetNameContext* MySQLParser::OptionValueNoOptionTypeContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}

tree::TerminalNode* MySQLParser::OptionValueNoOptionTypeContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::CollateContext* MySQLParser::OptionValueNoOptionTypeContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}


size_t MySQLParser::OptionValueNoOptionTypeContext::getRuleIndex() const {
  return MySQLParser::RuleOptionValueNoOptionType;
}

void MySQLParser::OptionValueNoOptionTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionValueNoOptionType(this);
}

void MySQLParser::OptionValueNoOptionTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionValueNoOptionType(this);
}


std::any MySQLParser::OptionValueNoOptionTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOptionValueNoOptionType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OptionValueNoOptionTypeContext* MySQLParser::optionValueNoOptionType() {
  OptionValueNoOptionTypeContext *_localctx = _tracker.createInstance<OptionValueNoOptionTypeContext>(_ctx, getState());
  enterRule(_localctx, 738, MySQLParser::RuleOptionValueNoOptionType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5805);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 665, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5775);
      lvalueVariable();
      setState(5776);
      equal();
      setState(5777);
      setExprOrDefault();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5779);
      charsetClause();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5780);
      userVariable();
      setState(5781);
      equal();
      setState(5782);
      expr(0);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5784);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(5785);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(5787);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 662, _ctx)) {
      case 1: {
        setState(5786);
        setVarIdentType();
        break;
      }

      default:
        break;
      }
      setState(5789);
      lvalueVariable();
      setState(5790);
      equal();
      setState(5791);
      setExprOrDefault();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5793);
      match(MySQLParser::NAMES_SYMBOL);
      setState(5803);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 664, _ctx)) {
      case 1: {
        setState(5794);
        equal();
        setState(5795);
        expr(0);
        break;
      }

      case 2: {
        setState(5797);
        charsetName();
        setState(5799);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COLLATE_SYMBOL) {
          setState(5798);
          collate();
        }
        break;
      }

      case 3: {
        setState(5801);

        if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
        setState(5802);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionValueContext ------------------------------------------------------------------

MySQLParser::OptionValueContext::OptionValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OptionTypeContext* MySQLParser::OptionValueContext::optionType() {
  return getRuleContext<MySQLParser::OptionTypeContext>(0);
}

MySQLParser::LvalueVariableContext* MySQLParser::OptionValueContext::lvalueVariable() {
  return getRuleContext<MySQLParser::LvalueVariableContext>(0);
}

MySQLParser::EqualContext* MySQLParser::OptionValueContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::SetExprOrDefaultContext* MySQLParser::OptionValueContext::setExprOrDefault() {
  return getRuleContext<MySQLParser::SetExprOrDefaultContext>(0);
}

MySQLParser::OptionValueNoOptionTypeContext* MySQLParser::OptionValueContext::optionValueNoOptionType() {
  return getRuleContext<MySQLParser::OptionValueNoOptionTypeContext>(0);
}


size_t MySQLParser::OptionValueContext::getRuleIndex() const {
  return MySQLParser::RuleOptionValue;
}

void MySQLParser::OptionValueContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionValue(this);
}

void MySQLParser::OptionValueContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionValue(this);
}


std::any MySQLParser::OptionValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOptionValue(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OptionValueContext* MySQLParser::optionValue() {
  OptionValueContext *_localctx = _tracker.createInstance<OptionValueContext>(_ctx, getState());
  enterRule(_localctx, 740, MySQLParser::RuleOptionValue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5813);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 666, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5807);
      optionType();
      setState(5808);
      lvalueVariable();
      setState(5809);
      equal();
      setState(5810);
      setExprOrDefault();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5812);
      optionValueNoOptionType();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StartOptionValueListFollowingOptionTypeContext ------------------------------------------------------------------

MySQLParser::StartOptionValueListFollowingOptionTypeContext::StartOptionValueListFollowingOptionTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::OptionValueFollowingOptionTypeContext* MySQLParser::StartOptionValueListFollowingOptionTypeContext::optionValueFollowingOptionType() {
  return getRuleContext<MySQLParser::OptionValueFollowingOptionTypeContext>(0);
}

MySQLParser::OptionValueListContinuedContext* MySQLParser::StartOptionValueListFollowingOptionTypeContext::optionValueListContinued() {
  return getRuleContext<MySQLParser::OptionValueListContinuedContext>(0);
}

tree::TerminalNode* MySQLParser::StartOptionValueListFollowingOptionTypeContext::TRANSACTION_SYMBOL() {
  return getToken(MySQLParser::TRANSACTION_SYMBOL, 0);
}

MySQLParser::TransactionCharacteristicsContext* MySQLParser::StartOptionValueListFollowingOptionTypeContext::transactionCharacteristics() {
  return getRuleContext<MySQLParser::TransactionCharacteristicsContext>(0);
}


size_t MySQLParser::StartOptionValueListFollowingOptionTypeContext::getRuleIndex() const {
  return MySQLParser::RuleStartOptionValueListFollowingOptionType;
}

void MySQLParser::StartOptionValueListFollowingOptionTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStartOptionValueListFollowingOptionType(this);
}

void MySQLParser::StartOptionValueListFollowingOptionTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStartOptionValueListFollowingOptionType(this);
}


std::any MySQLParser::StartOptionValueListFollowingOptionTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStartOptionValueListFollowingOptionType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StartOptionValueListFollowingOptionTypeContext* MySQLParser::startOptionValueListFollowingOptionType() {
  StartOptionValueListFollowingOptionTypeContext *_localctx = _tracker.createInstance<StartOptionValueListFollowingOptionTypeContext>(_ctx, getState());
  enterRule(_localctx, 742, MySQLParser::RuleStartOptionValueListFollowingOptionType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5820);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 667, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5815);
      optionValueFollowingOptionType();
      setState(5816);
      optionValueListContinued();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5818);
      match(MySQLParser::TRANSACTION_SYMBOL);
      setState(5819);
      transactionCharacteristics();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionValueFollowingOptionTypeContext ------------------------------------------------------------------

MySQLParser::OptionValueFollowingOptionTypeContext::OptionValueFollowingOptionTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LvalueVariableContext* MySQLParser::OptionValueFollowingOptionTypeContext::lvalueVariable() {
  return getRuleContext<MySQLParser::LvalueVariableContext>(0);
}

MySQLParser::EqualContext* MySQLParser::OptionValueFollowingOptionTypeContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::SetExprOrDefaultContext* MySQLParser::OptionValueFollowingOptionTypeContext::setExprOrDefault() {
  return getRuleContext<MySQLParser::SetExprOrDefaultContext>(0);
}


size_t MySQLParser::OptionValueFollowingOptionTypeContext::getRuleIndex() const {
  return MySQLParser::RuleOptionValueFollowingOptionType;
}

void MySQLParser::OptionValueFollowingOptionTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionValueFollowingOptionType(this);
}

void MySQLParser::OptionValueFollowingOptionTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionValueFollowingOptionType(this);
}


std::any MySQLParser::OptionValueFollowingOptionTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOptionValueFollowingOptionType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OptionValueFollowingOptionTypeContext* MySQLParser::optionValueFollowingOptionType() {
  OptionValueFollowingOptionTypeContext *_localctx = _tracker.createInstance<OptionValueFollowingOptionTypeContext>(_ctx, getState());
  enterRule(_localctx, 744, MySQLParser::RuleOptionValueFollowingOptionType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5822);
    lvalueVariable();
    setState(5823);
    equal();
    setState(5824);
    setExprOrDefault();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetExprOrDefaultContext ------------------------------------------------------------------

MySQLParser::SetExprOrDefaultContext::SetExprOrDefaultContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::SetExprOrDefaultContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::SetExprOrDefaultContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetExprOrDefaultContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetExprOrDefaultContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetExprOrDefaultContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetExprOrDefaultContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetExprOrDefaultContext::SYSTEM_SYMBOL() {
  return getToken(MySQLParser::SYSTEM_SYMBOL, 0);
}


size_t MySQLParser::SetExprOrDefaultContext::getRuleIndex() const {
  return MySQLParser::RuleSetExprOrDefault;
}

void MySQLParser::SetExprOrDefaultContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSetExprOrDefault(this);
}

void MySQLParser::SetExprOrDefaultContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSetExprOrDefault(this);
}


std::any MySQLParser::SetExprOrDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSetExprOrDefault(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SetExprOrDefaultContext* MySQLParser::setExprOrDefault() {
  SetExprOrDefaultContext *_localctx = _tracker.createInstance<SetExprOrDefaultContext>(_ctx, getState());
  enterRule(_localctx, 746, MySQLParser::RuleSetExprOrDefault);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5835);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 668, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5826);
      expr(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5827);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5828);
      match(MySQLParser::ON_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5829);
      match(MySQLParser::ALL_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5830);
      match(MySQLParser::BINARY_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(5831);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5832);
      match(MySQLParser::ROW_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(5833);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5834);
      match(MySQLParser::SYSTEM_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowDatabasesStatementContext ------------------------------------------------------------------

MySQLParser::ShowDatabasesStatementContext::ShowDatabasesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowDatabasesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowDatabasesStatementContext::DATABASES_SYMBOL() {
  return getToken(MySQLParser::DATABASES_SYMBOL, 0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowDatabasesStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowDatabasesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowDatabasesStatement;
}

void MySQLParser::ShowDatabasesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowDatabasesStatement(this);
}

void MySQLParser::ShowDatabasesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowDatabasesStatement(this);
}


std::any MySQLParser::ShowDatabasesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowDatabasesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowDatabasesStatementContext* MySQLParser::showDatabasesStatement() {
  ShowDatabasesStatementContext *_localctx = _tracker.createInstance<ShowDatabasesStatementContext>(_ctx, getState());
  enterRule(_localctx, 748, MySQLParser::RuleShowDatabasesStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5837);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5838);
    match(MySQLParser::DATABASES_SYMBOL);
    setState(5840);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5839);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowTablesStatementContext ------------------------------------------------------------------

MySQLParser::ShowTablesStatementContext::ShowTablesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowTablesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowTablesStatementContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

MySQLParser::ShowCommandTypeContext* MySQLParser::ShowTablesStatementContext::showCommandType() {
  return getRuleContext<MySQLParser::ShowCommandTypeContext>(0);
}

MySQLParser::InDbContext* MySQLParser::ShowTablesStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowTablesStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowTablesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowTablesStatement;
}

void MySQLParser::ShowTablesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowTablesStatement(this);
}

void MySQLParser::ShowTablesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowTablesStatement(this);
}


std::any MySQLParser::ShowTablesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowTablesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowTablesStatementContext* MySQLParser::showTablesStatement() {
  ShowTablesStatementContext *_localctx = _tracker.createInstance<ShowTablesStatementContext>(_ctx, getState());
  enterRule(_localctx, 750, MySQLParser::RuleShowTablesStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5842);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5844);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 670, _ctx)) {
    case 1: {
      setState(5843);
      showCommandType();
      break;
    }

    default:
      break;
    }
    setState(5846);
    antlrcpp::downCast<ShowTablesStatementContext *>(_localctx)->value = match(MySQLParser::TABLES_SYMBOL);
    setState(5848);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5847);
      inDb();
    }
    setState(5851);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5850);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowTriggersStatementContext ------------------------------------------------------------------

MySQLParser::ShowTriggersStatementContext::ShowTriggersStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowTriggersStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowTriggersStatementContext::TRIGGERS_SYMBOL() {
  return getToken(MySQLParser::TRIGGERS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowTriggersStatementContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}

MySQLParser::InDbContext* MySQLParser::ShowTriggersStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowTriggersStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowTriggersStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowTriggersStatement;
}

void MySQLParser::ShowTriggersStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowTriggersStatement(this);
}

void MySQLParser::ShowTriggersStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowTriggersStatement(this);
}


std::any MySQLParser::ShowTriggersStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowTriggersStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowTriggersStatementContext* MySQLParser::showTriggersStatement() {
  ShowTriggersStatementContext *_localctx = _tracker.createInstance<ShowTriggersStatementContext>(_ctx, getState());
  enterRule(_localctx, 752, MySQLParser::RuleShowTriggersStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5853);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5855);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FULL_SYMBOL) {
      setState(5854);
      match(MySQLParser::FULL_SYMBOL);
    }
    setState(5857);
    match(MySQLParser::TRIGGERS_SYMBOL);
    setState(5859);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5858);
      inDb();
    }
    setState(5862);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5861);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowEventsStatementContext ------------------------------------------------------------------

MySQLParser::ShowEventsStatementContext::ShowEventsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowEventsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowEventsStatementContext::EVENTS_SYMBOL() {
  return getToken(MySQLParser::EVENTS_SYMBOL, 0);
}

MySQLParser::InDbContext* MySQLParser::ShowEventsStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowEventsStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowEventsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowEventsStatement;
}

void MySQLParser::ShowEventsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowEventsStatement(this);
}

void MySQLParser::ShowEventsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowEventsStatement(this);
}


std::any MySQLParser::ShowEventsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowEventsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowEventsStatementContext* MySQLParser::showEventsStatement() {
  ShowEventsStatementContext *_localctx = _tracker.createInstance<ShowEventsStatementContext>(_ctx, getState());
  enterRule(_localctx, 754, MySQLParser::RuleShowEventsStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5864);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5865);
    match(MySQLParser::EVENTS_SYMBOL);
    setState(5867);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5866);
      inDb();
    }
    setState(5870);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5869);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowTableStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowTableStatusStatementContext::ShowTableStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowTableStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowTableStatusStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowTableStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

MySQLParser::InDbContext* MySQLParser::ShowTableStatusStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowTableStatusStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowTableStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowTableStatusStatement;
}

void MySQLParser::ShowTableStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowTableStatusStatement(this);
}

void MySQLParser::ShowTableStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowTableStatusStatement(this);
}


std::any MySQLParser::ShowTableStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowTableStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowTableStatusStatementContext* MySQLParser::showTableStatusStatement() {
  ShowTableStatusStatementContext *_localctx = _tracker.createInstance<ShowTableStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 756, MySQLParser::RuleShowTableStatusStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5872);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5873);
    match(MySQLParser::TABLE_SYMBOL);
    setState(5874);
    match(MySQLParser::STATUS_SYMBOL);
    setState(5876);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5875);
      inDb();
    }
    setState(5879);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5878);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowOpenTablesStatementContext ------------------------------------------------------------------

MySQLParser::ShowOpenTablesStatementContext::ShowOpenTablesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowOpenTablesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowOpenTablesStatementContext::OPEN_SYMBOL() {
  return getToken(MySQLParser::OPEN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowOpenTablesStatementContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

MySQLParser::InDbContext* MySQLParser::ShowOpenTablesStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowOpenTablesStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowOpenTablesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowOpenTablesStatement;
}

void MySQLParser::ShowOpenTablesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowOpenTablesStatement(this);
}

void MySQLParser::ShowOpenTablesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowOpenTablesStatement(this);
}


std::any MySQLParser::ShowOpenTablesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowOpenTablesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowOpenTablesStatementContext* MySQLParser::showOpenTablesStatement() {
  ShowOpenTablesStatementContext *_localctx = _tracker.createInstance<ShowOpenTablesStatementContext>(_ctx, getState());
  enterRule(_localctx, 758, MySQLParser::RuleShowOpenTablesStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5881);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5882);
    match(MySQLParser::OPEN_SYMBOL);
    setState(5883);
    match(MySQLParser::TABLES_SYMBOL);
    setState(5885);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5884);
      inDb();
    }
    setState(5888);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5887);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowParseTreeStatementContext ------------------------------------------------------------------

MySQLParser::ShowParseTreeStatementContext::ShowParseTreeStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowParseTreeStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowParseTreeStatementContext::PARSE_TREE_SYMBOL() {
  return getToken(MySQLParser::PARSE_TREE_SYMBOL, 0);
}

MySQLParser::SimpleStatementContext* MySQLParser::ShowParseTreeStatementContext::simpleStatement() {
  return getRuleContext<MySQLParser::SimpleStatementContext>(0);
}


size_t MySQLParser::ShowParseTreeStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowParseTreeStatement;
}

void MySQLParser::ShowParseTreeStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowParseTreeStatement(this);
}

void MySQLParser::ShowParseTreeStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowParseTreeStatement(this);
}


std::any MySQLParser::ShowParseTreeStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowParseTreeStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowParseTreeStatementContext* MySQLParser::showParseTreeStatement() {
  ShowParseTreeStatementContext *_localctx = _tracker.createInstance<ShowParseTreeStatementContext>(_ctx, getState());
  enterRule(_localctx, 760, MySQLParser::RuleShowParseTreeStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5890);

    if (!(serverVersion >= 80100)) throw FailedPredicateException(this, "serverVersion >= 80100");
    setState(5891);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5892);
    match(MySQLParser::PARSE_TREE_SYMBOL);
    setState(5893);
    simpleStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowPluginsStatementContext ------------------------------------------------------------------

MySQLParser::ShowPluginsStatementContext::ShowPluginsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowPluginsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowPluginsStatementContext::PLUGINS_SYMBOL() {
  return getToken(MySQLParser::PLUGINS_SYMBOL, 0);
}


size_t MySQLParser::ShowPluginsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowPluginsStatement;
}

void MySQLParser::ShowPluginsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowPluginsStatement(this);
}

void MySQLParser::ShowPluginsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowPluginsStatement(this);
}


std::any MySQLParser::ShowPluginsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowPluginsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowPluginsStatementContext* MySQLParser::showPluginsStatement() {
  ShowPluginsStatementContext *_localctx = _tracker.createInstance<ShowPluginsStatementContext>(_ctx, getState());
  enterRule(_localctx, 762, MySQLParser::RuleShowPluginsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5895);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5896);
    match(MySQLParser::PLUGINS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowEngineLogsStatementContext ------------------------------------------------------------------

MySQLParser::ShowEngineLogsStatementContext::ShowEngineLogsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowEngineLogsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowEngineLogsStatementContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

MySQLParser::EngineOrAllContext* MySQLParser::ShowEngineLogsStatementContext::engineOrAll() {
  return getRuleContext<MySQLParser::EngineOrAllContext>(0);
}

tree::TerminalNode* MySQLParser::ShowEngineLogsStatementContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}


size_t MySQLParser::ShowEngineLogsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowEngineLogsStatement;
}

void MySQLParser::ShowEngineLogsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowEngineLogsStatement(this);
}

void MySQLParser::ShowEngineLogsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowEngineLogsStatement(this);
}


std::any MySQLParser::ShowEngineLogsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowEngineLogsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowEngineLogsStatementContext* MySQLParser::showEngineLogsStatement() {
  ShowEngineLogsStatementContext *_localctx = _tracker.createInstance<ShowEngineLogsStatementContext>(_ctx, getState());
  enterRule(_localctx, 764, MySQLParser::RuleShowEngineLogsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5898);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5899);
    match(MySQLParser::ENGINE_SYMBOL);
    setState(5900);
    engineOrAll();
    setState(5901);
    match(MySQLParser::LOGS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowEngineMutexStatementContext ------------------------------------------------------------------

MySQLParser::ShowEngineMutexStatementContext::ShowEngineMutexStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowEngineMutexStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowEngineMutexStatementContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

MySQLParser::EngineOrAllContext* MySQLParser::ShowEngineMutexStatementContext::engineOrAll() {
  return getRuleContext<MySQLParser::EngineOrAllContext>(0);
}

tree::TerminalNode* MySQLParser::ShowEngineMutexStatementContext::MUTEX_SYMBOL() {
  return getToken(MySQLParser::MUTEX_SYMBOL, 0);
}


size_t MySQLParser::ShowEngineMutexStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowEngineMutexStatement;
}

void MySQLParser::ShowEngineMutexStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowEngineMutexStatement(this);
}

void MySQLParser::ShowEngineMutexStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowEngineMutexStatement(this);
}


std::any MySQLParser::ShowEngineMutexStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowEngineMutexStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowEngineMutexStatementContext* MySQLParser::showEngineMutexStatement() {
  ShowEngineMutexStatementContext *_localctx = _tracker.createInstance<ShowEngineMutexStatementContext>(_ctx, getState());
  enterRule(_localctx, 766, MySQLParser::RuleShowEngineMutexStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5903);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5904);
    match(MySQLParser::ENGINE_SYMBOL);
    setState(5905);
    engineOrAll();
    setState(5906);
    match(MySQLParser::MUTEX_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowEngineStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowEngineStatusStatementContext::ShowEngineStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowEngineStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowEngineStatusStatementContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

MySQLParser::EngineOrAllContext* MySQLParser::ShowEngineStatusStatementContext::engineOrAll() {
  return getRuleContext<MySQLParser::EngineOrAllContext>(0);
}

tree::TerminalNode* MySQLParser::ShowEngineStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}


size_t MySQLParser::ShowEngineStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowEngineStatusStatement;
}

void MySQLParser::ShowEngineStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowEngineStatusStatement(this);
}

void MySQLParser::ShowEngineStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowEngineStatusStatement(this);
}


std::any MySQLParser::ShowEngineStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowEngineStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowEngineStatusStatementContext* MySQLParser::showEngineStatusStatement() {
  ShowEngineStatusStatementContext *_localctx = _tracker.createInstance<ShowEngineStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 768, MySQLParser::RuleShowEngineStatusStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5908);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5909);
    match(MySQLParser::ENGINE_SYMBOL);
    setState(5910);
    engineOrAll();
    setState(5911);
    match(MySQLParser::STATUS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowColumnsStatementContext ------------------------------------------------------------------

MySQLParser::ShowColumnsStatementContext::ShowColumnsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowColumnsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowColumnsStatementContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::ShowColumnsStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::ShowColumnsStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowColumnsStatementContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

MySQLParser::ShowCommandTypeContext* MySQLParser::ShowColumnsStatementContext::showCommandType() {
  return getRuleContext<MySQLParser::ShowCommandTypeContext>(0);
}

MySQLParser::InDbContext* MySQLParser::ShowColumnsStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowColumnsStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowColumnsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowColumnsStatement;
}

void MySQLParser::ShowColumnsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowColumnsStatement(this);
}

void MySQLParser::ShowColumnsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowColumnsStatement(this);
}


std::any MySQLParser::ShowColumnsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowColumnsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowColumnsStatementContext* MySQLParser::showColumnsStatement() {
  ShowColumnsStatementContext *_localctx = _tracker.createInstance<ShowColumnsStatementContext>(_ctx, getState());
  enterRule(_localctx, 770, MySQLParser::RuleShowColumnsStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5913);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5915);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 682, _ctx)) {
    case 1: {
      setState(5914);
      showCommandType();
      break;
    }

    default:
      break;
    }
    setState(5917);
    match(MySQLParser::COLUMNS_SYMBOL);
    setState(5918);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5919);
    tableRef();
    setState(5921);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5920);
      inDb();
    }
    setState(5924);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(5923);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowBinaryLogsStatementContext ------------------------------------------------------------------

MySQLParser::ShowBinaryLogsStatementContext::ShowBinaryLogsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowBinaryLogsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinaryLogsStatementContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinaryLogsStatementContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinaryLogsStatementContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}


size_t MySQLParser::ShowBinaryLogsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowBinaryLogsStatement;
}

void MySQLParser::ShowBinaryLogsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowBinaryLogsStatement(this);
}

void MySQLParser::ShowBinaryLogsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowBinaryLogsStatement(this);
}


std::any MySQLParser::ShowBinaryLogsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowBinaryLogsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowBinaryLogsStatementContext* MySQLParser::showBinaryLogsStatement() {
  ShowBinaryLogsStatementContext *_localctx = _tracker.createInstance<ShowBinaryLogsStatementContext>(_ctx, getState());
  enterRule(_localctx, 772, MySQLParser::RuleShowBinaryLogsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5926);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5930);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 685, _ctx)) {
    case 1: {
      setState(5927);
      match(MySQLParser::BINARY_SYMBOL);
      break;
    }

    case 2: {
      setState(5928);

      if (!(serverVersion < 80400)) throw FailedPredicateException(this, "serverVersion < 80400");
      setState(5929);
      match(MySQLParser::MASTER_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(5932);
    antlrcpp::downCast<ShowBinaryLogsStatementContext *>(_localctx)->value = match(MySQLParser::LOGS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowBinaryLogStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowBinaryLogStatusStatementContext::ShowBinaryLogStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowBinaryLogStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinaryLogStatusStatementContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinaryLogStatusStatementContext::LOG_SYMBOL() {
  return getToken(MySQLParser::LOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinaryLogStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}


size_t MySQLParser::ShowBinaryLogStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowBinaryLogStatusStatement;
}

void MySQLParser::ShowBinaryLogStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowBinaryLogStatusStatement(this);
}

void MySQLParser::ShowBinaryLogStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowBinaryLogStatusStatement(this);
}


std::any MySQLParser::ShowBinaryLogStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowBinaryLogStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowBinaryLogStatusStatementContext* MySQLParser::showBinaryLogStatusStatement() {
  ShowBinaryLogStatusStatementContext *_localctx = _tracker.createInstance<ShowBinaryLogStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 774, MySQLParser::RuleShowBinaryLogStatusStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5934);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5935);
    match(MySQLParser::BINARY_SYMBOL);
    setState(5936);
    match(MySQLParser::LOG_SYMBOL);
    setState(5937);
    match(MySQLParser::STATUS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowReplicasStatementContext ------------------------------------------------------------------

MySQLParser::ShowReplicasStatementContext::ShowReplicasStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowReplicasStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowReplicasStatementContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowReplicasStatementContext::HOSTS_SYMBOL() {
  return getToken(MySQLParser::HOSTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowReplicasStatementContext::REPLICAS_SYMBOL() {
  return getToken(MySQLParser::REPLICAS_SYMBOL, 0);
}


size_t MySQLParser::ShowReplicasStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowReplicasStatement;
}

void MySQLParser::ShowReplicasStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowReplicasStatement(this);
}

void MySQLParser::ShowReplicasStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowReplicasStatement(this);
}


std::any MySQLParser::ShowReplicasStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowReplicasStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowReplicasStatementContext* MySQLParser::showReplicasStatement() {
  ShowReplicasStatementContext *_localctx = _tracker.createInstance<ShowReplicasStatementContext>(_ctx, getState());
  enterRule(_localctx, 776, MySQLParser::RuleShowReplicasStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5939);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5943);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::SLAVE_SYMBOL: {
        setState(5940);
        match(MySQLParser::SLAVE_SYMBOL);
        setState(5941);
        match(MySQLParser::HOSTS_SYMBOL);
        break;
      }

      case MySQLParser::REPLICAS_SYMBOL: {
        setState(5942);
        match(MySQLParser::REPLICAS_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowBinlogEventsStatementContext ------------------------------------------------------------------

MySQLParser::ShowBinlogEventsStatementContext::ShowBinlogEventsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowBinlogEventsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinlogEventsStatementContext::BINLOG_SYMBOL() {
  return getToken(MySQLParser::BINLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinlogEventsStatementContext::EVENTS_SYMBOL() {
  return getToken(MySQLParser::EVENTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowBinlogEventsStatementContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::ShowBinlogEventsStatementContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::ShowBinlogEventsStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::UlonglongNumberContext* MySQLParser::ShowBinlogEventsStatementContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

MySQLParser::LimitClauseContext* MySQLParser::ShowBinlogEventsStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::ShowBinlogEventsStatementContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ShowBinlogEventsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowBinlogEventsStatement;
}

void MySQLParser::ShowBinlogEventsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowBinlogEventsStatement(this);
}

void MySQLParser::ShowBinlogEventsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowBinlogEventsStatement(this);
}


std::any MySQLParser::ShowBinlogEventsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowBinlogEventsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowBinlogEventsStatementContext* MySQLParser::showBinlogEventsStatement() {
  ShowBinlogEventsStatementContext *_localctx = _tracker.createInstance<ShowBinlogEventsStatementContext>(_ctx, getState());
  enterRule(_localctx, 778, MySQLParser::RuleShowBinlogEventsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5945);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5946);
    match(MySQLParser::BINLOG_SYMBOL);
    setState(5947);
    match(MySQLParser::EVENTS_SYMBOL);
    setState(5950);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 687, _ctx)) {
    case 1: {
      setState(5948);
      match(MySQLParser::IN_SYMBOL);
      setState(5949);
      textString();
      break;
    }

    default:
      break;
    }
    setState(5954);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 688, _ctx)) {
    case 1: {
      setState(5952);
      match(MySQLParser::FROM_SYMBOL);
      setState(5953);
      ulonglongNumber();
      break;
    }

    default:
      break;
    }
    setState(5957);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 689, _ctx)) {
    case 1: {
      setState(5956);
      limitClause();
      break;
    }

    default:
      break;
    }
    setState(5960);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 690, _ctx)) {
    case 1: {
      setState(5959);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowRelaylogEventsStatementContext ------------------------------------------------------------------

MySQLParser::ShowRelaylogEventsStatementContext::ShowRelaylogEventsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowRelaylogEventsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowRelaylogEventsStatementContext::RELAYLOG_SYMBOL() {
  return getToken(MySQLParser::RELAYLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowRelaylogEventsStatementContext::EVENTS_SYMBOL() {
  return getToken(MySQLParser::EVENTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowRelaylogEventsStatementContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::ShowRelaylogEventsStatementContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::ShowRelaylogEventsStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::UlonglongNumberContext* MySQLParser::ShowRelaylogEventsStatementContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

MySQLParser::LimitClauseContext* MySQLParser::ShowRelaylogEventsStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::ShowRelaylogEventsStatementContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ShowRelaylogEventsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowRelaylogEventsStatement;
}

void MySQLParser::ShowRelaylogEventsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowRelaylogEventsStatement(this);
}

void MySQLParser::ShowRelaylogEventsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowRelaylogEventsStatement(this);
}


std::any MySQLParser::ShowRelaylogEventsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowRelaylogEventsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowRelaylogEventsStatementContext* MySQLParser::showRelaylogEventsStatement() {
  ShowRelaylogEventsStatementContext *_localctx = _tracker.createInstance<ShowRelaylogEventsStatementContext>(_ctx, getState());
  enterRule(_localctx, 780, MySQLParser::RuleShowRelaylogEventsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5962);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5963);
    match(MySQLParser::RELAYLOG_SYMBOL);
    setState(5964);
    match(MySQLParser::EVENTS_SYMBOL);
    setState(5967);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 691, _ctx)) {
    case 1: {
      setState(5965);
      match(MySQLParser::IN_SYMBOL);
      setState(5966);
      textString();
      break;
    }

    default:
      break;
    }
    setState(5971);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 692, _ctx)) {
    case 1: {
      setState(5969);
      match(MySQLParser::FROM_SYMBOL);
      setState(5970);
      ulonglongNumber();
      break;
    }

    default:
      break;
    }
    setState(5974);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 693, _ctx)) {
    case 1: {
      setState(5973);
      limitClause();
      break;
    }

    default:
      break;
    }
    setState(5977);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 694, _ctx)) {
    case 1: {
      setState(5976);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowKeysStatementContext ------------------------------------------------------------------

MySQLParser::ShowKeysStatementContext::ShowKeysStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowKeysStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

MySQLParser::FromOrInContext* MySQLParser::ShowKeysStatementContext::fromOrIn() {
  return getRuleContext<MySQLParser::FromOrInContext>(0);
}

MySQLParser::TableRefContext* MySQLParser::ShowKeysStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::ShowKeysStatementContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowKeysStatementContext::INDEXES_SYMBOL() {
  return getToken(MySQLParser::INDEXES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowKeysStatementContext::KEYS_SYMBOL() {
  return getToken(MySQLParser::KEYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowKeysStatementContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

MySQLParser::InDbContext* MySQLParser::ShowKeysStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

MySQLParser::WhereClauseContext* MySQLParser::ShowKeysStatementContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}


size_t MySQLParser::ShowKeysStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowKeysStatement;
}

void MySQLParser::ShowKeysStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowKeysStatement(this);
}

void MySQLParser::ShowKeysStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowKeysStatement(this);
}


std::any MySQLParser::ShowKeysStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowKeysStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowKeysStatementContext* MySQLParser::showKeysStatement() {
  ShowKeysStatementContext *_localctx = _tracker.createInstance<ShowKeysStatementContext>(_ctx, getState());
  enterRule(_localctx, 782, MySQLParser::RuleShowKeysStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5979);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5982);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 695, _ctx)) {
    case 1: {
      setState(5980);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5981);
      match(MySQLParser::EXTENDED_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(5984);
    _la = _input->LA(1);
    if (!(((((_la - 271) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 271)) & ((1ULL << (MySQLParser::INDEXES_SYMBOL - 271))
      | (1ULL << (MySQLParser::INDEX_SYMBOL - 271))
      | (1ULL << (MySQLParser::KEYS_SYMBOL - 271)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5985);
    fromOrIn();
    setState(5986);
    tableRef();
    setState(5988);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL) {
      setState(5987);
      inDb();
    }
    setState(5991);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::WHERE_SYMBOL) {
      setState(5990);
      whereClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowEnginesStatementContext ------------------------------------------------------------------

MySQLParser::ShowEnginesStatementContext::ShowEnginesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowEnginesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowEnginesStatementContext::ENGINES_SYMBOL() {
  return getToken(MySQLParser::ENGINES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowEnginesStatementContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}


size_t MySQLParser::ShowEnginesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowEnginesStatement;
}

void MySQLParser::ShowEnginesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowEnginesStatement(this);
}

void MySQLParser::ShowEnginesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowEnginesStatement(this);
}


std::any MySQLParser::ShowEnginesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowEnginesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowEnginesStatementContext* MySQLParser::showEnginesStatement() {
  ShowEnginesStatementContext *_localctx = _tracker.createInstance<ShowEnginesStatementContext>(_ctx, getState());
  enterRule(_localctx, 784, MySQLParser::RuleShowEnginesStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5993);
    match(MySQLParser::SHOW_SYMBOL);
    setState(5995);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::STORAGE_SYMBOL) {
      setState(5994);
      match(MySQLParser::STORAGE_SYMBOL);
    }
    setState(5997);
    antlrcpp::downCast<ShowEnginesStatementContext *>(_localctx)->value = match(MySQLParser::ENGINES_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCountWarningsStatementContext ------------------------------------------------------------------

MySQLParser::ShowCountWarningsStatementContext::ShowCountWarningsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCountWarningsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountWarningsStatementContext::COUNT_SYMBOL() {
  return getToken(MySQLParser::COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountWarningsStatementContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountWarningsStatementContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::ShowCountWarningsStatementContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountWarningsStatementContext::WARNINGS_SYMBOL() {
  return getToken(MySQLParser::WARNINGS_SYMBOL, 0);
}


size_t MySQLParser::ShowCountWarningsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCountWarningsStatement;
}

void MySQLParser::ShowCountWarningsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCountWarningsStatement(this);
}

void MySQLParser::ShowCountWarningsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCountWarningsStatement(this);
}


std::any MySQLParser::ShowCountWarningsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCountWarningsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCountWarningsStatementContext* MySQLParser::showCountWarningsStatement() {
  ShowCountWarningsStatementContext *_localctx = _tracker.createInstance<ShowCountWarningsStatementContext>(_ctx, getState());
  enterRule(_localctx, 786, MySQLParser::RuleShowCountWarningsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5999);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6000);
    match(MySQLParser::COUNT_SYMBOL);
    setState(6001);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6002);
    match(MySQLParser::MULT_OPERATOR);
    setState(6003);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(6004);
    match(MySQLParser::WARNINGS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCountErrorsStatementContext ------------------------------------------------------------------

MySQLParser::ShowCountErrorsStatementContext::ShowCountErrorsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCountErrorsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountErrorsStatementContext::COUNT_SYMBOL() {
  return getToken(MySQLParser::COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountErrorsStatementContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountErrorsStatementContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::ShowCountErrorsStatementContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCountErrorsStatementContext::ERRORS_SYMBOL() {
  return getToken(MySQLParser::ERRORS_SYMBOL, 0);
}


size_t MySQLParser::ShowCountErrorsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCountErrorsStatement;
}

void MySQLParser::ShowCountErrorsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCountErrorsStatement(this);
}

void MySQLParser::ShowCountErrorsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCountErrorsStatement(this);
}


std::any MySQLParser::ShowCountErrorsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCountErrorsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCountErrorsStatementContext* MySQLParser::showCountErrorsStatement() {
  ShowCountErrorsStatementContext *_localctx = _tracker.createInstance<ShowCountErrorsStatementContext>(_ctx, getState());
  enterRule(_localctx, 788, MySQLParser::RuleShowCountErrorsStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6006);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6007);
    match(MySQLParser::COUNT_SYMBOL);
    setState(6008);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6009);
    match(MySQLParser::MULT_OPERATOR);
    setState(6010);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(6011);
    match(MySQLParser::ERRORS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowWarningsStatementContext ------------------------------------------------------------------

MySQLParser::ShowWarningsStatementContext::ShowWarningsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowWarningsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowWarningsStatementContext::WARNINGS_SYMBOL() {
  return getToken(MySQLParser::WARNINGS_SYMBOL, 0);
}

MySQLParser::LimitClauseContext* MySQLParser::ShowWarningsStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}


size_t MySQLParser::ShowWarningsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowWarningsStatement;
}

void MySQLParser::ShowWarningsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowWarningsStatement(this);
}

void MySQLParser::ShowWarningsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowWarningsStatement(this);
}


std::any MySQLParser::ShowWarningsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowWarningsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowWarningsStatementContext* MySQLParser::showWarningsStatement() {
  ShowWarningsStatementContext *_localctx = _tracker.createInstance<ShowWarningsStatementContext>(_ctx, getState());
  enterRule(_localctx, 790, MySQLParser::RuleShowWarningsStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6013);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6014);
    match(MySQLParser::WARNINGS_SYMBOL);
    setState(6016);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIMIT_SYMBOL) {
      setState(6015);
      limitClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowErrorsStatementContext ------------------------------------------------------------------

MySQLParser::ShowErrorsStatementContext::ShowErrorsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowErrorsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowErrorsStatementContext::ERRORS_SYMBOL() {
  return getToken(MySQLParser::ERRORS_SYMBOL, 0);
}

MySQLParser::LimitClauseContext* MySQLParser::ShowErrorsStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}


size_t MySQLParser::ShowErrorsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowErrorsStatement;
}

void MySQLParser::ShowErrorsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowErrorsStatement(this);
}

void MySQLParser::ShowErrorsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowErrorsStatement(this);
}


std::any MySQLParser::ShowErrorsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowErrorsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowErrorsStatementContext* MySQLParser::showErrorsStatement() {
  ShowErrorsStatementContext *_localctx = _tracker.createInstance<ShowErrorsStatementContext>(_ctx, getState());
  enterRule(_localctx, 792, MySQLParser::RuleShowErrorsStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6018);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6019);
    match(MySQLParser::ERRORS_SYMBOL);
    setState(6021);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIMIT_SYMBOL) {
      setState(6020);
      limitClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowProfilesStatementContext ------------------------------------------------------------------

MySQLParser::ShowProfilesStatementContext::ShowProfilesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowProfilesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProfilesStatementContext::PROFILES_SYMBOL() {
  return getToken(MySQLParser::PROFILES_SYMBOL, 0);
}


size_t MySQLParser::ShowProfilesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowProfilesStatement;
}

void MySQLParser::ShowProfilesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowProfilesStatement(this);
}

void MySQLParser::ShowProfilesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowProfilesStatement(this);
}


std::any MySQLParser::ShowProfilesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowProfilesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowProfilesStatementContext* MySQLParser::showProfilesStatement() {
  ShowProfilesStatementContext *_localctx = _tracker.createInstance<ShowProfilesStatementContext>(_ctx, getState());
  enterRule(_localctx, 794, MySQLParser::RuleShowProfilesStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6023);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6024);
    match(MySQLParser::PROFILES_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowProfileStatementContext ------------------------------------------------------------------

MySQLParser::ShowProfileStatementContext::ShowProfileStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowProfileStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProfileStatementContext::PROFILE_SYMBOL() {
  return getToken(MySQLParser::PROFILE_SYMBOL, 0);
}

MySQLParser::ProfileDefinitionsContext* MySQLParser::ShowProfileStatementContext::profileDefinitions() {
  return getRuleContext<MySQLParser::ProfileDefinitionsContext>(0);
}

tree::TerminalNode* MySQLParser::ShowProfileStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProfileStatementContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProfileStatementContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

MySQLParser::LimitClauseContext* MySQLParser::ShowProfileStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}


size_t MySQLParser::ShowProfileStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowProfileStatement;
}

void MySQLParser::ShowProfileStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowProfileStatement(this);
}

void MySQLParser::ShowProfileStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowProfileStatement(this);
}


std::any MySQLParser::ShowProfileStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowProfileStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowProfileStatementContext* MySQLParser::showProfileStatement() {
  ShowProfileStatementContext *_localctx = _tracker.createInstance<ShowProfileStatementContext>(_ctx, getState());
  enterRule(_localctx, 796, MySQLParser::RuleShowProfileStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6026);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6027);
    match(MySQLParser::PROFILE_SYMBOL);
    setState(6029);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALL_SYMBOL || ((((_la - 85) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 85)) & ((1ULL << (MySQLParser::BLOCK_SYMBOL - 85))
      | (1ULL << (MySQLParser::CONTEXT_SYMBOL - 85))
      | (1ULL << (MySQLParser::CPU_SYMBOL - 85)))) != 0) || _la == MySQLParser::IPC_SYMBOL || _la == MySQLParser::MEMORY_SYMBOL || _la == MySQLParser::PAGE_SYMBOL || _la == MySQLParser::SOURCE_SYMBOL

    || _la == MySQLParser::SWAPS_SYMBOL) {
      setState(6028);
      profileDefinitions();
    }
    setState(6034);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FOR_SYMBOL) {
      setState(6031);
      match(MySQLParser::FOR_SYMBOL);
      setState(6032);
      match(MySQLParser::QUERY_SYMBOL);
      setState(6033);
      match(MySQLParser::INT_NUMBER);
    }
    setState(6037);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIMIT_SYMBOL) {
      setState(6036);
      limitClause();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowStatusStatementContext::ShowStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

MySQLParser::OptionTypeContext* MySQLParser::ShowStatusStatementContext::optionType() {
  return getRuleContext<MySQLParser::OptionTypeContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowStatusStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowStatusStatement;
}

void MySQLParser::ShowStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowStatusStatement(this);
}

void MySQLParser::ShowStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowStatusStatement(this);
}


std::any MySQLParser::ShowStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowStatusStatementContext* MySQLParser::showStatusStatement() {
  ShowStatusStatementContext *_localctx = _tracker.createInstance<ShowStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 798, MySQLParser::RuleShowStatusStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6039);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6041);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 704, _ctx)) {
    case 1: {
      setState(6040);
      optionType();
      break;
    }

    default:
      break;
    }
    setState(6043);
    match(MySQLParser::STATUS_SYMBOL);
    setState(6045);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(6044);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowProcessListStatementContext ------------------------------------------------------------------

MySQLParser::ShowProcessListStatementContext::ShowProcessListStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowProcessListStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProcessListStatementContext::PROCESSLIST_SYMBOL() {
  return getToken(MySQLParser::PROCESSLIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProcessListStatementContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}


size_t MySQLParser::ShowProcessListStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowProcessListStatement;
}

void MySQLParser::ShowProcessListStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowProcessListStatement(this);
}

void MySQLParser::ShowProcessListStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowProcessListStatement(this);
}


std::any MySQLParser::ShowProcessListStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowProcessListStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowProcessListStatementContext* MySQLParser::showProcessListStatement() {
  ShowProcessListStatementContext *_localctx = _tracker.createInstance<ShowProcessListStatementContext>(_ctx, getState());
  enterRule(_localctx, 800, MySQLParser::RuleShowProcessListStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6047);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6049);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FULL_SYMBOL) {
      setState(6048);
      match(MySQLParser::FULL_SYMBOL);
    }
    setState(6051);
    match(MySQLParser::PROCESSLIST_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowVariablesStatementContext ------------------------------------------------------------------

MySQLParser::ShowVariablesStatementContext::ShowVariablesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowVariablesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowVariablesStatementContext::VARIABLES_SYMBOL() {
  return getToken(MySQLParser::VARIABLES_SYMBOL, 0);
}

MySQLParser::OptionTypeContext* MySQLParser::ShowVariablesStatementContext::optionType() {
  return getRuleContext<MySQLParser::OptionTypeContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowVariablesStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowVariablesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowVariablesStatement;
}

void MySQLParser::ShowVariablesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowVariablesStatement(this);
}

void MySQLParser::ShowVariablesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowVariablesStatement(this);
}


std::any MySQLParser::ShowVariablesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowVariablesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowVariablesStatementContext* MySQLParser::showVariablesStatement() {
  ShowVariablesStatementContext *_localctx = _tracker.createInstance<ShowVariablesStatementContext>(_ctx, getState());
  enterRule(_localctx, 802, MySQLParser::RuleShowVariablesStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6053);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6055);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 707, _ctx)) {
    case 1: {
      setState(6054);
      optionType();
      break;
    }

    default:
      break;
    }
    setState(6057);
    match(MySQLParser::VARIABLES_SYMBOL);
    setState(6059);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(6058);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCharacterSetStatementContext ------------------------------------------------------------------

MySQLParser::ShowCharacterSetStatementContext::ShowCharacterSetStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCharacterSetStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

MySQLParser::CharsetContext* MySQLParser::ShowCharacterSetStatementContext::charset() {
  return getRuleContext<MySQLParser::CharsetContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowCharacterSetStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowCharacterSetStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCharacterSetStatement;
}

void MySQLParser::ShowCharacterSetStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCharacterSetStatement(this);
}

void MySQLParser::ShowCharacterSetStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCharacterSetStatement(this);
}


std::any MySQLParser::ShowCharacterSetStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCharacterSetStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCharacterSetStatementContext* MySQLParser::showCharacterSetStatement() {
  ShowCharacterSetStatementContext *_localctx = _tracker.createInstance<ShowCharacterSetStatementContext>(_ctx, getState());
  enterRule(_localctx, 804, MySQLParser::RuleShowCharacterSetStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6061);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6062);
    charset();
    setState(6064);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(6063);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCollationStatementContext ------------------------------------------------------------------

MySQLParser::ShowCollationStatementContext::ShowCollationStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCollationStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCollationStatementContext::COLLATION_SYMBOL() {
  return getToken(MySQLParser::COLLATION_SYMBOL, 0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowCollationStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowCollationStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCollationStatement;
}

void MySQLParser::ShowCollationStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCollationStatement(this);
}

void MySQLParser::ShowCollationStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCollationStatement(this);
}


std::any MySQLParser::ShowCollationStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCollationStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCollationStatementContext* MySQLParser::showCollationStatement() {
  ShowCollationStatementContext *_localctx = _tracker.createInstance<ShowCollationStatementContext>(_ctx, getState());
  enterRule(_localctx, 806, MySQLParser::RuleShowCollationStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6066);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6067);
    match(MySQLParser::COLLATION_SYMBOL);
    setState(6069);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(6068);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowPrivilegesStatementContext ------------------------------------------------------------------

MySQLParser::ShowPrivilegesStatementContext::ShowPrivilegesStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowPrivilegesStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowPrivilegesStatementContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}


size_t MySQLParser::ShowPrivilegesStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowPrivilegesStatement;
}

void MySQLParser::ShowPrivilegesStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowPrivilegesStatement(this);
}

void MySQLParser::ShowPrivilegesStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowPrivilegesStatement(this);
}


std::any MySQLParser::ShowPrivilegesStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowPrivilegesStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowPrivilegesStatementContext* MySQLParser::showPrivilegesStatement() {
  ShowPrivilegesStatementContext *_localctx = _tracker.createInstance<ShowPrivilegesStatementContext>(_ctx, getState());
  enterRule(_localctx, 808, MySQLParser::RuleShowPrivilegesStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6071);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6072);
    match(MySQLParser::PRIVILEGES_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowGrantsStatementContext ------------------------------------------------------------------

MySQLParser::ShowGrantsStatementContext::ShowGrantsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowGrantsStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowGrantsStatementContext::GRANTS_SYMBOL() {
  return getToken(MySQLParser::GRANTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowGrantsStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::ShowGrantsStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::ShowGrantsStatementContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::ShowGrantsStatementContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}


size_t MySQLParser::ShowGrantsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowGrantsStatement;
}

void MySQLParser::ShowGrantsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowGrantsStatement(this);
}

void MySQLParser::ShowGrantsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowGrantsStatement(this);
}


std::any MySQLParser::ShowGrantsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowGrantsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowGrantsStatementContext* MySQLParser::showGrantsStatement() {
  ShowGrantsStatementContext *_localctx = _tracker.createInstance<ShowGrantsStatementContext>(_ctx, getState());
  enterRule(_localctx, 810, MySQLParser::RuleShowGrantsStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6074);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6075);
    match(MySQLParser::GRANTS_SYMBOL);
    setState(6082);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FOR_SYMBOL) {
      setState(6076);
      match(MySQLParser::FOR_SYMBOL);
      setState(6077);
      user();
      setState(6080);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::USING_SYMBOL) {
        setState(6078);
        match(MySQLParser::USING_SYMBOL);
        setState(6079);
        userList();
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateDatabaseStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateDatabaseStatementContext::ShowCreateDatabaseStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateDatabaseStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateDatabaseStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateDatabaseStatementContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

MySQLParser::SchemaRefContext* MySQLParser::ShowCreateDatabaseStatementContext::schemaRef() {
  return getRuleContext<MySQLParser::SchemaRefContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::ShowCreateDatabaseStatementContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}


size_t MySQLParser::ShowCreateDatabaseStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateDatabaseStatement;
}

void MySQLParser::ShowCreateDatabaseStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateDatabaseStatement(this);
}

void MySQLParser::ShowCreateDatabaseStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateDatabaseStatement(this);
}


std::any MySQLParser::ShowCreateDatabaseStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateDatabaseStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateDatabaseStatementContext* MySQLParser::showCreateDatabaseStatement() {
  ShowCreateDatabaseStatementContext *_localctx = _tracker.createInstance<ShowCreateDatabaseStatementContext>(_ctx, getState());
  enterRule(_localctx, 812, MySQLParser::RuleShowCreateDatabaseStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6084);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6085);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6086);
    match(MySQLParser::DATABASE_SYMBOL);
    setState(6088);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 713, _ctx)) {
    case 1: {
      setState(6087);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(6090);
    schemaRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateTableStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateTableStatementContext::ShowCreateTableStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateTableStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateTableStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateTableStatementContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::ShowCreateTableStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}


size_t MySQLParser::ShowCreateTableStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateTableStatement;
}

void MySQLParser::ShowCreateTableStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateTableStatement(this);
}

void MySQLParser::ShowCreateTableStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateTableStatement(this);
}


std::any MySQLParser::ShowCreateTableStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateTableStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateTableStatementContext* MySQLParser::showCreateTableStatement() {
  ShowCreateTableStatementContext *_localctx = _tracker.createInstance<ShowCreateTableStatementContext>(_ctx, getState());
  enterRule(_localctx, 814, MySQLParser::RuleShowCreateTableStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6092);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6093);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6094);
    match(MySQLParser::TABLE_SYMBOL);
    setState(6095);
    tableRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateViewStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateViewStatementContext::ShowCreateViewStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateViewStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateViewStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateViewStatementContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

MySQLParser::ViewRefContext* MySQLParser::ShowCreateViewStatementContext::viewRef() {
  return getRuleContext<MySQLParser::ViewRefContext>(0);
}


size_t MySQLParser::ShowCreateViewStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateViewStatement;
}

void MySQLParser::ShowCreateViewStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateViewStatement(this);
}

void MySQLParser::ShowCreateViewStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateViewStatement(this);
}


std::any MySQLParser::ShowCreateViewStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateViewStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateViewStatementContext* MySQLParser::showCreateViewStatement() {
  ShowCreateViewStatementContext *_localctx = _tracker.createInstance<ShowCreateViewStatementContext>(_ctx, getState());
  enterRule(_localctx, 816, MySQLParser::RuleShowCreateViewStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6097);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6098);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6099);
    match(MySQLParser::VIEW_SYMBOL);
    setState(6100);
    viewRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowMasterStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowMasterStatusStatementContext::ShowMasterStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowMasterStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowMasterStatusStatementContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowMasterStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}


size_t MySQLParser::ShowMasterStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowMasterStatusStatement;
}

void MySQLParser::ShowMasterStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowMasterStatusStatement(this);
}

void MySQLParser::ShowMasterStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowMasterStatusStatement(this);
}


std::any MySQLParser::ShowMasterStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowMasterStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowMasterStatusStatementContext* MySQLParser::showMasterStatusStatement() {
  ShowMasterStatusStatementContext *_localctx = _tracker.createInstance<ShowMasterStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 818, MySQLParser::RuleShowMasterStatusStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6102);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6103);
    match(MySQLParser::MASTER_SYMBOL);
    setState(6104);
    match(MySQLParser::STATUS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowReplicaStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowReplicaStatusStatementContext::ShowReplicaStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowReplicaStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

MySQLParser::ReplicaContext* MySQLParser::ShowReplicaStatusStatementContext::replica() {
  return getRuleContext<MySQLParser::ReplicaContext>(0);
}

tree::TerminalNode* MySQLParser::ShowReplicaStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowReplicaStatusStatementContext::NONBLOCKING_SYMBOL() {
  return getToken(MySQLParser::NONBLOCKING_SYMBOL, 0);
}

MySQLParser::ChannelContext* MySQLParser::ShowReplicaStatusStatementContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ShowReplicaStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowReplicaStatusStatement;
}

void MySQLParser::ShowReplicaStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowReplicaStatusStatement(this);
}

void MySQLParser::ShowReplicaStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowReplicaStatusStatement(this);
}


std::any MySQLParser::ShowReplicaStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowReplicaStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowReplicaStatusStatementContext* MySQLParser::showReplicaStatusStatement() {
  ShowReplicaStatusStatementContext *_localctx = _tracker.createInstance<ShowReplicaStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 820, MySQLParser::RuleShowReplicaStatusStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6106);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6107);
    replica();
    setState(6108);
    match(MySQLParser::STATUS_SYMBOL);
    setState(6111);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 714, _ctx)) {
    case 1: {
      setState(6109);

      if (!(serverVersion < 50706)) throw FailedPredicateException(this, "serverVersion < 50706");
      setState(6110);
      match(MySQLParser::NONBLOCKING_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(6114);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 715, _ctx)) {
    case 1: {
      setState(6113);
      channel();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateProcedureStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateProcedureStatementContext::ShowCreateProcedureStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateProcedureStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateProcedureStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateProcedureStatementContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

MySQLParser::ProcedureRefContext* MySQLParser::ShowCreateProcedureStatementContext::procedureRef() {
  return getRuleContext<MySQLParser::ProcedureRefContext>(0);
}


size_t MySQLParser::ShowCreateProcedureStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateProcedureStatement;
}

void MySQLParser::ShowCreateProcedureStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateProcedureStatement(this);
}

void MySQLParser::ShowCreateProcedureStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateProcedureStatement(this);
}


std::any MySQLParser::ShowCreateProcedureStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateProcedureStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateProcedureStatementContext* MySQLParser::showCreateProcedureStatement() {
  ShowCreateProcedureStatementContext *_localctx = _tracker.createInstance<ShowCreateProcedureStatementContext>(_ctx, getState());
  enterRule(_localctx, 822, MySQLParser::RuleShowCreateProcedureStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6116);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6117);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6118);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(6119);
    procedureRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateFunctionStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateFunctionStatementContext::ShowCreateFunctionStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateFunctionStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateFunctionStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateFunctionStatementContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

MySQLParser::FunctionRefContext* MySQLParser::ShowCreateFunctionStatementContext::functionRef() {
  return getRuleContext<MySQLParser::FunctionRefContext>(0);
}


size_t MySQLParser::ShowCreateFunctionStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateFunctionStatement;
}

void MySQLParser::ShowCreateFunctionStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateFunctionStatement(this);
}

void MySQLParser::ShowCreateFunctionStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateFunctionStatement(this);
}


std::any MySQLParser::ShowCreateFunctionStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateFunctionStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateFunctionStatementContext* MySQLParser::showCreateFunctionStatement() {
  ShowCreateFunctionStatementContext *_localctx = _tracker.createInstance<ShowCreateFunctionStatementContext>(_ctx, getState());
  enterRule(_localctx, 824, MySQLParser::RuleShowCreateFunctionStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6121);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6122);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6123);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(6124);
    functionRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateLibraryStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateLibraryStatementContext::ShowCreateLibraryStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateLibraryStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateLibraryStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateLibraryStatementContext::LIBRARY_SYMBOL() {
  return getToken(MySQLParser::LIBRARY_SYMBOL, 0);
}

MySQLParser::LibraryRefContext* MySQLParser::ShowCreateLibraryStatementContext::libraryRef() {
  return getRuleContext<MySQLParser::LibraryRefContext>(0);
}


size_t MySQLParser::ShowCreateLibraryStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateLibraryStatement;
}

void MySQLParser::ShowCreateLibraryStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateLibraryStatement(this);
}

void MySQLParser::ShowCreateLibraryStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateLibraryStatement(this);
}


std::any MySQLParser::ShowCreateLibraryStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateLibraryStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateLibraryStatementContext* MySQLParser::showCreateLibraryStatement() {
  ShowCreateLibraryStatementContext *_localctx = _tracker.createInstance<ShowCreateLibraryStatementContext>(_ctx, getState());
  enterRule(_localctx, 826, MySQLParser::RuleShowCreateLibraryStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6126);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6127);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6128);
    match(MySQLParser::LIBRARY_SYMBOL);
    setState(6129);
    libraryRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateTriggerStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateTriggerStatementContext::ShowCreateTriggerStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateTriggerStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateTriggerStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateTriggerStatementContext::TRIGGER_SYMBOL() {
  return getToken(MySQLParser::TRIGGER_SYMBOL, 0);
}

MySQLParser::TriggerRefContext* MySQLParser::ShowCreateTriggerStatementContext::triggerRef() {
  return getRuleContext<MySQLParser::TriggerRefContext>(0);
}


size_t MySQLParser::ShowCreateTriggerStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateTriggerStatement;
}

void MySQLParser::ShowCreateTriggerStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateTriggerStatement(this);
}

void MySQLParser::ShowCreateTriggerStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateTriggerStatement(this);
}


std::any MySQLParser::ShowCreateTriggerStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateTriggerStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateTriggerStatementContext* MySQLParser::showCreateTriggerStatement() {
  ShowCreateTriggerStatementContext *_localctx = _tracker.createInstance<ShowCreateTriggerStatementContext>(_ctx, getState());
  enterRule(_localctx, 828, MySQLParser::RuleShowCreateTriggerStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6131);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6132);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6133);
    match(MySQLParser::TRIGGER_SYMBOL);
    setState(6134);
    triggerRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowProcedureStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowProcedureStatusStatementContext::ShowProcedureStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowProcedureStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProcedureStatusStatementContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProcedureStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowProcedureStatusStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowProcedureStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowProcedureStatusStatement;
}

void MySQLParser::ShowProcedureStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowProcedureStatusStatement(this);
}

void MySQLParser::ShowProcedureStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowProcedureStatusStatement(this);
}


std::any MySQLParser::ShowProcedureStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowProcedureStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowProcedureStatusStatementContext* MySQLParser::showProcedureStatusStatement() {
  ShowProcedureStatusStatementContext *_localctx = _tracker.createInstance<ShowProcedureStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 830, MySQLParser::RuleShowProcedureStatusStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6136);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6137);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(6138);
    match(MySQLParser::STATUS_SYMBOL);
    setState(6140);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(6139);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowFunctionStatusStatementContext ------------------------------------------------------------------

MySQLParser::ShowFunctionStatusStatementContext::ShowFunctionStatusStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowFunctionStatusStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowFunctionStatusStatementContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowFunctionStatusStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowFunctionStatusStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}


size_t MySQLParser::ShowFunctionStatusStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowFunctionStatusStatement;
}

void MySQLParser::ShowFunctionStatusStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowFunctionStatusStatement(this);
}

void MySQLParser::ShowFunctionStatusStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowFunctionStatusStatement(this);
}


std::any MySQLParser::ShowFunctionStatusStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowFunctionStatusStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowFunctionStatusStatementContext* MySQLParser::showFunctionStatusStatement() {
  ShowFunctionStatusStatementContext *_localctx = _tracker.createInstance<ShowFunctionStatusStatementContext>(_ctx, getState());
  enterRule(_localctx, 832, MySQLParser::RuleShowFunctionStatusStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6142);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6143);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(6144);
    match(MySQLParser::STATUS_SYMBOL);
    setState(6146);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
      setState(6145);
      likeOrWhere();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowProcedureCodeStatementContext ------------------------------------------------------------------

MySQLParser::ShowProcedureCodeStatementContext::ShowProcedureCodeStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowProcedureCodeStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProcedureCodeStatementContext::PROCEDURE_SYMBOL() {
  return getToken(MySQLParser::PROCEDURE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowProcedureCodeStatementContext::CODE_SYMBOL() {
  return getToken(MySQLParser::CODE_SYMBOL, 0);
}

MySQLParser::ProcedureRefContext* MySQLParser::ShowProcedureCodeStatementContext::procedureRef() {
  return getRuleContext<MySQLParser::ProcedureRefContext>(0);
}


size_t MySQLParser::ShowProcedureCodeStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowProcedureCodeStatement;
}

void MySQLParser::ShowProcedureCodeStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowProcedureCodeStatement(this);
}

void MySQLParser::ShowProcedureCodeStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowProcedureCodeStatement(this);
}


std::any MySQLParser::ShowProcedureCodeStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowProcedureCodeStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowProcedureCodeStatementContext* MySQLParser::showProcedureCodeStatement() {
  ShowProcedureCodeStatementContext *_localctx = _tracker.createInstance<ShowProcedureCodeStatementContext>(_ctx, getState());
  enterRule(_localctx, 834, MySQLParser::RuleShowProcedureCodeStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6148);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6149);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(6150);
    match(MySQLParser::CODE_SYMBOL);
    setState(6151);
    procedureRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowFunctionCodeStatementContext ------------------------------------------------------------------

MySQLParser::ShowFunctionCodeStatementContext::ShowFunctionCodeStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowFunctionCodeStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowFunctionCodeStatementContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowFunctionCodeStatementContext::CODE_SYMBOL() {
  return getToken(MySQLParser::CODE_SYMBOL, 0);
}

MySQLParser::FunctionRefContext* MySQLParser::ShowFunctionCodeStatementContext::functionRef() {
  return getRuleContext<MySQLParser::FunctionRefContext>(0);
}


size_t MySQLParser::ShowFunctionCodeStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowFunctionCodeStatement;
}

void MySQLParser::ShowFunctionCodeStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowFunctionCodeStatement(this);
}

void MySQLParser::ShowFunctionCodeStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowFunctionCodeStatement(this);
}


std::any MySQLParser::ShowFunctionCodeStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowFunctionCodeStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowFunctionCodeStatementContext* MySQLParser::showFunctionCodeStatement() {
  ShowFunctionCodeStatementContext *_localctx = _tracker.createInstance<ShowFunctionCodeStatementContext>(_ctx, getState());
  enterRule(_localctx, 836, MySQLParser::RuleShowFunctionCodeStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6153);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6154);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(6155);
    match(MySQLParser::CODE_SYMBOL);
    setState(6156);
    functionRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateEventStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateEventStatementContext::ShowCreateEventStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateEventStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateEventStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateEventStatementContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

MySQLParser::EventRefContext* MySQLParser::ShowCreateEventStatementContext::eventRef() {
  return getRuleContext<MySQLParser::EventRefContext>(0);
}


size_t MySQLParser::ShowCreateEventStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateEventStatement;
}

void MySQLParser::ShowCreateEventStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateEventStatement(this);
}

void MySQLParser::ShowCreateEventStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateEventStatement(this);
}


std::any MySQLParser::ShowCreateEventStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateEventStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateEventStatementContext* MySQLParser::showCreateEventStatement() {
  ShowCreateEventStatementContext *_localctx = _tracker.createInstance<ShowCreateEventStatementContext>(_ctx, getState());
  enterRule(_localctx, 838, MySQLParser::RuleShowCreateEventStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6158);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6159);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6160);
    match(MySQLParser::EVENT_SYMBOL);
    setState(6161);
    eventRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCreateUserStatementContext ------------------------------------------------------------------

MySQLParser::ShowCreateUserStatementContext::ShowCreateUserStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCreateUserStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateUserStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCreateUserStatementContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::ShowCreateUserStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}


size_t MySQLParser::ShowCreateUserStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowCreateUserStatement;
}

void MySQLParser::ShowCreateUserStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCreateUserStatement(this);
}

void MySQLParser::ShowCreateUserStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCreateUserStatement(this);
}


std::any MySQLParser::ShowCreateUserStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCreateUserStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCreateUserStatementContext* MySQLParser::showCreateUserStatement() {
  ShowCreateUserStatementContext *_localctx = _tracker.createInstance<ShowCreateUserStatementContext>(_ctx, getState());
  enterRule(_localctx, 840, MySQLParser::RuleShowCreateUserStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6163);
    match(MySQLParser::SHOW_SYMBOL);
    setState(6164);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6165);
    match(MySQLParser::USER_SYMBOL);
    setState(6166);
    user();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ShowCommandTypeContext ------------------------------------------------------------------

MySQLParser::ShowCommandTypeContext::ShowCommandTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ShowCommandTypeContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowCommandTypeContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}


size_t MySQLParser::ShowCommandTypeContext::getRuleIndex() const {
  return MySQLParser::RuleShowCommandType;
}

void MySQLParser::ShowCommandTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterShowCommandType(this);
}

void MySQLParser::ShowCommandTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitShowCommandType(this);
}


std::any MySQLParser::ShowCommandTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitShowCommandType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ShowCommandTypeContext* MySQLParser::showCommandType() {
  ShowCommandTypeContext *_localctx = _tracker.createInstance<ShowCommandTypeContext>(_ctx, getState());
  enterRule(_localctx, 842, MySQLParser::RuleShowCommandType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6174);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 719, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6168);
      match(MySQLParser::FULL_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6169);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(6170);
      match(MySQLParser::EXTENDED_SYMBOL);
      setState(6172);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FULL_SYMBOL) {
        setState(6171);
        match(MySQLParser::FULL_SYMBOL);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EngineOrAllContext ------------------------------------------------------------------

MySQLParser::EngineOrAllContext::EngineOrAllContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::EngineRefContext* MySQLParser::EngineOrAllContext::engineRef() {
  return getRuleContext<MySQLParser::EngineRefContext>(0);
}

tree::TerminalNode* MySQLParser::EngineOrAllContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}


size_t MySQLParser::EngineOrAllContext::getRuleIndex() const {
  return MySQLParser::RuleEngineOrAll;
}

void MySQLParser::EngineOrAllContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEngineOrAll(this);
}

void MySQLParser::EngineOrAllContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEngineOrAll(this);
}


std::any MySQLParser::EngineOrAllContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitEngineOrAll(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::EngineOrAllContext* MySQLParser::engineOrAll() {
  EngineOrAllContext *_localctx = _tracker.createInstance<EngineOrAllContext>(_ctx, getState());
  enterRule(_localctx, 844, MySQLParser::RuleEngineOrAll);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6178);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 720, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6176);
      engineRef();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6177);
      match(MySQLParser::ALL_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FromOrInContext ------------------------------------------------------------------

MySQLParser::FromOrInContext::FromOrInContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FromOrInContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FromOrInContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}


size_t MySQLParser::FromOrInContext::getRuleIndex() const {
  return MySQLParser::RuleFromOrIn;
}

void MySQLParser::FromOrInContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFromOrIn(this);
}

void MySQLParser::FromOrInContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFromOrIn(this);
}


std::any MySQLParser::FromOrInContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFromOrIn(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FromOrInContext* MySQLParser::fromOrIn() {
  FromOrInContext *_localctx = _tracker.createInstance<FromOrInContext>(_ctx, getState());
  enterRule(_localctx, 846, MySQLParser::RuleFromOrIn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6180);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::FROM_SYMBOL

    || _la == MySQLParser::IN_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InDbContext ------------------------------------------------------------------

MySQLParser::InDbContext::InDbContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::FromOrInContext* MySQLParser::InDbContext::fromOrIn() {
  return getRuleContext<MySQLParser::FromOrInContext>(0);
}

MySQLParser::IdentifierContext* MySQLParser::InDbContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::InDbContext::getRuleIndex() const {
  return MySQLParser::RuleInDb;
}

void MySQLParser::InDbContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInDb(this);
}

void MySQLParser::InDbContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInDb(this);
}


std::any MySQLParser::InDbContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInDb(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InDbContext* MySQLParser::inDb() {
  InDbContext *_localctx = _tracker.createInstance<InDbContext>(_ctx, getState());
  enterRule(_localctx, 848, MySQLParser::RuleInDb);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6182);
    fromOrIn();
    setState(6183);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProfileDefinitionsContext ------------------------------------------------------------------

MySQLParser::ProfileDefinitionsContext::ProfileDefinitionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::ProfileDefinitionContext *> MySQLParser::ProfileDefinitionsContext::profileDefinition() {
  return getRuleContexts<MySQLParser::ProfileDefinitionContext>();
}

MySQLParser::ProfileDefinitionContext* MySQLParser::ProfileDefinitionsContext::profileDefinition(size_t i) {
  return getRuleContext<MySQLParser::ProfileDefinitionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ProfileDefinitionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ProfileDefinitionsContext::getRuleIndex() const {
  return MySQLParser::RuleProfileDefinitions;
}

void MySQLParser::ProfileDefinitionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProfileDefinitions(this);
}

void MySQLParser::ProfileDefinitionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProfileDefinitions(this);
}


std::any MySQLParser::ProfileDefinitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitProfileDefinitions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ProfileDefinitionsContext* MySQLParser::profileDefinitions() {
  ProfileDefinitionsContext *_localctx = _tracker.createInstance<ProfileDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 850, MySQLParser::RuleProfileDefinitions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6185);
    profileDefinition();
    setState(6190);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6186);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6187);
      profileDefinition();
      setState(6192);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProfileDefinitionContext ------------------------------------------------------------------

MySQLParser::ProfileDefinitionContext::ProfileDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::BLOCK_SYMBOL() {
  return getToken(MySQLParser::BLOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::IO_SYMBOL() {
  return getToken(MySQLParser::IO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::CONTEXT_SYMBOL() {
  return getToken(MySQLParser::CONTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::SWITCHES_SYMBOL() {
  return getToken(MySQLParser::SWITCHES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::PAGE_SYMBOL() {
  return getToken(MySQLParser::PAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::FAULTS_SYMBOL() {
  return getToken(MySQLParser::FAULTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::CPU_SYMBOL() {
  return getToken(MySQLParser::CPU_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::IPC_SYMBOL() {
  return getToken(MySQLParser::IPC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::SOURCE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileDefinitionContext::SWAPS_SYMBOL() {
  return getToken(MySQLParser::SWAPS_SYMBOL, 0);
}


size_t MySQLParser::ProfileDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleProfileDefinition;
}

void MySQLParser::ProfileDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProfileDefinition(this);
}

void MySQLParser::ProfileDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProfileDefinition(this);
}


std::any MySQLParser::ProfileDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitProfileDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ProfileDefinitionContext* MySQLParser::profileDefinition() {
  ProfileDefinitionContext *_localctx = _tracker.createInstance<ProfileDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 852, MySQLParser::RuleProfileDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6200);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::BLOCK_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6193);
        match(MySQLParser::BLOCK_SYMBOL);
        setState(6194);
        match(MySQLParser::IO_SYMBOL);
        break;
      }

      case MySQLParser::CONTEXT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6195);
        match(MySQLParser::CONTEXT_SYMBOL);
        setState(6196);
        match(MySQLParser::SWITCHES_SYMBOL);
        break;
      }

      case MySQLParser::PAGE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(6197);
        match(MySQLParser::PAGE_SYMBOL);
        setState(6198);
        match(MySQLParser::FAULTS_SYMBOL);
        break;
      }

      case MySQLParser::ALL_SYMBOL:
      case MySQLParser::CPU_SYMBOL:
      case MySQLParser::IPC_SYMBOL:
      case MySQLParser::MEMORY_SYMBOL:
      case MySQLParser::SOURCE_SYMBOL:
      case MySQLParser::SWAPS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(6199);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::ALL_SYMBOL || _la == MySQLParser::CPU_SYMBOL || _la == MySQLParser::IPC_SYMBOL || _la == MySQLParser::MEMORY_SYMBOL || _la == MySQLParser::SOURCE_SYMBOL

        || _la == MySQLParser::SWAPS_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OtherAdministrativeStatementContext ------------------------------------------------------------------

MySQLParser::OtherAdministrativeStatementContext::OtherAdministrativeStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextLiteralContext* MySQLParser::OtherAdministrativeStatementContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::BINLOG_SYMBOL() {
  return getToken(MySQLParser::BINLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

MySQLParser::KeyCacheListOrPartsContext* MySQLParser::OtherAdministrativeStatementContext::keyCacheListOrParts() {
  return getRuleContext<MySQLParser::KeyCacheListOrPartsContext>(0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::CACHE_SYMBOL() {
  return getToken(MySQLParser::CACHE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::OtherAdministrativeStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::FLUSH_SYMBOL() {
  return getToken(MySQLParser::FLUSH_SYMBOL, 0);
}

MySQLParser::FlushTablesContext* MySQLParser::OtherAdministrativeStatementContext::flushTables() {
  return getRuleContext<MySQLParser::FlushTablesContext>(0);
}

std::vector<MySQLParser::FlushOptionContext *> MySQLParser::OtherAdministrativeStatementContext::flushOption() {
  return getRuleContexts<MySQLParser::FlushOptionContext>();
}

MySQLParser::FlushOptionContext* MySQLParser::OtherAdministrativeStatementContext::flushOption(size_t i) {
  return getRuleContext<MySQLParser::FlushOptionContext>(i);
}

MySQLParser::NoWriteToBinLogContext* MySQLParser::OtherAdministrativeStatementContext::noWriteToBinLog() {
  return getRuleContext<MySQLParser::NoWriteToBinLogContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::OtherAdministrativeStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

MySQLParser::ExprContext* MySQLParser::OtherAdministrativeStatementContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::KILL_SYMBOL() {
  return getToken(MySQLParser::KILL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::CONNECTION_SYMBOL() {
  return getToken(MySQLParser::CONNECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

MySQLParser::PreloadTailContext* MySQLParser::OtherAdministrativeStatementContext::preloadTail() {
  return getRuleContext<MySQLParser::PreloadTailContext>(0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::LOAD_SYMBOL() {
  return getToken(MySQLParser::LOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OtherAdministrativeStatementContext::SHUTDOWN_SYMBOL() {
  return getToken(MySQLParser::SHUTDOWN_SYMBOL, 0);
}


size_t MySQLParser::OtherAdministrativeStatementContext::getRuleIndex() const {
  return MySQLParser::RuleOtherAdministrativeStatement;
}

void MySQLParser::OtherAdministrativeStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOtherAdministrativeStatement(this);
}

void MySQLParser::OtherAdministrativeStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOtherAdministrativeStatement(this);
}


std::any MySQLParser::OtherAdministrativeStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOtherAdministrativeStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OtherAdministrativeStatementContext* MySQLParser::otherAdministrativeStatement() {
  OtherAdministrativeStatementContext *_localctx = _tracker.createInstance<OtherAdministrativeStatementContext>(_ctx, getState());
  enterRule(_localctx, 854, MySQLParser::RuleOtherAdministrativeStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6239);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 728, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6202);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::BINLOG_SYMBOL);
      setState(6203);
      textLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6204);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::CACHE_SYMBOL);
      setState(6205);
      match(MySQLParser::INDEX_SYMBOL);
      setState(6206);
      keyCacheListOrParts();
      setState(6207);
      match(MySQLParser::IN_SYMBOL);
      setState(6210);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 723, _ctx)) {
      case 1: {
        setState(6208);
        identifier();
        break;
      }

      case 2: {
        setState(6209);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6212);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::FLUSH_SYMBOL);
      setState(6214);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 724, _ctx)) {
      case 1: {
        setState(6213);
        noWriteToBinLog();
        break;
      }

      default:
        break;
      }
      setState(6225);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 726, _ctx)) {
      case 1: {
        setState(6216);
        flushTables();
        break;
      }

      case 2: {
        setState(6217);
        flushOption();
        setState(6222);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::COMMA_SYMBOL) {
          setState(6218);
          match(MySQLParser::COMMA_SYMBOL);
          setState(6219);
          flushOption();
          setState(6224);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6227);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::KILL_SYMBOL);
      setState(6229);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 727, _ctx)) {
      case 1: {
        setState(6228);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::CONNECTION_SYMBOL || _la == MySQLParser::QUERY_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      default:
        break;
      }
      setState(6231);
      expr(0);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6232);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::LOAD_SYMBOL);
      setState(6233);
      match(MySQLParser::INDEX_SYMBOL);
      setState(6234);
      match(MySQLParser::INTO_SYMBOL);
      setState(6235);
      match(MySQLParser::CACHE_SYMBOL);
      setState(6236);
      preloadTail();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6237);

      if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
      setState(6238);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::SHUTDOWN_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyCacheListOrPartsContext ------------------------------------------------------------------

MySQLParser::KeyCacheListOrPartsContext::KeyCacheListOrPartsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::KeyCacheListContext* MySQLParser::KeyCacheListOrPartsContext::keyCacheList() {
  return getRuleContext<MySQLParser::KeyCacheListContext>(0);
}

MySQLParser::AssignToKeycachePartitionContext* MySQLParser::KeyCacheListOrPartsContext::assignToKeycachePartition() {
  return getRuleContext<MySQLParser::AssignToKeycachePartitionContext>(0);
}


size_t MySQLParser::KeyCacheListOrPartsContext::getRuleIndex() const {
  return MySQLParser::RuleKeyCacheListOrParts;
}

void MySQLParser::KeyCacheListOrPartsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyCacheListOrParts(this);
}

void MySQLParser::KeyCacheListOrPartsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyCacheListOrParts(this);
}


std::any MySQLParser::KeyCacheListOrPartsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyCacheListOrParts(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyCacheListOrPartsContext* MySQLParser::keyCacheListOrParts() {
  KeyCacheListOrPartsContext *_localctx = _tracker.createInstance<KeyCacheListOrPartsContext>(_ctx, getState());
  enterRule(_localctx, 856, MySQLParser::RuleKeyCacheListOrParts);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6243);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 729, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6241);
      keyCacheList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6242);
      assignToKeycachePartition();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyCacheListContext ------------------------------------------------------------------

MySQLParser::KeyCacheListContext::KeyCacheListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::AssignToKeycacheContext *> MySQLParser::KeyCacheListContext::assignToKeycache() {
  return getRuleContexts<MySQLParser::AssignToKeycacheContext>();
}

MySQLParser::AssignToKeycacheContext* MySQLParser::KeyCacheListContext::assignToKeycache(size_t i) {
  return getRuleContext<MySQLParser::AssignToKeycacheContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::KeyCacheListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::KeyCacheListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::KeyCacheListContext::getRuleIndex() const {
  return MySQLParser::RuleKeyCacheList;
}

void MySQLParser::KeyCacheListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyCacheList(this);
}

void MySQLParser::KeyCacheListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyCacheList(this);
}


std::any MySQLParser::KeyCacheListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyCacheList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyCacheListContext* MySQLParser::keyCacheList() {
  KeyCacheListContext *_localctx = _tracker.createInstance<KeyCacheListContext>(_ctx, getState());
  enterRule(_localctx, 858, MySQLParser::RuleKeyCacheList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6245);
    assignToKeycache();
    setState(6250);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6246);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6247);
      assignToKeycache();
      setState(6252);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignToKeycacheContext ------------------------------------------------------------------

MySQLParser::AssignToKeycacheContext::AssignToKeycacheContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::AssignToKeycacheContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::CacheKeyListContext* MySQLParser::AssignToKeycacheContext::cacheKeyList() {
  return getRuleContext<MySQLParser::CacheKeyListContext>(0);
}


size_t MySQLParser::AssignToKeycacheContext::getRuleIndex() const {
  return MySQLParser::RuleAssignToKeycache;
}

void MySQLParser::AssignToKeycacheContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAssignToKeycache(this);
}

void MySQLParser::AssignToKeycacheContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAssignToKeycache(this);
}


std::any MySQLParser::AssignToKeycacheContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAssignToKeycache(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AssignToKeycacheContext* MySQLParser::assignToKeycache() {
  AssignToKeycacheContext *_localctx = _tracker.createInstance<AssignToKeycacheContext>(_ctx, getState());
  enterRule(_localctx, 860, MySQLParser::RuleAssignToKeycache);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6253);
    tableRef();
    setState(6255);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::INDEX_SYMBOL

    || _la == MySQLParser::KEY_SYMBOL) {
      setState(6254);
      cacheKeyList();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AssignToKeycachePartitionContext ------------------------------------------------------------------

MySQLParser::AssignToKeycachePartitionContext::AssignToKeycachePartitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::AssignToKeycachePartitionContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::AssignToKeycachePartitionContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AssignToKeycachePartitionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::AllOrPartitionNameListContext* MySQLParser::AssignToKeycachePartitionContext::allOrPartitionNameList() {
  return getRuleContext<MySQLParser::AllOrPartitionNameListContext>(0);
}

tree::TerminalNode* MySQLParser::AssignToKeycachePartitionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::CacheKeyListContext* MySQLParser::AssignToKeycachePartitionContext::cacheKeyList() {
  return getRuleContext<MySQLParser::CacheKeyListContext>(0);
}


size_t MySQLParser::AssignToKeycachePartitionContext::getRuleIndex() const {
  return MySQLParser::RuleAssignToKeycachePartition;
}

void MySQLParser::AssignToKeycachePartitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAssignToKeycachePartition(this);
}

void MySQLParser::AssignToKeycachePartitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAssignToKeycachePartition(this);
}


std::any MySQLParser::AssignToKeycachePartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAssignToKeycachePartition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AssignToKeycachePartitionContext* MySQLParser::assignToKeycachePartition() {
  AssignToKeycachePartitionContext *_localctx = _tracker.createInstance<AssignToKeycachePartitionContext>(_ctx, getState());
  enterRule(_localctx, 862, MySQLParser::RuleAssignToKeycachePartition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6257);
    tableRef();
    setState(6258);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(6259);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6260);
    allOrPartitionNameList();
    setState(6261);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(6263);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::INDEX_SYMBOL

    || _la == MySQLParser::KEY_SYMBOL) {
      setState(6262);
      cacheKeyList();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CacheKeyListContext ------------------------------------------------------------------

MySQLParser::CacheKeyListContext::CacheKeyListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::KeyOrIndexContext* MySQLParser::CacheKeyListContext::keyOrIndex() {
  return getRuleContext<MySQLParser::KeyOrIndexContext>(0);
}

tree::TerminalNode* MySQLParser::CacheKeyListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CacheKeyListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::KeyUsageListContext* MySQLParser::CacheKeyListContext::keyUsageList() {
  return getRuleContext<MySQLParser::KeyUsageListContext>(0);
}


size_t MySQLParser::CacheKeyListContext::getRuleIndex() const {
  return MySQLParser::RuleCacheKeyList;
}

void MySQLParser::CacheKeyListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCacheKeyList(this);
}

void MySQLParser::CacheKeyListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCacheKeyList(this);
}


std::any MySQLParser::CacheKeyListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCacheKeyList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CacheKeyListContext* MySQLParser::cacheKeyList() {
  CacheKeyListContext *_localctx = _tracker.createInstance<CacheKeyListContext>(_ctx, getState());
  enterRule(_localctx, 864, MySQLParser::RuleCacheKeyList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6265);
    keyOrIndex();
    setState(6266);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6268);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 733, _ctx)) {
    case 1: {
      setState(6267);
      keyUsageList();
      break;
    }

    default:
      break;
    }
    setState(6270);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyUsageElementContext ------------------------------------------------------------------

MySQLParser::KeyUsageElementContext::KeyUsageElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::KeyUsageElementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::KeyUsageElementContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}


size_t MySQLParser::KeyUsageElementContext::getRuleIndex() const {
  return MySQLParser::RuleKeyUsageElement;
}

void MySQLParser::KeyUsageElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyUsageElement(this);
}

void MySQLParser::KeyUsageElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyUsageElement(this);
}


std::any MySQLParser::KeyUsageElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyUsageElement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyUsageElementContext* MySQLParser::keyUsageElement() {
  KeyUsageElementContext *_localctx = _tracker.createInstance<KeyUsageElementContext>(_ctx, getState());
  enterRule(_localctx, 866, MySQLParser::RuleKeyUsageElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6274);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 734, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6272);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6273);
      match(MySQLParser::PRIMARY_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyUsageListContext ------------------------------------------------------------------

MySQLParser::KeyUsageListContext::KeyUsageListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::KeyUsageElementContext *> MySQLParser::KeyUsageListContext::keyUsageElement() {
  return getRuleContexts<MySQLParser::KeyUsageElementContext>();
}

MySQLParser::KeyUsageElementContext* MySQLParser::KeyUsageListContext::keyUsageElement(size_t i) {
  return getRuleContext<MySQLParser::KeyUsageElementContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::KeyUsageListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::KeyUsageListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::KeyUsageListContext::getRuleIndex() const {
  return MySQLParser::RuleKeyUsageList;
}

void MySQLParser::KeyUsageListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyUsageList(this);
}

void MySQLParser::KeyUsageListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyUsageList(this);
}


std::any MySQLParser::KeyUsageListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyUsageList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyUsageListContext* MySQLParser::keyUsageList() {
  KeyUsageListContext *_localctx = _tracker.createInstance<KeyUsageListContext>(_ctx, getState());
  enterRule(_localctx, 868, MySQLParser::RuleKeyUsageList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6276);
    keyUsageElement();
    setState(6281);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6277);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6278);
      keyUsageElement();
      setState(6283);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FlushOptionContext ------------------------------------------------------------------

MySQLParser::FlushOptionContext::FlushOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FlushOptionContext::DES_KEY_FILE_SYMBOL() {
  return getToken(MySQLParser::DES_KEY_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::USER_RESOURCES_SYMBOL() {
  return getToken(MySQLParser::USER_RESOURCES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::HOSTS_SYMBOL() {
  return getToken(MySQLParser::HOSTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

MySQLParser::LogTypeContext* MySQLParser::FlushOptionContext::logType() {
  return getRuleContext<MySQLParser::LogTypeContext>(0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::RELAY_SYMBOL() {
  return getToken(MySQLParser::RELAY_SYMBOL, 0);
}

MySQLParser::ChannelContext* MySQLParser::FlushOptionContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::CACHE_SYMBOL() {
  return getToken(MySQLParser::CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushOptionContext::OPTIMIZER_COSTS_SYMBOL() {
  return getToken(MySQLParser::OPTIMIZER_COSTS_SYMBOL, 0);
}


size_t MySQLParser::FlushOptionContext::getRuleIndex() const {
  return MySQLParser::RuleFlushOption;
}

void MySQLParser::FlushOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFlushOption(this);
}

void MySQLParser::FlushOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFlushOption(this);
}


std::any MySQLParser::FlushOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFlushOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FlushOptionContext* MySQLParser::flushOption() {
  FlushOptionContext *_localctx = _tracker.createInstance<FlushOptionContext>(_ctx, getState());
  enterRule(_localctx, 870, MySQLParser::RuleFlushOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6301);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 738, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6284);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DES_KEY_FILE_SYMBOL || _la == MySQLParser::PRIVILEGES_SYMBOL || _la == MySQLParser::STATUS_SYMBOL || _la == MySQLParser::USER_RESOURCES_SYMBOL)) {
        antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6285);

      if (!(serverVersion < 80300)) throw FailedPredicateException(this, "serverVersion < 80300");
      setState(6286);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::HOSTS_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6288);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::BINARY_SYMBOL || ((((_la - 202) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 202)) & ((1ULL << (MySQLParser::ENGINE_SYMBOL - 202))
        | (1ULL << (MySQLParser::ERROR_SYMBOL - 202))
        | (1ULL << (MySQLParser::GENERAL_SYMBOL - 202)))) != 0) || _la == MySQLParser::SLOW_SYMBOL) {
        setState(6287);
        logType();
      }
      setState(6290);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::LOGS_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6291);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::RELAY_SYMBOL);
      setState(6292);
      match(MySQLParser::LOGS_SYMBOL);
      setState(6294);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 737, _ctx)) {
      case 1: {
        setState(6293);
        channel();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6296);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(6297);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::QUERY_SYMBOL);
      setState(6298);
      match(MySQLParser::CACHE_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6299);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(6300);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::OPTIMIZER_COSTS_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogTypeContext ------------------------------------------------------------------

MySQLParser::LogTypeContext::LogTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LogTypeContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LogTypeContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LogTypeContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LogTypeContext::GENERAL_SYMBOL() {
  return getToken(MySQLParser::GENERAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LogTypeContext::SLOW_SYMBOL() {
  return getToken(MySQLParser::SLOW_SYMBOL, 0);
}


size_t MySQLParser::LogTypeContext::getRuleIndex() const {
  return MySQLParser::RuleLogType;
}

void MySQLParser::LogTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLogType(this);
}

void MySQLParser::LogTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLogType(this);
}


std::any MySQLParser::LogTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLogType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LogTypeContext* MySQLParser::logType() {
  LogTypeContext *_localctx = _tracker.createInstance<LogTypeContext>(_ctx, getState());
  enterRule(_localctx, 872, MySQLParser::RuleLogType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6303);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::BINARY_SYMBOL || ((((_la - 202) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 202)) & ((1ULL << (MySQLParser::ENGINE_SYMBOL - 202))
      | (1ULL << (MySQLParser::ERROR_SYMBOL - 202))
      | (1ULL << (MySQLParser::GENERAL_SYMBOL - 202)))) != 0) || _la == MySQLParser::SLOW_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FlushTablesContext ------------------------------------------------------------------

MySQLParser::FlushTablesContext::FlushTablesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FlushTablesContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesContext::TABLE_SYMBOL() {
  return getToken(MySQLParser::TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::FlushTablesContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

MySQLParser::FlushTablesOptionsContext* MySQLParser::FlushTablesContext::flushTablesOptions() {
  return getRuleContext<MySQLParser::FlushTablesOptionsContext>(0);
}


size_t MySQLParser::FlushTablesContext::getRuleIndex() const {
  return MySQLParser::RuleFlushTables;
}

void MySQLParser::FlushTablesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFlushTables(this);
}

void MySQLParser::FlushTablesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFlushTables(this);
}


std::any MySQLParser::FlushTablesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFlushTables(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FlushTablesContext* MySQLParser::flushTables() {
  FlushTablesContext *_localctx = _tracker.createInstance<FlushTablesContext>(_ctx, getState());
  enterRule(_localctx, 874, MySQLParser::RuleFlushTables);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6305);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TABLES_SYMBOL

    || _la == MySQLParser::TABLE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(6313);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 740, _ctx)) {
    case 1: {
      setState(6306);
      match(MySQLParser::WITH_SYMBOL);
      setState(6307);
      match(MySQLParser::READ_SYMBOL);
      setState(6308);
      match(MySQLParser::LOCK_SYMBOL);
      break;
    }

    case 2: {
      setState(6309);
      identifierList();
      setState(6311);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL || _la == MySQLParser::WITH_SYMBOL) {
        setState(6310);
        flushTablesOptions();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FlushTablesOptionsContext ------------------------------------------------------------------

MySQLParser::FlushTablesOptionsContext::FlushTablesOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FlushTablesOptionsContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesOptionsContext::EXPORT_SYMBOL() {
  return getToken(MySQLParser::EXPORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesOptionsContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesOptionsContext::READ_SYMBOL() {
  return getToken(MySQLParser::READ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FlushTablesOptionsContext::LOCK_SYMBOL() {
  return getToken(MySQLParser::LOCK_SYMBOL, 0);
}


size_t MySQLParser::FlushTablesOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleFlushTablesOptions;
}

void MySQLParser::FlushTablesOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFlushTablesOptions(this);
}

void MySQLParser::FlushTablesOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFlushTablesOptions(this);
}


std::any MySQLParser::FlushTablesOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFlushTablesOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FlushTablesOptionsContext* MySQLParser::flushTablesOptions() {
  FlushTablesOptionsContext *_localctx = _tracker.createInstance<FlushTablesOptionsContext>(_ctx, getState());
  enterRule(_localctx, 876, MySQLParser::RuleFlushTablesOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6320);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FOR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6315);
        match(MySQLParser::FOR_SYMBOL);
        setState(6316);
        match(MySQLParser::EXPORT_SYMBOL);
        break;
      }

      case MySQLParser::WITH_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6317);
        match(MySQLParser::WITH_SYMBOL);
        setState(6318);
        match(MySQLParser::READ_SYMBOL);
        setState(6319);
        match(MySQLParser::LOCK_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PreloadTailContext ------------------------------------------------------------------

MySQLParser::PreloadTailContext::PreloadTailContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::PreloadTailContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::AdminPartitionContext* MySQLParser::PreloadTailContext::adminPartition() {
  return getRuleContext<MySQLParser::AdminPartitionContext>(0);
}

MySQLParser::CacheKeyListContext* MySQLParser::PreloadTailContext::cacheKeyList() {
  return getRuleContext<MySQLParser::CacheKeyListContext>(0);
}

tree::TerminalNode* MySQLParser::PreloadTailContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PreloadTailContext::LEAVES_SYMBOL() {
  return getToken(MySQLParser::LEAVES_SYMBOL, 0);
}

MySQLParser::PreloadListContext* MySQLParser::PreloadTailContext::preloadList() {
  return getRuleContext<MySQLParser::PreloadListContext>(0);
}


size_t MySQLParser::PreloadTailContext::getRuleIndex() const {
  return MySQLParser::RulePreloadTail;
}

void MySQLParser::PreloadTailContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPreloadTail(this);
}

void MySQLParser::PreloadTailContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPreloadTail(this);
}


std::any MySQLParser::PreloadTailContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPreloadTail(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PreloadTailContext* MySQLParser::preloadTail() {
  PreloadTailContext *_localctx = _tracker.createInstance<PreloadTailContext>(_ctx, getState());
  enterRule(_localctx, 878, MySQLParser::RulePreloadTail);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6332);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 744, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6322);
      tableRef();
      setState(6323);
      adminPartition();
      setState(6325);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::INDEX_SYMBOL

      || _la == MySQLParser::KEY_SYMBOL) {
        setState(6324);
        cacheKeyList();
      }
      setState(6329);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::IGNORE_SYMBOL) {
        setState(6327);
        match(MySQLParser::IGNORE_SYMBOL);
        setState(6328);
        match(MySQLParser::LEAVES_SYMBOL);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6331);
      preloadList();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PreloadListContext ------------------------------------------------------------------

MySQLParser::PreloadListContext::PreloadListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::PreloadKeysContext *> MySQLParser::PreloadListContext::preloadKeys() {
  return getRuleContexts<MySQLParser::PreloadKeysContext>();
}

MySQLParser::PreloadKeysContext* MySQLParser::PreloadListContext::preloadKeys(size_t i) {
  return getRuleContext<MySQLParser::PreloadKeysContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::PreloadListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::PreloadListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::PreloadListContext::getRuleIndex() const {
  return MySQLParser::RulePreloadList;
}

void MySQLParser::PreloadListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPreloadList(this);
}

void MySQLParser::PreloadListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPreloadList(this);
}


std::any MySQLParser::PreloadListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPreloadList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PreloadListContext* MySQLParser::preloadList() {
  PreloadListContext *_localctx = _tracker.createInstance<PreloadListContext>(_ctx, getState());
  enterRule(_localctx, 880, MySQLParser::RulePreloadList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6334);
    preloadKeys();
    setState(6339);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6335);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6336);
      preloadKeys();
      setState(6341);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PreloadKeysContext ------------------------------------------------------------------

MySQLParser::PreloadKeysContext::PreloadKeysContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::PreloadKeysContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::CacheKeyListContext* MySQLParser::PreloadKeysContext::cacheKeyList() {
  return getRuleContext<MySQLParser::CacheKeyListContext>(0);
}

tree::TerminalNode* MySQLParser::PreloadKeysContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PreloadKeysContext::LEAVES_SYMBOL() {
  return getToken(MySQLParser::LEAVES_SYMBOL, 0);
}


size_t MySQLParser::PreloadKeysContext::getRuleIndex() const {
  return MySQLParser::RulePreloadKeys;
}

void MySQLParser::PreloadKeysContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPreloadKeys(this);
}

void MySQLParser::PreloadKeysContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPreloadKeys(this);
}


std::any MySQLParser::PreloadKeysContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPreloadKeys(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PreloadKeysContext* MySQLParser::preloadKeys() {
  PreloadKeysContext *_localctx = _tracker.createInstance<PreloadKeysContext>(_ctx, getState());
  enterRule(_localctx, 882, MySQLParser::RulePreloadKeys);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6342);
    tableRef();
    setState(6344);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::INDEX_SYMBOL

    || _la == MySQLParser::KEY_SYMBOL) {
      setState(6343);
      cacheKeyList();
    }
    setState(6348);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::IGNORE_SYMBOL) {
      setState(6346);
      match(MySQLParser::IGNORE_SYMBOL);
      setState(6347);
      match(MySQLParser::LEAVES_SYMBOL);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AdminPartitionContext ------------------------------------------------------------------

MySQLParser::AdminPartitionContext::AdminPartitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AdminPartitionContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AdminPartitionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::AllOrPartitionNameListContext* MySQLParser::AdminPartitionContext::allOrPartitionNameList() {
  return getRuleContext<MySQLParser::AllOrPartitionNameListContext>(0);
}

tree::TerminalNode* MySQLParser::AdminPartitionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::AdminPartitionContext::getRuleIndex() const {
  return MySQLParser::RuleAdminPartition;
}

void MySQLParser::AdminPartitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAdminPartition(this);
}

void MySQLParser::AdminPartitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAdminPartition(this);
}


std::any MySQLParser::AdminPartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAdminPartition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AdminPartitionContext* MySQLParser::adminPartition() {
  AdminPartitionContext *_localctx = _tracker.createInstance<AdminPartitionContext>(_ctx, getState());
  enterRule(_localctx, 884, MySQLParser::RuleAdminPartition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6350);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(6351);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6352);
    allOrPartitionNameList();
    setState(6353);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResourceGroupManagementContext ------------------------------------------------------------------

MySQLParser::ResourceGroupManagementContext::ResourceGroupManagementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CreateResourceGroupContext* MySQLParser::ResourceGroupManagementContext::createResourceGroup() {
  return getRuleContext<MySQLParser::CreateResourceGroupContext>(0);
}

MySQLParser::AlterResourceGroupContext* MySQLParser::ResourceGroupManagementContext::alterResourceGroup() {
  return getRuleContext<MySQLParser::AlterResourceGroupContext>(0);
}

MySQLParser::SetResourceGroupContext* MySQLParser::ResourceGroupManagementContext::setResourceGroup() {
  return getRuleContext<MySQLParser::SetResourceGroupContext>(0);
}

MySQLParser::DropResourceGroupContext* MySQLParser::ResourceGroupManagementContext::dropResourceGroup() {
  return getRuleContext<MySQLParser::DropResourceGroupContext>(0);
}


size_t MySQLParser::ResourceGroupManagementContext::getRuleIndex() const {
  return MySQLParser::RuleResourceGroupManagement;
}

void MySQLParser::ResourceGroupManagementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResourceGroupManagement(this);
}

void MySQLParser::ResourceGroupManagementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResourceGroupManagement(this);
}


std::any MySQLParser::ResourceGroupManagementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResourceGroupManagement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResourceGroupManagementContext* MySQLParser::resourceGroupManagement() {
  ResourceGroupManagementContext *_localctx = _tracker.createInstance<ResourceGroupManagementContext>(_ctx, getState());
  enterRule(_localctx, 886, MySQLParser::RuleResourceGroupManagement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6359);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CREATE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6355);
        createResourceGroup();
        break;
      }

      case MySQLParser::ALTER_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6356);
        alterResourceGroup();
        break;
      }

      case MySQLParser::SET_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(6357);
        setResourceGroup();
        break;
      }

      case MySQLParser::DROP_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(6358);
        dropResourceGroup();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateResourceGroupContext ------------------------------------------------------------------

MySQLParser::CreateResourceGroupContext::CreateResourceGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CreateResourceGroupContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateResourceGroupContext::RESOURCE_SYMBOL() {
  return getToken(MySQLParser::RESOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateResourceGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CreateResourceGroupContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CreateResourceGroupContext::TYPE_SYMBOL() {
  return getToken(MySQLParser::TYPE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateResourceGroupContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateResourceGroupContext::SYSTEM_SYMBOL() {
  return getToken(MySQLParser::SYSTEM_SYMBOL, 0);
}

MySQLParser::EqualContext* MySQLParser::CreateResourceGroupContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::ResourceGroupVcpuListContext* MySQLParser::CreateResourceGroupContext::resourceGroupVcpuList() {
  return getRuleContext<MySQLParser::ResourceGroupVcpuListContext>(0);
}

MySQLParser::ResourceGroupPriorityContext* MySQLParser::CreateResourceGroupContext::resourceGroupPriority() {
  return getRuleContext<MySQLParser::ResourceGroupPriorityContext>(0);
}

MySQLParser::ResourceGroupEnableDisableContext* MySQLParser::CreateResourceGroupContext::resourceGroupEnableDisable() {
  return getRuleContext<MySQLParser::ResourceGroupEnableDisableContext>(0);
}


size_t MySQLParser::CreateResourceGroupContext::getRuleIndex() const {
  return MySQLParser::RuleCreateResourceGroup;
}

void MySQLParser::CreateResourceGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateResourceGroup(this);
}

void MySQLParser::CreateResourceGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateResourceGroup(this);
}


std::any MySQLParser::CreateResourceGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateResourceGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateResourceGroupContext* MySQLParser::createResourceGroup() {
  CreateResourceGroupContext *_localctx = _tracker.createInstance<CreateResourceGroupContext>(_ctx, getState());
  enterRule(_localctx, 888, MySQLParser::RuleCreateResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6361);
    match(MySQLParser::CREATE_SYMBOL);
    setState(6362);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(6363);
    match(MySQLParser::GROUP_SYMBOL);
    setState(6364);
    identifier();
    setState(6365);
    match(MySQLParser::TYPE_SYMBOL);
    setState(6367);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::EQUAL_OPERATOR

    || _la == MySQLParser::ASSIGN_OPERATOR) {
      setState(6366);
      equal();
    }
    setState(6369);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::USER_SYMBOL || _la == MySQLParser::SYSTEM_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(6371);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::VCPU_SYMBOL) {
      setState(6370);
      resourceGroupVcpuList();
    }
    setState(6374);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::THREAD_PRIORITY_SYMBOL) {
      setState(6373);
      resourceGroupPriority();
    }
    setState(6377);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DISABLE_SYMBOL

    || _la == MySQLParser::ENABLE_SYMBOL) {
      setState(6376);
      resourceGroupEnableDisable();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResourceGroupVcpuListContext ------------------------------------------------------------------

MySQLParser::ResourceGroupVcpuListContext::ResourceGroupVcpuListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ResourceGroupVcpuListContext::VCPU_SYMBOL() {
  return getToken(MySQLParser::VCPU_SYMBOL, 0);
}

std::vector<MySQLParser::VcpuNumOrRangeContext *> MySQLParser::ResourceGroupVcpuListContext::vcpuNumOrRange() {
  return getRuleContexts<MySQLParser::VcpuNumOrRangeContext>();
}

MySQLParser::VcpuNumOrRangeContext* MySQLParser::ResourceGroupVcpuListContext::vcpuNumOrRange(size_t i) {
  return getRuleContext<MySQLParser::VcpuNumOrRangeContext>(i);
}

MySQLParser::EqualContext* MySQLParser::ResourceGroupVcpuListContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::ResourceGroupVcpuListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ResourceGroupVcpuListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ResourceGroupVcpuListContext::getRuleIndex() const {
  return MySQLParser::RuleResourceGroupVcpuList;
}

void MySQLParser::ResourceGroupVcpuListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResourceGroupVcpuList(this);
}

void MySQLParser::ResourceGroupVcpuListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResourceGroupVcpuList(this);
}


std::any MySQLParser::ResourceGroupVcpuListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResourceGroupVcpuList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResourceGroupVcpuListContext* MySQLParser::resourceGroupVcpuList() {
  ResourceGroupVcpuListContext *_localctx = _tracker.createInstance<ResourceGroupVcpuListContext>(_ctx, getState());
  enterRule(_localctx, 890, MySQLParser::RuleResourceGroupVcpuList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6379);
    match(MySQLParser::VCPU_SYMBOL);
    setState(6381);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::EQUAL_OPERATOR

    || _la == MySQLParser::ASSIGN_OPERATOR) {
      setState(6380);
      equal();
    }
    setState(6383);
    vcpuNumOrRange();
    setState(6390);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::INT_NUMBER

    || _la == MySQLParser::COMMA_SYMBOL) {
      setState(6385);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6384);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(6387);
      vcpuNumOrRange();
      setState(6392);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VcpuNumOrRangeContext ------------------------------------------------------------------

MySQLParser::VcpuNumOrRangeContext::VcpuNumOrRangeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::VcpuNumOrRangeContext::INT_NUMBER() {
  return getTokens(MySQLParser::INT_NUMBER);
}

tree::TerminalNode* MySQLParser::VcpuNumOrRangeContext::INT_NUMBER(size_t i) {
  return getToken(MySQLParser::INT_NUMBER, i);
}

tree::TerminalNode* MySQLParser::VcpuNumOrRangeContext::MINUS_OPERATOR() {
  return getToken(MySQLParser::MINUS_OPERATOR, 0);
}


size_t MySQLParser::VcpuNumOrRangeContext::getRuleIndex() const {
  return MySQLParser::RuleVcpuNumOrRange;
}

void MySQLParser::VcpuNumOrRangeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterVcpuNumOrRange(this);
}

void MySQLParser::VcpuNumOrRangeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitVcpuNumOrRange(this);
}


std::any MySQLParser::VcpuNumOrRangeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitVcpuNumOrRange(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::VcpuNumOrRangeContext* MySQLParser::vcpuNumOrRange() {
  VcpuNumOrRangeContext *_localctx = _tracker.createInstance<VcpuNumOrRangeContext>(_ctx, getState());
  enterRule(_localctx, 892, MySQLParser::RuleVcpuNumOrRange);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6393);
    match(MySQLParser::INT_NUMBER);
    setState(6396);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::MINUS_OPERATOR) {
      setState(6394);
      match(MySQLParser::MINUS_OPERATOR);
      setState(6395);
      match(MySQLParser::INT_NUMBER);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResourceGroupPriorityContext ------------------------------------------------------------------

MySQLParser::ResourceGroupPriorityContext::ResourceGroupPriorityContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ResourceGroupPriorityContext::THREAD_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::THREAD_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ResourceGroupPriorityContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

MySQLParser::EqualContext* MySQLParser::ResourceGroupPriorityContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}


size_t MySQLParser::ResourceGroupPriorityContext::getRuleIndex() const {
  return MySQLParser::RuleResourceGroupPriority;
}

void MySQLParser::ResourceGroupPriorityContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResourceGroupPriority(this);
}

void MySQLParser::ResourceGroupPriorityContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResourceGroupPriority(this);
}


std::any MySQLParser::ResourceGroupPriorityContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResourceGroupPriority(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResourceGroupPriorityContext* MySQLParser::resourceGroupPriority() {
  ResourceGroupPriorityContext *_localctx = _tracker.createInstance<ResourceGroupPriorityContext>(_ctx, getState());
  enterRule(_localctx, 894, MySQLParser::RuleResourceGroupPriority);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6398);
    match(MySQLParser::THREAD_PRIORITY_SYMBOL);
    setState(6400);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::EQUAL_OPERATOR

    || _la == MySQLParser::ASSIGN_OPERATOR) {
      setState(6399);
      equal();
    }
    setState(6402);
    match(MySQLParser::INT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResourceGroupEnableDisableContext ------------------------------------------------------------------

MySQLParser::ResourceGroupEnableDisableContext::ResourceGroupEnableDisableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ResourceGroupEnableDisableContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ResourceGroupEnableDisableContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}


size_t MySQLParser::ResourceGroupEnableDisableContext::getRuleIndex() const {
  return MySQLParser::RuleResourceGroupEnableDisable;
}

void MySQLParser::ResourceGroupEnableDisableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResourceGroupEnableDisable(this);
}

void MySQLParser::ResourceGroupEnableDisableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResourceGroupEnableDisable(this);
}


std::any MySQLParser::ResourceGroupEnableDisableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResourceGroupEnableDisable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResourceGroupEnableDisableContext* MySQLParser::resourceGroupEnableDisable() {
  ResourceGroupEnableDisableContext *_localctx = _tracker.createInstance<ResourceGroupEnableDisableContext>(_ctx, getState());
  enterRule(_localctx, 896, MySQLParser::RuleResourceGroupEnableDisable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6404);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DISABLE_SYMBOL

    || _la == MySQLParser::ENABLE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AlterResourceGroupContext ------------------------------------------------------------------

MySQLParser::AlterResourceGroupContext::AlterResourceGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AlterResourceGroupContext::ALTER_SYMBOL() {
  return getToken(MySQLParser::ALTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterResourceGroupContext::RESOURCE_SYMBOL() {
  return getToken(MySQLParser::RESOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterResourceGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::ResourceGroupRefContext* MySQLParser::AlterResourceGroupContext::resourceGroupRef() {
  return getRuleContext<MySQLParser::ResourceGroupRefContext>(0);
}

MySQLParser::ResourceGroupVcpuListContext* MySQLParser::AlterResourceGroupContext::resourceGroupVcpuList() {
  return getRuleContext<MySQLParser::ResourceGroupVcpuListContext>(0);
}

MySQLParser::ResourceGroupPriorityContext* MySQLParser::AlterResourceGroupContext::resourceGroupPriority() {
  return getRuleContext<MySQLParser::ResourceGroupPriorityContext>(0);
}

MySQLParser::ResourceGroupEnableDisableContext* MySQLParser::AlterResourceGroupContext::resourceGroupEnableDisable() {
  return getRuleContext<MySQLParser::ResourceGroupEnableDisableContext>(0);
}

tree::TerminalNode* MySQLParser::AlterResourceGroupContext::FORCE_SYMBOL() {
  return getToken(MySQLParser::FORCE_SYMBOL, 0);
}


size_t MySQLParser::AlterResourceGroupContext::getRuleIndex() const {
  return MySQLParser::RuleAlterResourceGroup;
}

void MySQLParser::AlterResourceGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterResourceGroup(this);
}

void MySQLParser::AlterResourceGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterResourceGroup(this);
}


std::any MySQLParser::AlterResourceGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterResourceGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterResourceGroupContext* MySQLParser::alterResourceGroup() {
  AlterResourceGroupContext *_localctx = _tracker.createInstance<AlterResourceGroupContext>(_ctx, getState());
  enterRule(_localctx, 898, MySQLParser::RuleAlterResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6406);
    match(MySQLParser::ALTER_SYMBOL);
    setState(6407);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(6408);
    match(MySQLParser::GROUP_SYMBOL);
    setState(6409);
    resourceGroupRef();
    setState(6411);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::VCPU_SYMBOL) {
      setState(6410);
      resourceGroupVcpuList();
    }
    setState(6414);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::THREAD_PRIORITY_SYMBOL) {
      setState(6413);
      resourceGroupPriority();
    }
    setState(6417);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DISABLE_SYMBOL

    || _la == MySQLParser::ENABLE_SYMBOL) {
      setState(6416);
      resourceGroupEnableDisable();
    }
    setState(6420);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FORCE_SYMBOL) {
      setState(6419);
      match(MySQLParser::FORCE_SYMBOL);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetResourceGroupContext ------------------------------------------------------------------

MySQLParser::SetResourceGroupContext::SetResourceGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SetResourceGroupContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetResourceGroupContext::RESOURCE_SYMBOL() {
  return getToken(MySQLParser::RESOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetResourceGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::SetResourceGroupContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::SetResourceGroupContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::ThreadIdListContext* MySQLParser::SetResourceGroupContext::threadIdList() {
  return getRuleContext<MySQLParser::ThreadIdListContext>(0);
}


size_t MySQLParser::SetResourceGroupContext::getRuleIndex() const {
  return MySQLParser::RuleSetResourceGroup;
}

void MySQLParser::SetResourceGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSetResourceGroup(this);
}

void MySQLParser::SetResourceGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSetResourceGroup(this);
}


std::any MySQLParser::SetResourceGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSetResourceGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SetResourceGroupContext* MySQLParser::setResourceGroup() {
  SetResourceGroupContext *_localctx = _tracker.createInstance<SetResourceGroupContext>(_ctx, getState());
  enterRule(_localctx, 900, MySQLParser::RuleSetResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6422);
    match(MySQLParser::SET_SYMBOL);
    setState(6423);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(6424);
    match(MySQLParser::GROUP_SYMBOL);
    setState(6425);
    identifier();
    setState(6428);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FOR_SYMBOL) {
      setState(6426);
      match(MySQLParser::FOR_SYMBOL);
      setState(6427);
      threadIdList();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ThreadIdListContext ------------------------------------------------------------------

MySQLParser::ThreadIdListContext::ThreadIdListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::Real_ulong_numberContext *> MySQLParser::ThreadIdListContext::real_ulong_number() {
  return getRuleContexts<MySQLParser::Real_ulong_numberContext>();
}

MySQLParser::Real_ulong_numberContext* MySQLParser::ThreadIdListContext::real_ulong_number(size_t i) {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ThreadIdListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ThreadIdListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ThreadIdListContext::getRuleIndex() const {
  return MySQLParser::RuleThreadIdList;
}

void MySQLParser::ThreadIdListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterThreadIdList(this);
}

void MySQLParser::ThreadIdListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitThreadIdList(this);
}


std::any MySQLParser::ThreadIdListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitThreadIdList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ThreadIdListContext* MySQLParser::threadIdList() {
  ThreadIdListContext *_localctx = _tracker.createInstance<ThreadIdListContext>(_ctx, getState());
  enterRule(_localctx, 902, MySQLParser::RuleThreadIdList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6430);
    real_ulong_number();
    setState(6437);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
      | (1ULL << MySQLParser::LONG_NUMBER)
      | (1ULL << MySQLParser::ULONGLONG_NUMBER)
      | (1ULL << MySQLParser::COMMA_SYMBOL)
      | (1ULL << MySQLParser::HEX_NUMBER))) != 0)) {
      setState(6432);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6431);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(6434);
      real_ulong_number();
      setState(6439);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropResourceGroupContext ------------------------------------------------------------------

MySQLParser::DropResourceGroupContext::DropResourceGroupContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DropResourceGroupContext::DROP_SYMBOL() {
  return getToken(MySQLParser::DROP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropResourceGroupContext::RESOURCE_SYMBOL() {
  return getToken(MySQLParser::RESOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DropResourceGroupContext::GROUP_SYMBOL() {
  return getToken(MySQLParser::GROUP_SYMBOL, 0);
}

MySQLParser::ResourceGroupRefContext* MySQLParser::DropResourceGroupContext::resourceGroupRef() {
  return getRuleContext<MySQLParser::ResourceGroupRefContext>(0);
}

tree::TerminalNode* MySQLParser::DropResourceGroupContext::FORCE_SYMBOL() {
  return getToken(MySQLParser::FORCE_SYMBOL, 0);
}


size_t MySQLParser::DropResourceGroupContext::getRuleIndex() const {
  return MySQLParser::RuleDropResourceGroup;
}

void MySQLParser::DropResourceGroupContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDropResourceGroup(this);
}

void MySQLParser::DropResourceGroupContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDropResourceGroup(this);
}


std::any MySQLParser::DropResourceGroupContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDropResourceGroup(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DropResourceGroupContext* MySQLParser::dropResourceGroup() {
  DropResourceGroupContext *_localctx = _tracker.createInstance<DropResourceGroupContext>(_ctx, getState());
  enterRule(_localctx, 904, MySQLParser::RuleDropResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6440);
    match(MySQLParser::DROP_SYMBOL);
    setState(6441);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(6442);
    match(MySQLParser::GROUP_SYMBOL);
    setState(6443);
    resourceGroupRef();
    setState(6445);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FORCE_SYMBOL) {
      setState(6444);
      match(MySQLParser::FORCE_SYMBOL);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UtilityStatementContext ------------------------------------------------------------------

MySQLParser::UtilityStatementContext::UtilityStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::DescribeStatementContext* MySQLParser::UtilityStatementContext::describeStatement() {
  return getRuleContext<MySQLParser::DescribeStatementContext>(0);
}

MySQLParser::ExplainStatementContext* MySQLParser::UtilityStatementContext::explainStatement() {
  return getRuleContext<MySQLParser::ExplainStatementContext>(0);
}

MySQLParser::HelpCommandContext* MySQLParser::UtilityStatementContext::helpCommand() {
  return getRuleContext<MySQLParser::HelpCommandContext>(0);
}

MySQLParser::UseCommandContext* MySQLParser::UtilityStatementContext::useCommand() {
  return getRuleContext<MySQLParser::UseCommandContext>(0);
}

MySQLParser::RestartServerContext* MySQLParser::UtilityStatementContext::restartServer() {
  return getRuleContext<MySQLParser::RestartServerContext>(0);
}


size_t MySQLParser::UtilityStatementContext::getRuleIndex() const {
  return MySQLParser::RuleUtilityStatement;
}

void MySQLParser::UtilityStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUtilityStatement(this);
}

void MySQLParser::UtilityStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUtilityStatement(this);
}


std::any MySQLParser::UtilityStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUtilityStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UtilityStatementContext* MySQLParser::utilityStatement() {
  UtilityStatementContext *_localctx = _tracker.createInstance<UtilityStatementContext>(_ctx, getState());
  enterRule(_localctx, 906, MySQLParser::RuleUtilityStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6453);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 766, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6447);
      describeStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6448);
      explainStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6449);
      helpCommand();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6450);
      useCommand();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6451);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(6452);
      restartServer();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DescribeStatementContext ------------------------------------------------------------------

MySQLParser::DescribeStatementContext::DescribeStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TableRefContext* MySQLParser::DescribeStatementContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

tree::TerminalNode* MySQLParser::DescribeStatementContext::EXPLAIN_SYMBOL() {
  return getToken(MySQLParser::EXPLAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DescribeStatementContext::DESCRIBE_SYMBOL() {
  return getToken(MySQLParser::DESCRIBE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DescribeStatementContext::DESC_SYMBOL() {
  return getToken(MySQLParser::DESC_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::DescribeStatementContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

MySQLParser::ColumnRefContext* MySQLParser::DescribeStatementContext::columnRef() {
  return getRuleContext<MySQLParser::ColumnRefContext>(0);
}


size_t MySQLParser::DescribeStatementContext::getRuleIndex() const {
  return MySQLParser::RuleDescribeStatement;
}

void MySQLParser::DescribeStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDescribeStatement(this);
}

void MySQLParser::DescribeStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDescribeStatement(this);
}


std::any MySQLParser::DescribeStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDescribeStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DescribeStatementContext* MySQLParser::describeStatement() {
  DescribeStatementContext *_localctx = _tracker.createInstance<DescribeStatementContext>(_ctx, getState());
  enterRule(_localctx, 908, MySQLParser::RuleDescribeStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6455);
    _la = _input->LA(1);
    if (!(((((_la - 174) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 174)) & ((1ULL << (MySQLParser::DESC_SYMBOL - 174))
      | (1ULL << (MySQLParser::DESCRIBE_SYMBOL - 174))
      | (1ULL << (MySQLParser::EXPLAIN_SYMBOL - 174)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(6456);
    tableRef();
    setState(6459);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 767, _ctx)) {
    case 1: {
      setState(6457);
      textString();
      break;
    }

    case 2: {
      setState(6458);
      columnRef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplainStatementContext ------------------------------------------------------------------

MySQLParser::ExplainStatementContext::ExplainStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExplainableStatementContext* MySQLParser::ExplainStatementContext::explainableStatement() {
  return getRuleContext<MySQLParser::ExplainableStatementContext>(0);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::EXPLAIN_SYMBOL() {
  return getToken(MySQLParser::EXPLAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::DESCRIBE_SYMBOL() {
  return getToken(MySQLParser::DESCRIBE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::DESC_SYMBOL() {
  return getToken(MySQLParser::DESC_SYMBOL, 0);
}

MySQLParser::ExplainOptionsContext* MySQLParser::ExplainStatementContext::explainOptions() {
  return getRuleContext<MySQLParser::ExplainOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::ExplainStatementContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::ExplainStatementContext::getRuleIndex() const {
  return MySQLParser::RuleExplainStatement;
}

void MySQLParser::ExplainStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExplainStatement(this);
}

void MySQLParser::ExplainStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExplainStatement(this);
}


std::any MySQLParser::ExplainStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExplainStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExplainStatementContext* MySQLParser::explainStatement() {
  ExplainStatementContext *_localctx = _tracker.createInstance<ExplainStatementContext>(_ctx, getState());
  enterRule(_localctx, 910, MySQLParser::RuleExplainStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6461);
    _la = _input->LA(1);
    if (!(((((_la - 174) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 174)) & ((1ULL << (MySQLParser::DESC_SYMBOL - 174))
      | (1ULL << (MySQLParser::DESCRIBE_SYMBOL - 174))
      | (1ULL << (MySQLParser::EXPLAIN_SYMBOL - 174)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(6463);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 768, _ctx)) {
    case 1: {
      setState(6462);
      explainOptions();
      break;
    }

    default:
      break;
    }
    setState(6469);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 769, _ctx)) {
    case 1: {
      setState(6465);

      if (!(serverVersion >= 80032)) throw FailedPredicateException(this, "serverVersion >= 80032");
      setState(6466);
      match(MySQLParser::FOR_SYMBOL);
      setState(6467);
      match(MySQLParser::DATABASE_SYMBOL);
      setState(6468);
      textOrIdentifier();
      break;
    }

    default:
      break;
    }
    setState(6471);
    explainableStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplainOptionsContext ------------------------------------------------------------------

MySQLParser::ExplainOptionsContext::ExplainOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExplainOptionsContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainOptionsContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::ExplainOptionsContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::ExplainIntoContext* MySQLParser::ExplainOptionsContext::explainInto() {
  return getRuleContext<MySQLParser::ExplainIntoContext>(0);
}

tree::TerminalNode* MySQLParser::ExplainOptionsContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainOptionsContext::PARTITIONS_SYMBOL() {
  return getToken(MySQLParser::PARTITIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainOptionsContext::ANALYZE_SYMBOL() {
  return getToken(MySQLParser::ANALYZE_SYMBOL, 0);
}


size_t MySQLParser::ExplainOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleExplainOptions;
}

void MySQLParser::ExplainOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExplainOptions(this);
}

void MySQLParser::ExplainOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExplainOptions(this);
}


std::any MySQLParser::ExplainOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExplainOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExplainOptionsContext* MySQLParser::explainOptions() {
  ExplainOptionsContext *_localctx = _tracker.createInstance<ExplainOptionsContext>(_ctx, getState());
  enterRule(_localctx, 912, MySQLParser::RuleExplainOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6491);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 771, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6473);
      match(MySQLParser::FORMAT_SYMBOL);
      setState(6474);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(6475);
      textOrIdentifier();
      setState(6478);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 770, _ctx)) {
      case 1: {
        setState(6476);

        if (!(serverVersion >= 80100)) throw FailedPredicateException(this, "serverVersion >= 80100");
        setState(6477);
        explainInto();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6480);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(6481);
      match(MySQLParser::EXTENDED_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6482);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(6483);
      match(MySQLParser::PARTITIONS_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6484);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(6485);
      match(MySQLParser::ANALYZE_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6486);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(6487);
      match(MySQLParser::ANALYZE_SYMBOL);
      setState(6488);
      match(MySQLParser::FORMAT_SYMBOL);
      setState(6489);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(6490);
      textOrIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplainableStatementContext ------------------------------------------------------------------

MySQLParser::ExplainableStatementContext::ExplainableStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SelectStatementContext* MySQLParser::ExplainableStatementContext::selectStatement() {
  return getRuleContext<MySQLParser::SelectStatementContext>(0);
}

MySQLParser::DeleteStatementContext* MySQLParser::ExplainableStatementContext::deleteStatement() {
  return getRuleContext<MySQLParser::DeleteStatementContext>(0);
}

MySQLParser::InsertStatementContext* MySQLParser::ExplainableStatementContext::insertStatement() {
  return getRuleContext<MySQLParser::InsertStatementContext>(0);
}

MySQLParser::ReplaceStatementContext* MySQLParser::ExplainableStatementContext::replaceStatement() {
  return getRuleContext<MySQLParser::ReplaceStatementContext>(0);
}

MySQLParser::UpdateStatementContext* MySQLParser::ExplainableStatementContext::updateStatement() {
  return getRuleContext<MySQLParser::UpdateStatementContext>(0);
}

tree::TerminalNode* MySQLParser::ExplainableStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainableStatementContext::CONNECTION_SYMBOL() {
  return getToken(MySQLParser::CONNECTION_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::ExplainableStatementContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}


size_t MySQLParser::ExplainableStatementContext::getRuleIndex() const {
  return MySQLParser::RuleExplainableStatement;
}

void MySQLParser::ExplainableStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExplainableStatement(this);
}

void MySQLParser::ExplainableStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExplainableStatement(this);
}


std::any MySQLParser::ExplainableStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExplainableStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExplainableStatementContext* MySQLParser::explainableStatement() {
  ExplainableStatementContext *_localctx = _tracker.createInstance<ExplainableStatementContext>(_ctx, getState());
  enterRule(_localctx, 914, MySQLParser::RuleExplainableStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6501);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 772, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6493);
      selectStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6494);
      deleteStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6495);
      insertStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6496);
      replaceStatement();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6497);
      updateStatement();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6498);
      match(MySQLParser::FOR_SYMBOL);
      setState(6499);
      match(MySQLParser::CONNECTION_SYMBOL);
      setState(6500);
      real_ulong_number();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExplainIntoContext ------------------------------------------------------------------

MySQLParser::ExplainIntoContext::ExplainIntoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExplainIntoContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExplainIntoContext::AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::ExplainIntoContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::ExplainIntoContext::getRuleIndex() const {
  return MySQLParser::RuleExplainInto;
}

void MySQLParser::ExplainIntoContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExplainInto(this);
}

void MySQLParser::ExplainIntoContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExplainInto(this);
}


std::any MySQLParser::ExplainIntoContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExplainInto(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExplainIntoContext* MySQLParser::explainInto() {
  ExplainIntoContext *_localctx = _tracker.createInstance<ExplainIntoContext>(_ctx, getState());
  enterRule(_localctx, 916, MySQLParser::RuleExplainInto);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6503);
    match(MySQLParser::INTO_SYMBOL);
    setState(6504);
    match(MySQLParser::AT_SIGN_SYMBOL);
    setState(6505);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HelpCommandContext ------------------------------------------------------------------

MySQLParser::HelpCommandContext::HelpCommandContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HelpCommandContext::HELP_SYMBOL() {
  return getToken(MySQLParser::HELP_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::HelpCommandContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::HelpCommandContext::getRuleIndex() const {
  return MySQLParser::RuleHelpCommand;
}

void MySQLParser::HelpCommandContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHelpCommand(this);
}

void MySQLParser::HelpCommandContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHelpCommand(this);
}


std::any MySQLParser::HelpCommandContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHelpCommand(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HelpCommandContext* MySQLParser::helpCommand() {
  HelpCommandContext *_localctx = _tracker.createInstance<HelpCommandContext>(_ctx, getState());
  enterRule(_localctx, 918, MySQLParser::RuleHelpCommand);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6507);
    match(MySQLParser::HELP_SYMBOL);
    setState(6508);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UseCommandContext ------------------------------------------------------------------

MySQLParser::UseCommandContext::UseCommandContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UseCommandContext::USE_SYMBOL() {
  return getToken(MySQLParser::USE_SYMBOL, 0);
}

MySQLParser::SchemaRefContext* MySQLParser::UseCommandContext::schemaRef() {
  return getRuleContext<MySQLParser::SchemaRefContext>(0);
}


size_t MySQLParser::UseCommandContext::getRuleIndex() const {
  return MySQLParser::RuleUseCommand;
}

void MySQLParser::UseCommandContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUseCommand(this);
}

void MySQLParser::UseCommandContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUseCommand(this);
}


std::any MySQLParser::UseCommandContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUseCommand(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UseCommandContext* MySQLParser::useCommand() {
  UseCommandContext *_localctx = _tracker.createInstance<UseCommandContext>(_ctx, getState());
  enterRule(_localctx, 920, MySQLParser::RuleUseCommand);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6510);
    match(MySQLParser::USE_SYMBOL);
    setState(6511);
    schemaRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RestartServerContext ------------------------------------------------------------------

MySQLParser::RestartServerContext::RestartServerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RestartServerContext::RESTART_SYMBOL() {
  return getToken(MySQLParser::RESTART_SYMBOL, 0);
}


size_t MySQLParser::RestartServerContext::getRuleIndex() const {
  return MySQLParser::RuleRestartServer;
}

void MySQLParser::RestartServerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRestartServer(this);
}

void MySQLParser::RestartServerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRestartServer(this);
}


std::any MySQLParser::RestartServerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRestartServer(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RestartServerContext* MySQLParser::restartServer() {
  RestartServerContext *_localctx = _tracker.createInstance<RestartServerContext>(_ctx, getState());
  enterRule(_localctx, 922, MySQLParser::RuleRestartServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6513);
    match(MySQLParser::RESTART_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExprContext ------------------------------------------------------------------

MySQLParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t MySQLParser::ExprContext::getRuleIndex() const {
  return MySQLParser::RuleExpr;
}

void MySQLParser::ExprContext::copyFrom(ExprContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- ExprOrContext ------------------------------------------------------------------

std::vector<MySQLParser::ExprContext *> MySQLParser::ExprOrContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::ExprOrContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::ExprOrContext::OR_SYMBOL() {
  return getToken(MySQLParser::OR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExprOrContext::LOGICAL_OR_OPERATOR() {
  return getToken(MySQLParser::LOGICAL_OR_OPERATOR, 0);
}

MySQLParser::ExprOrContext::ExprOrContext(ExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::ExprOrContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprOr(this);
}
void MySQLParser::ExprOrContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprOr(this);
}

std::any MySQLParser::ExprOrContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprOr(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExprNotContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::ExprNotContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::ExprNotContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::ExprNotContext::ExprNotContext(ExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::ExprNotContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprNot(this);
}
void MySQLParser::ExprNotContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprNot(this);
}

std::any MySQLParser::ExprNotContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprNot(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExprIsContext ------------------------------------------------------------------

MySQLParser::BoolPriContext* MySQLParser::ExprIsContext::boolPri() {
  return getRuleContext<MySQLParser::BoolPriContext>(0);
}

tree::TerminalNode* MySQLParser::ExprIsContext::IS_SYMBOL() {
  return getToken(MySQLParser::IS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExprIsContext::TRUE_SYMBOL() {
  return getToken(MySQLParser::TRUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExprIsContext::FALSE_SYMBOL() {
  return getToken(MySQLParser::FALSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExprIsContext::UNKNOWN_SYMBOL() {
  return getToken(MySQLParser::UNKNOWN_SYMBOL, 0);
}

MySQLParser::NotRuleContext* MySQLParser::ExprIsContext::notRule() {
  return getRuleContext<MySQLParser::NotRuleContext>(0);
}

MySQLParser::ExprIsContext::ExprIsContext(ExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::ExprIsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprIs(this);
}
void MySQLParser::ExprIsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprIs(this);
}

std::any MySQLParser::ExprIsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprIs(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExprAndContext ------------------------------------------------------------------

std::vector<MySQLParser::ExprContext *> MySQLParser::ExprAndContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::ExprAndContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::ExprAndContext::AND_SYMBOL() {
  return getToken(MySQLParser::AND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ExprAndContext::LOGICAL_AND_OPERATOR() {
  return getToken(MySQLParser::LOGICAL_AND_OPERATOR, 0);
}

MySQLParser::ExprAndContext::ExprAndContext(ExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::ExprAndContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprAnd(this);
}
void MySQLParser::ExprAndContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprAnd(this);
}

std::any MySQLParser::ExprAndContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprAnd(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExprXorContext ------------------------------------------------------------------

std::vector<MySQLParser::ExprContext *> MySQLParser::ExprXorContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::ExprXorContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::ExprXorContext::XOR_SYMBOL() {
  return getToken(MySQLParser::XOR_SYMBOL, 0);
}

MySQLParser::ExprXorContext::ExprXorContext(ExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::ExprXorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprXor(this);
}
void MySQLParser::ExprXorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprXor(this);
}

std::any MySQLParser::ExprXorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprXor(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExprContext* MySQLParser::expr() {
   return expr(0);
}

MySQLParser::ExprContext* MySQLParser::expr(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  MySQLParser::ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, parentState);
  MySQLParser::ExprContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 924;
  enterRecursionRule(_localctx, 924, MySQLParser::RuleExpr, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(6526);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 775, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<ExprIsContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(6516);
      boolPri(0);
      setState(6522);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 774, _ctx)) {
      case 1: {
        setState(6517);
        match(MySQLParser::IS_SYMBOL);
        setState(6519);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NOT2_SYMBOL || _la == MySQLParser::NOT_SYMBOL) {
          setState(6518);
          notRule();
        }
        setState(6521);
        antlrcpp::downCast<ExprIsContext *>(_localctx)->type = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::FALSE_SYMBOL || _la == MySQLParser::TRUE_SYMBOL

        || _la == MySQLParser::UNKNOWN_SYMBOL)) {
          antlrcpp::downCast<ExprIsContext *>(_localctx)->type = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<ExprNotContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6524);
      match(MySQLParser::NOT_SYMBOL);
      setState(6525);
      expr(4);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(6539);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 777, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(6537);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 776, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<ExprAndContext>(_tracker.createInstance<ExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleExpr);
          setState(6528);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(6529);
          antlrcpp::downCast<ExprAndContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::LOGICAL_AND_OPERATOR

          || _la == MySQLParser::AND_SYMBOL)) {
            antlrcpp::downCast<ExprAndContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6530);
          expr(4);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<ExprXorContext>(_tracker.createInstance<ExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleExpr);
          setState(6531);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(6532);
          match(MySQLParser::XOR_SYMBOL);
          setState(6533);
          expr(3);
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<ExprOrContext>(_tracker.createInstance<ExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleExpr);
          setState(6534);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(6535);
          antlrcpp::downCast<ExprOrContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::LOGICAL_OR_OPERATOR || _la == MySQLParser::OR_SYMBOL)) {
            antlrcpp::downCast<ExprOrContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6536);
          expr(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(6541);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 777, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- BoolPriContext ------------------------------------------------------------------

MySQLParser::BoolPriContext::BoolPriContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t MySQLParser::BoolPriContext::getRuleIndex() const {
  return MySQLParser::RuleBoolPri;
}

void MySQLParser::BoolPriContext::copyFrom(BoolPriContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- PrimaryExprPredicateContext ------------------------------------------------------------------

MySQLParser::PredicateContext* MySQLParser::PrimaryExprPredicateContext::predicate() {
  return getRuleContext<MySQLParser::PredicateContext>(0);
}

MySQLParser::PrimaryExprPredicateContext::PrimaryExprPredicateContext(BoolPriContext *ctx) { copyFrom(ctx); }

void MySQLParser::PrimaryExprPredicateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrimaryExprPredicate(this);
}
void MySQLParser::PrimaryExprPredicateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrimaryExprPredicate(this);
}

std::any MySQLParser::PrimaryExprPredicateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPrimaryExprPredicate(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PrimaryExprCompareContext ------------------------------------------------------------------

MySQLParser::BoolPriContext* MySQLParser::PrimaryExprCompareContext::boolPri() {
  return getRuleContext<MySQLParser::BoolPriContext>(0);
}

MySQLParser::CompOpContext* MySQLParser::PrimaryExprCompareContext::compOp() {
  return getRuleContext<MySQLParser::CompOpContext>(0);
}

MySQLParser::PredicateContext* MySQLParser::PrimaryExprCompareContext::predicate() {
  return getRuleContext<MySQLParser::PredicateContext>(0);
}

MySQLParser::PrimaryExprCompareContext::PrimaryExprCompareContext(BoolPriContext *ctx) { copyFrom(ctx); }

void MySQLParser::PrimaryExprCompareContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrimaryExprCompare(this);
}
void MySQLParser::PrimaryExprCompareContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrimaryExprCompare(this);
}

std::any MySQLParser::PrimaryExprCompareContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPrimaryExprCompare(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PrimaryExprAllAnyContext ------------------------------------------------------------------

MySQLParser::BoolPriContext* MySQLParser::PrimaryExprAllAnyContext::boolPri() {
  return getRuleContext<MySQLParser::BoolPriContext>(0);
}

MySQLParser::CompOpContext* MySQLParser::PrimaryExprAllAnyContext::compOp() {
  return getRuleContext<MySQLParser::CompOpContext>(0);
}

MySQLParser::SubqueryContext* MySQLParser::PrimaryExprAllAnyContext::subquery() {
  return getRuleContext<MySQLParser::SubqueryContext>(0);
}

tree::TerminalNode* MySQLParser::PrimaryExprAllAnyContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PrimaryExprAllAnyContext::ANY_SYMBOL() {
  return getToken(MySQLParser::ANY_SYMBOL, 0);
}

MySQLParser::PrimaryExprAllAnyContext::PrimaryExprAllAnyContext(BoolPriContext *ctx) { copyFrom(ctx); }

void MySQLParser::PrimaryExprAllAnyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrimaryExprAllAny(this);
}
void MySQLParser::PrimaryExprAllAnyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrimaryExprAllAny(this);
}

std::any MySQLParser::PrimaryExprAllAnyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPrimaryExprAllAny(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PrimaryExprIsNullContext ------------------------------------------------------------------

MySQLParser::BoolPriContext* MySQLParser::PrimaryExprIsNullContext::boolPri() {
  return getRuleContext<MySQLParser::BoolPriContext>(0);
}

tree::TerminalNode* MySQLParser::PrimaryExprIsNullContext::IS_SYMBOL() {
  return getToken(MySQLParser::IS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PrimaryExprIsNullContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

MySQLParser::NotRuleContext* MySQLParser::PrimaryExprIsNullContext::notRule() {
  return getRuleContext<MySQLParser::NotRuleContext>(0);
}

MySQLParser::PrimaryExprIsNullContext::PrimaryExprIsNullContext(BoolPriContext *ctx) { copyFrom(ctx); }

void MySQLParser::PrimaryExprIsNullContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrimaryExprIsNull(this);
}
void MySQLParser::PrimaryExprIsNullContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrimaryExprIsNull(this);
}

std::any MySQLParser::PrimaryExprIsNullContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPrimaryExprIsNull(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::BoolPriContext* MySQLParser::boolPri() {
   return boolPri(0);
}

MySQLParser::BoolPriContext* MySQLParser::boolPri(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  MySQLParser::BoolPriContext *_localctx = _tracker.createInstance<BoolPriContext>(_ctx, parentState);
  MySQLParser::BoolPriContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 926;
  enterRecursionRule(_localctx, 926, MySQLParser::RuleBoolPri, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    _localctx = _tracker.createInstance<PrimaryExprPredicateContext>(_localctx);
    _ctx = _localctx;
    previousContext = _localctx;

    setState(6543);
    predicate();
    _ctx->stop = _input->LT(-1);
    setState(6562);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 780, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(6560);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 779, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<PrimaryExprIsNullContext>(_tracker.createInstance<BoolPriContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleBoolPri);
          setState(6545);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(6546);
          match(MySQLParser::IS_SYMBOL);
          setState(6548);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::NOT2_SYMBOL || _la == MySQLParser::NOT_SYMBOL) {
            setState(6547);
            notRule();
          }
          setState(6550);
          match(MySQLParser::NULL_SYMBOL);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<PrimaryExprCompareContext>(_tracker.createInstance<BoolPriContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleBoolPri);
          setState(6551);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(6552);
          compOp();
          setState(6553);
          predicate();
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<PrimaryExprAllAnyContext>(_tracker.createInstance<BoolPriContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleBoolPri);
          setState(6555);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(6556);
          compOp();
          setState(6557);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::ALL_SYMBOL

          || _la == MySQLParser::ANY_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6558);
          subquery();
          break;
        }

        default:
          break;
        } 
      }
      setState(6564);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 780, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- CompOpContext ------------------------------------------------------------------

MySQLParser::CompOpContext::CompOpContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CompOpContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CompOpContext::NULL_SAFE_EQUAL_OPERATOR() {
  return getToken(MySQLParser::NULL_SAFE_EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CompOpContext::GREATER_OR_EQUAL_OPERATOR() {
  return getToken(MySQLParser::GREATER_OR_EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CompOpContext::GREATER_THAN_OPERATOR() {
  return getToken(MySQLParser::GREATER_THAN_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CompOpContext::LESS_OR_EQUAL_OPERATOR() {
  return getToken(MySQLParser::LESS_OR_EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CompOpContext::LESS_THAN_OPERATOR() {
  return getToken(MySQLParser::LESS_THAN_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CompOpContext::NOT_EQUAL_OPERATOR() {
  return getToken(MySQLParser::NOT_EQUAL_OPERATOR, 0);
}


size_t MySQLParser::CompOpContext::getRuleIndex() const {
  return MySQLParser::RuleCompOp;
}

void MySQLParser::CompOpContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCompOp(this);
}

void MySQLParser::CompOpContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCompOp(this);
}


std::any MySQLParser::CompOpContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCompOp(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CompOpContext* MySQLParser::compOp() {
  CompOpContext *_localctx = _tracker.createInstance<CompOpContext>(_ctx, getState());
  enterRule(_localctx, 928, MySQLParser::RuleCompOp);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6565);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::EQUAL_OPERATOR)
      | (1ULL << MySQLParser::NULL_SAFE_EQUAL_OPERATOR)
      | (1ULL << MySQLParser::GREATER_OR_EQUAL_OPERATOR)
      | (1ULL << MySQLParser::GREATER_THAN_OPERATOR)
      | (1ULL << MySQLParser::LESS_OR_EQUAL_OPERATOR)
      | (1ULL << MySQLParser::LESS_THAN_OPERATOR)
      | (1ULL << MySQLParser::NOT_EQUAL_OPERATOR))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PredicateContext ------------------------------------------------------------------

MySQLParser::PredicateContext::PredicateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::BitExprContext *> MySQLParser::PredicateContext::bitExpr() {
  return getRuleContexts<MySQLParser::BitExprContext>();
}

MySQLParser::BitExprContext* MySQLParser::PredicateContext::bitExpr(size_t i) {
  return getRuleContext<MySQLParser::BitExprContext>(i);
}

MySQLParser::PredicateOperationsContext* MySQLParser::PredicateContext::predicateOperations() {
  return getRuleContext<MySQLParser::PredicateOperationsContext>(0);
}

tree::TerminalNode* MySQLParser::PredicateContext::MEMBER_SYMBOL() {
  return getToken(MySQLParser::MEMBER_SYMBOL, 0);
}

MySQLParser::SimpleExprWithParenthesesContext* MySQLParser::PredicateContext::simpleExprWithParentheses() {
  return getRuleContext<MySQLParser::SimpleExprWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::PredicateContext::SOUNDS_SYMBOL() {
  return getToken(MySQLParser::SOUNDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PredicateContext::LIKE_SYMBOL() {
  return getToken(MySQLParser::LIKE_SYMBOL, 0);
}

MySQLParser::NotRuleContext* MySQLParser::PredicateContext::notRule() {
  return getRuleContext<MySQLParser::NotRuleContext>(0);
}

tree::TerminalNode* MySQLParser::PredicateContext::OF_SYMBOL() {
  return getToken(MySQLParser::OF_SYMBOL, 0);
}


size_t MySQLParser::PredicateContext::getRuleIndex() const {
  return MySQLParser::RulePredicate;
}

void MySQLParser::PredicateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPredicate(this);
}

void MySQLParser::PredicateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPredicate(this);
}


std::any MySQLParser::PredicateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPredicate(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PredicateContext* MySQLParser::predicate() {
  PredicateContext *_localctx = _tracker.createInstance<PredicateContext>(_ctx, getState());
  enterRule(_localctx, 930, MySQLParser::RulePredicate);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6567);
    bitExpr(0);
    setState(6581);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 783, _ctx)) {
    case 1: {
      setState(6569);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT2_SYMBOL || _la == MySQLParser::NOT_SYMBOL) {
        setState(6568);
        notRule();
      }
      setState(6571);
      predicateOperations();
      break;
    }

    case 2: {
      setState(6572);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(6573);
      match(MySQLParser::MEMBER_SYMBOL);
      setState(6575);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::OF_SYMBOL) {
        setState(6574);
        match(MySQLParser::OF_SYMBOL);
      }
      setState(6577);
      simpleExprWithParentheses();
      break;
    }

    case 3: {
      setState(6578);
      match(MySQLParser::SOUNDS_SYMBOL);
      setState(6579);
      match(MySQLParser::LIKE_SYMBOL);
      setState(6580);
      bitExpr(0);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PredicateOperationsContext ------------------------------------------------------------------

MySQLParser::PredicateOperationsContext::PredicateOperationsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t MySQLParser::PredicateOperationsContext::getRuleIndex() const {
  return MySQLParser::RulePredicateOperations;
}

void MySQLParser::PredicateOperationsContext::copyFrom(PredicateOperationsContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- PredicateExprRegexContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PredicateExprRegexContext::REGEXP_SYMBOL() {
  return getToken(MySQLParser::REGEXP_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::PredicateExprRegexContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

MySQLParser::PredicateExprRegexContext::PredicateExprRegexContext(PredicateOperationsContext *ctx) { copyFrom(ctx); }

void MySQLParser::PredicateExprRegexContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPredicateExprRegex(this);
}
void MySQLParser::PredicateExprRegexContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPredicateExprRegex(this);
}

std::any MySQLParser::PredicateExprRegexContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPredicateExprRegex(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PredicateExprBetweenContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PredicateExprBetweenContext::BETWEEN_SYMBOL() {
  return getToken(MySQLParser::BETWEEN_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::PredicateExprBetweenContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::PredicateExprBetweenContext::AND_SYMBOL() {
  return getToken(MySQLParser::AND_SYMBOL, 0);
}

MySQLParser::PredicateContext* MySQLParser::PredicateExprBetweenContext::predicate() {
  return getRuleContext<MySQLParser::PredicateContext>(0);
}

MySQLParser::PredicateExprBetweenContext::PredicateExprBetweenContext(PredicateOperationsContext *ctx) { copyFrom(ctx); }

void MySQLParser::PredicateExprBetweenContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPredicateExprBetween(this);
}
void MySQLParser::PredicateExprBetweenContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPredicateExprBetween(this);
}

std::any MySQLParser::PredicateExprBetweenContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPredicateExprBetween(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PredicateExprInContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PredicateExprInContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

MySQLParser::SubqueryContext* MySQLParser::PredicateExprInContext::subquery() {
  return getRuleContext<MySQLParser::SubqueryContext>(0);
}

tree::TerminalNode* MySQLParser::PredicateExprInContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::PredicateExprInContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::PredicateExprInContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::PredicateExprInContext::PredicateExprInContext(PredicateOperationsContext *ctx) { copyFrom(ctx); }

void MySQLParser::PredicateExprInContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPredicateExprIn(this);
}
void MySQLParser::PredicateExprInContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPredicateExprIn(this);
}

std::any MySQLParser::PredicateExprInContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPredicateExprIn(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PredicateExprLikeContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PredicateExprLikeContext::LIKE_SYMBOL() {
  return getToken(MySQLParser::LIKE_SYMBOL, 0);
}

std::vector<MySQLParser::SimpleExprContext *> MySQLParser::PredicateExprLikeContext::simpleExpr() {
  return getRuleContexts<MySQLParser::SimpleExprContext>();
}

MySQLParser::SimpleExprContext* MySQLParser::PredicateExprLikeContext::simpleExpr(size_t i) {
  return getRuleContext<MySQLParser::SimpleExprContext>(i);
}

tree::TerminalNode* MySQLParser::PredicateExprLikeContext::ESCAPE_SYMBOL() {
  return getToken(MySQLParser::ESCAPE_SYMBOL, 0);
}

MySQLParser::PredicateExprLikeContext::PredicateExprLikeContext(PredicateOperationsContext *ctx) { copyFrom(ctx); }

void MySQLParser::PredicateExprLikeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPredicateExprLike(this);
}
void MySQLParser::PredicateExprLikeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPredicateExprLike(this);
}

std::any MySQLParser::PredicateExprLikeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPredicateExprLike(this);
  else
    return visitor->visitChildren(this);
}
MySQLParser::PredicateOperationsContext* MySQLParser::predicateOperations() {
  PredicateOperationsContext *_localctx = _tracker.createInstance<PredicateOperationsContext>(_ctx, getState());
  enterRule(_localctx, 932, MySQLParser::RulePredicateOperations);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6604);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::IN_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprInContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(6583);
        match(MySQLParser::IN_SYMBOL);
        setState(6589);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 784, _ctx)) {
        case 1: {
          setState(6584);
          subquery();
          break;
        }

        case 2: {
          setState(6585);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(6586);
          exprList();
          setState(6587);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::BETWEEN_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprBetweenContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(6591);
        match(MySQLParser::BETWEEN_SYMBOL);
        setState(6592);
        bitExpr(0);
        setState(6593);
        match(MySQLParser::AND_SYMBOL);
        setState(6594);
        predicate();
        break;
      }

      case MySQLParser::LIKE_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprLikeContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(6596);
        match(MySQLParser::LIKE_SYMBOL);
        setState(6597);
        simpleExpr(0);
        setState(6600);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 785, _ctx)) {
        case 1: {
          setState(6598);
          match(MySQLParser::ESCAPE_SYMBOL);
          setState(6599);
          simpleExpr(0);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::REGEXP_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprRegexContext>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(6602);
        match(MySQLParser::REGEXP_SYMBOL);
        setState(6603);
        bitExpr(0);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BitExprContext ------------------------------------------------------------------

MySQLParser::BitExprContext::BitExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SimpleExprContext* MySQLParser::BitExprContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

std::vector<MySQLParser::BitExprContext *> MySQLParser::BitExprContext::bitExpr() {
  return getRuleContexts<MySQLParser::BitExprContext>();
}

MySQLParser::BitExprContext* MySQLParser::BitExprContext::bitExpr(size_t i) {
  return getRuleContext<MySQLParser::BitExprContext>(i);
}

tree::TerminalNode* MySQLParser::BitExprContext::BITWISE_XOR_OPERATOR() {
  return getToken(MySQLParser::BITWISE_XOR_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::DIV_OPERATOR() {
  return getToken(MySQLParser::DIV_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::MOD_OPERATOR() {
  return getToken(MySQLParser::MOD_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::DIV_SYMBOL() {
  return getToken(MySQLParser::DIV_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::MOD_SYMBOL() {
  return getToken(MySQLParser::MOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::PLUS_OPERATOR() {
  return getToken(MySQLParser::PLUS_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::MINUS_OPERATOR() {
  return getToken(MySQLParser::MINUS_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::SHIFT_LEFT_OPERATOR() {
  return getToken(MySQLParser::SHIFT_LEFT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::SHIFT_RIGHT_OPERATOR() {
  return getToken(MySQLParser::SHIFT_RIGHT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::BITWISE_AND_OPERATOR() {
  return getToken(MySQLParser::BITWISE_AND_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::BITWISE_OR_OPERATOR() {
  return getToken(MySQLParser::BITWISE_OR_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::BitExprContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::BitExprContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::IntervalContext* MySQLParser::BitExprContext::interval() {
  return getRuleContext<MySQLParser::IntervalContext>(0);
}


size_t MySQLParser::BitExprContext::getRuleIndex() const {
  return MySQLParser::RuleBitExpr;
}

void MySQLParser::BitExprContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBitExpr(this);
}

void MySQLParser::BitExprContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBitExpr(this);
}


std::any MySQLParser::BitExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitBitExpr(this);
  else
    return visitor->visitChildren(this);
}


MySQLParser::BitExprContext* MySQLParser::bitExpr() {
   return bitExpr(0);
}

MySQLParser::BitExprContext* MySQLParser::bitExpr(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  MySQLParser::BitExprContext *_localctx = _tracker.createInstance<BitExprContext>(_ctx, parentState);
  MySQLParser::BitExprContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 934;
  enterRecursionRule(_localctx, 934, MySQLParser::RuleBitExpr, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(6607);
    simpleExpr(0);
    _ctx->stop = _input->LT(-1);
    setState(6635);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 788, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(6633);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 787, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6609);

          if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
          setState(6610);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = match(MySQLParser::BITWISE_XOR_OPERATOR);
          setState(6611);
          bitExpr(8);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6612);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(6613);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!((((_la & ~ 0x3fULL) == 0) &&
            ((1ULL << _la) & ((1ULL << MySQLParser::MULT_OPERATOR)
            | (1ULL << MySQLParser::DIV_OPERATOR)
            | (1ULL << MySQLParser::MOD_OPERATOR))) != 0) || _la == MySQLParser::DIV_SYMBOL || _la == MySQLParser::MOD_SYMBOL)) {
            antlrcpp::downCast<BitExprContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6614);
          bitExpr(7);
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6615);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(6616);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::PLUS_OPERATOR

          || _la == MySQLParser::MINUS_OPERATOR)) {
            antlrcpp::downCast<BitExprContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6617);
          bitExpr(6);
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6618);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(6619);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::SHIFT_LEFT_OPERATOR

          || _la == MySQLParser::SHIFT_RIGHT_OPERATOR)) {
            antlrcpp::downCast<BitExprContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6620);
          bitExpr(4);
          break;
        }

        case 5: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6621);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(6622);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = match(MySQLParser::BITWISE_AND_OPERATOR);
          setState(6623);
          bitExpr(3);
          break;
        }

        case 6: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6624);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(6625);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = match(MySQLParser::BITWISE_OR_OPERATOR);
          setState(6626);
          bitExpr(2);
          break;
        }

        case 7: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(6627);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(6628);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::PLUS_OPERATOR

          || _la == MySQLParser::MINUS_OPERATOR)) {
            antlrcpp::downCast<BitExprContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(6629);
          match(MySQLParser::INTERVAL_SYMBOL);
          setState(6630);
          expr(0);
          setState(6631);
          interval();
          break;
        }

        default:
          break;
        } 
      }
      setState(6637);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 788, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- SimpleExprContext ------------------------------------------------------------------

MySQLParser::SimpleExprContext::SimpleExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t MySQLParser::SimpleExprContext::getRuleIndex() const {
  return MySQLParser::RuleSimpleExpr;
}

void MySQLParser::SimpleExprContext::copyFrom(SimpleExprContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- SimpleExprConvertContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprConvertContext::CONVERT_SYMBOL() {
  return getToken(MySQLParser::CONVERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprConvertContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprConvertContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprConvertContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

MySQLParser::CastTypeContext* MySQLParser::SimpleExprConvertContext::castType() {
  return getRuleContext<MySQLParser::CastTypeContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprConvertContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::SimpleExprConvertContext::SimpleExprConvertContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprConvertContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprConvert(this);
}
void MySQLParser::SimpleExprConvertContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprConvert(this);
}

std::any MySQLParser::SimpleExprConvertContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprConvert(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprCastContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprCastContext::CAST_SYMBOL() {
  return getToken(MySQLParser::CAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprCastContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::CastTypeContext* MySQLParser::SimpleExprCastContext::castType() {
  return getRuleContext<MySQLParser::CastTypeContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastContext::AT_SYMBOL() {
  return getToken(MySQLParser::AT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

MySQLParser::ArrayCastContext* MySQLParser::SimpleExprCastContext::arrayCast() {
  return getRuleContext<MySQLParser::ArrayCastContext>(0);
}

MySQLParser::SimpleExprCastContext::SimpleExprCastContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprCastContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprCast(this);
}
void MySQLParser::SimpleExprCastContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprCast(this);
}

std::any MySQLParser::SimpleExprCastContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprCast(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprUnaryContext ------------------------------------------------------------------

MySQLParser::SimpleExprContext* MySQLParser::SimpleExprUnaryContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprUnaryContext::PLUS_OPERATOR() {
  return getToken(MySQLParser::PLUS_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprUnaryContext::MINUS_OPERATOR() {
  return getToken(MySQLParser::MINUS_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprUnaryContext::BITWISE_NOT_OPERATOR() {
  return getToken(MySQLParser::BITWISE_NOT_OPERATOR, 0);
}

MySQLParser::SimpleExprUnaryContext::SimpleExprUnaryContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprUnaryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprUnary(this);
}
void MySQLParser::SimpleExprUnaryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprUnary(this);
}

std::any MySQLParser::SimpleExprUnaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprUnary(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExpressionRValueContext ------------------------------------------------------------------

MySQLParser::RvalueSystemOrUserVariableContext* MySQLParser::SimpleExpressionRValueContext::rvalueSystemOrUserVariable() {
  return getRuleContext<MySQLParser::RvalueSystemOrUserVariableContext>(0);
}

MySQLParser::SimpleExpressionRValueContext::SimpleExpressionRValueContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExpressionRValueContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExpressionRValue(this);
}
void MySQLParser::SimpleExpressionRValueContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExpressionRValue(this);
}

std::any MySQLParser::SimpleExpressionRValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExpressionRValue(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprOdbcContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprOdbcContext::OPEN_CURLY_SYMBOL() {
  return getToken(MySQLParser::OPEN_CURLY_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::SimpleExprOdbcContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprOdbcContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprOdbcContext::CLOSE_CURLY_SYMBOL() {
  return getToken(MySQLParser::CLOSE_CURLY_SYMBOL, 0);
}

MySQLParser::SimpleExprOdbcContext::SimpleExprOdbcContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprOdbcContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprOdbc(this);
}
void MySQLParser::SimpleExprOdbcContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprOdbc(this);
}

std::any MySQLParser::SimpleExprOdbcContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprOdbc(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprRuntimeFunctionContext ------------------------------------------------------------------

MySQLParser::RuntimeFunctionCallContext* MySQLParser::SimpleExprRuntimeFunctionContext::runtimeFunctionCall() {
  return getRuleContext<MySQLParser::RuntimeFunctionCallContext>(0);
}

MySQLParser::SimpleExprRuntimeFunctionContext::SimpleExprRuntimeFunctionContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprRuntimeFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprRuntimeFunction(this);
}
void MySQLParser::SimpleExprRuntimeFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprRuntimeFunction(this);
}

std::any MySQLParser::SimpleExprRuntimeFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprRuntimeFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprFunctionContext ------------------------------------------------------------------

MySQLParser::FunctionCallContext* MySQLParser::SimpleExprFunctionContext::functionCall() {
  return getRuleContext<MySQLParser::FunctionCallContext>(0);
}

MySQLParser::SimpleExprFunctionContext::SimpleExprFunctionContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprFunction(this);
}
void MySQLParser::SimpleExprFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprFunction(this);
}

std::any MySQLParser::SimpleExprFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprCollateContext ------------------------------------------------------------------

MySQLParser::SimpleExprContext* MySQLParser::SimpleExprCollateContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprCollateContext::COLLATE_SYMBOL() {
  return getToken(MySQLParser::COLLATE_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::SimpleExprCollateContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::SimpleExprCollateContext::SimpleExprCollateContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprCollateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprCollate(this);
}
void MySQLParser::SimpleExprCollateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprCollate(this);
}

std::any MySQLParser::SimpleExprCollateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprCollate(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprMatchContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprMatchContext::MATCH_SYMBOL() {
  return getToken(MySQLParser::MATCH_SYMBOL, 0);
}

MySQLParser::IdentListArgContext* MySQLParser::SimpleExprMatchContext::identListArg() {
  return getRuleContext<MySQLParser::IdentListArgContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprMatchContext::AGAINST_SYMBOL() {
  return getToken(MySQLParser::AGAINST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprMatchContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::SimpleExprMatchContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprMatchContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::FulltextOptionsContext* MySQLParser::SimpleExprMatchContext::fulltextOptions() {
  return getRuleContext<MySQLParser::FulltextOptionsContext>(0);
}

MySQLParser::SimpleExprMatchContext::SimpleExprMatchContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprMatchContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprMatch(this);
}
void MySQLParser::SimpleExprMatchContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprMatch(this);
}

std::any MySQLParser::SimpleExprMatchContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprMatch(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprWindowingFunctionContext ------------------------------------------------------------------

MySQLParser::WindowFunctionCallContext* MySQLParser::SimpleExprWindowingFunctionContext::windowFunctionCall() {
  return getRuleContext<MySQLParser::WindowFunctionCallContext>(0);
}

MySQLParser::SimpleExprWindowingFunctionContext::SimpleExprWindowingFunctionContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprWindowingFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprWindowingFunction(this);
}
void MySQLParser::SimpleExprWindowingFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprWindowingFunction(this);
}

std::any MySQLParser::SimpleExprWindowingFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprWindowingFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprBinaryContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprBinaryContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

MySQLParser::SimpleExprContext* MySQLParser::SimpleExprBinaryContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

MySQLParser::SimpleExprBinaryContext::SimpleExprBinaryContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprBinaryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprBinary(this);
}
void MySQLParser::SimpleExprBinaryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprBinary(this);
}

std::any MySQLParser::SimpleExprBinaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprBinary(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprColumnRefContext ------------------------------------------------------------------

MySQLParser::ColumnRefContext* MySQLParser::SimpleExprColumnRefContext::columnRef() {
  return getRuleContext<MySQLParser::ColumnRefContext>(0);
}

MySQLParser::JsonOperatorContext* MySQLParser::SimpleExprColumnRefContext::jsonOperator() {
  return getRuleContext<MySQLParser::JsonOperatorContext>(0);
}

MySQLParser::SimpleExprColumnRefContext::SimpleExprColumnRefContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprColumnRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprColumnRef(this);
}
void MySQLParser::SimpleExprColumnRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprColumnRef(this);
}

std::any MySQLParser::SimpleExprColumnRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprColumnRef(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprParamMarkerContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprParamMarkerContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}

MySQLParser::SimpleExprParamMarkerContext::SimpleExprParamMarkerContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprParamMarkerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprParamMarker(this);
}
void MySQLParser::SimpleExprParamMarkerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprParamMarker(this);
}

std::any MySQLParser::SimpleExprParamMarkerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprParamMarker(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprSumContext ------------------------------------------------------------------

MySQLParser::SumExprContext* MySQLParser::SimpleExprSumContext::sumExpr() {
  return getRuleContext<MySQLParser::SumExprContext>(0);
}

MySQLParser::SimpleExprSumContext::SimpleExprSumContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprSumContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprSum(this);
}
void MySQLParser::SimpleExprSumContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprSum(this);
}

std::any MySQLParser::SimpleExprSumContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprSum(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprCastTimeContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::CAST_SYMBOL() {
  return getToken(MySQLParser::CAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprCastTimeContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::AT_SYMBOL() {
  return getToken(MySQLParser::AT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::ZONE_SYMBOL() {
  return getToken(MySQLParser::ZONE_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::SimpleExprCastTimeContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::DATETIME_SYMBOL() {
  return getToken(MySQLParser::DATETIME_SYMBOL, 0);
}

MySQLParser::TypeDatetimePrecisionContext* MySQLParser::SimpleExprCastTimeContext::typeDatetimePrecision() {
  return getRuleContext<MySQLParser::TypeDatetimePrecisionContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCastTimeContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

MySQLParser::SimpleExprCastTimeContext::SimpleExprCastTimeContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprCastTimeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprCastTime(this);
}
void MySQLParser::SimpleExprCastTimeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprCastTime(this);
}

std::any MySQLParser::SimpleExprCastTimeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprCastTime(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprConvertUsingContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprConvertUsingContext::CONVERT_SYMBOL() {
  return getToken(MySQLParser::CONVERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprConvertUsingContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprConvertUsingContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprConvertUsingContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::CharsetNameContext* MySQLParser::SimpleExprConvertUsingContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprConvertUsingContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::SimpleExprConvertUsingContext::SimpleExprConvertUsingContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprConvertUsingContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprConvertUsing(this);
}
void MySQLParser::SimpleExprConvertUsingContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprConvertUsing(this);
}

std::any MySQLParser::SimpleExprConvertUsingContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprConvertUsing(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprSubQueryContext ------------------------------------------------------------------

MySQLParser::SubqueryContext* MySQLParser::SimpleExprSubQueryContext::subquery() {
  return getRuleContext<MySQLParser::SubqueryContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprSubQueryContext::EXISTS_SYMBOL() {
  return getToken(MySQLParser::EXISTS_SYMBOL, 0);
}

MySQLParser::SimpleExprSubQueryContext::SimpleExprSubQueryContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprSubQueryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprSubQuery(this);
}
void MySQLParser::SimpleExprSubQueryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprSubQuery(this);
}

std::any MySQLParser::SimpleExprSubQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprSubQuery(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprGroupingOperationContext ------------------------------------------------------------------

MySQLParser::GroupingOperationContext* MySQLParser::SimpleExprGroupingOperationContext::groupingOperation() {
  return getRuleContext<MySQLParser::GroupingOperationContext>(0);
}

MySQLParser::SimpleExprGroupingOperationContext::SimpleExprGroupingOperationContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprGroupingOperationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprGroupingOperation(this);
}
void MySQLParser::SimpleExprGroupingOperationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprGroupingOperation(this);
}

std::any MySQLParser::SimpleExprGroupingOperationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprGroupingOperation(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprNotContext ------------------------------------------------------------------

MySQLParser::Not2RuleContext* MySQLParser::SimpleExprNotContext::not2Rule() {
  return getRuleContext<MySQLParser::Not2RuleContext>(0);
}

MySQLParser::SimpleExprContext* MySQLParser::SimpleExprNotContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

MySQLParser::SimpleExprNotContext::SimpleExprNotContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprNotContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprNot(this);
}
void MySQLParser::SimpleExprNotContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprNot(this);
}

std::any MySQLParser::SimpleExprNotContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprNot(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprValuesContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprValuesContext::VALUES_SYMBOL() {
  return getToken(MySQLParser::VALUES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprValuesContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::SimpleIdentifierContext* MySQLParser::SimpleExprValuesContext::simpleIdentifier() {
  return getRuleContext<MySQLParser::SimpleIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprValuesContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::SimpleExprValuesContext::SimpleExprValuesContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprValuesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprValues(this);
}
void MySQLParser::SimpleExprValuesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprValues(this);
}

std::any MySQLParser::SimpleExprValuesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprValues(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprUserVariableAssignmentContext ------------------------------------------------------------------

MySQLParser::InExpressionUserVariableAssignmentContext* MySQLParser::SimpleExprUserVariableAssignmentContext::inExpressionUserVariableAssignment() {
  return getRuleContext<MySQLParser::InExpressionUserVariableAssignmentContext>(0);
}

MySQLParser::SimpleExprUserVariableAssignmentContext::SimpleExprUserVariableAssignmentContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprUserVariableAssignmentContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprUserVariableAssignment(this);
}
void MySQLParser::SimpleExprUserVariableAssignmentContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprUserVariableAssignment(this);
}

std::any MySQLParser::SimpleExprUserVariableAssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprUserVariableAssignment(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprDefaultContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprDefaultContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprDefaultContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::SimpleIdentifierContext* MySQLParser::SimpleExprDefaultContext::simpleIdentifier() {
  return getRuleContext<MySQLParser::SimpleIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprDefaultContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::SimpleExprDefaultContext::SimpleExprDefaultContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprDefaultContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprDefault(this);
}
void MySQLParser::SimpleExprDefaultContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprDefault(this);
}

std::any MySQLParser::SimpleExprDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprDefault(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprListContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::SimpleExprListContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprListContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}

MySQLParser::SimpleExprListContext::SimpleExprListContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprList(this);
}
void MySQLParser::SimpleExprListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprList(this);
}

std::any MySQLParser::SimpleExprListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprList(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprIntervalContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprIntervalContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

std::vector<MySQLParser::ExprContext *> MySQLParser::SimpleExprIntervalContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::SimpleExprIntervalContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

MySQLParser::IntervalContext* MySQLParser::SimpleExprIntervalContext::interval() {
  return getRuleContext<MySQLParser::IntervalContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprIntervalContext::PLUS_OPERATOR() {
  return getToken(MySQLParser::PLUS_OPERATOR, 0);
}

MySQLParser::SimpleExprIntervalContext::SimpleExprIntervalContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprIntervalContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprInterval(this);
}
void MySQLParser::SimpleExprIntervalContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprInterval(this);
}

std::any MySQLParser::SimpleExprIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprInterval(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprCaseContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::SimpleExprCaseContext::CASE_SYMBOL() {
  return getToken(MySQLParser::CASE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SimpleExprCaseContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprCaseContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

std::vector<MySQLParser::WhenExpressionContext *> MySQLParser::SimpleExprCaseContext::whenExpression() {
  return getRuleContexts<MySQLParser::WhenExpressionContext>();
}

MySQLParser::WhenExpressionContext* MySQLParser::SimpleExprCaseContext::whenExpression(size_t i) {
  return getRuleContext<MySQLParser::WhenExpressionContext>(i);
}

std::vector<MySQLParser::ThenExpressionContext *> MySQLParser::SimpleExprCaseContext::thenExpression() {
  return getRuleContexts<MySQLParser::ThenExpressionContext>();
}

MySQLParser::ThenExpressionContext* MySQLParser::SimpleExprCaseContext::thenExpression(size_t i) {
  return getRuleContext<MySQLParser::ThenExpressionContext>(i);
}

MySQLParser::ElseExpressionContext* MySQLParser::SimpleExprCaseContext::elseExpression() {
  return getRuleContext<MySQLParser::ElseExpressionContext>(0);
}

MySQLParser::SimpleExprCaseContext::SimpleExprCaseContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprCaseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprCase(this);
}
void MySQLParser::SimpleExprCaseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprCase(this);
}

std::any MySQLParser::SimpleExprCaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprCase(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprConcatContext ------------------------------------------------------------------

std::vector<MySQLParser::SimpleExprContext *> MySQLParser::SimpleExprConcatContext::simpleExpr() {
  return getRuleContexts<MySQLParser::SimpleExprContext>();
}

MySQLParser::SimpleExprContext* MySQLParser::SimpleExprConcatContext::simpleExpr(size_t i) {
  return getRuleContext<MySQLParser::SimpleExprContext>(i);
}

tree::TerminalNode* MySQLParser::SimpleExprConcatContext::CONCAT_PIPES_SYMBOL() {
  return getToken(MySQLParser::CONCAT_PIPES_SYMBOL, 0);
}

MySQLParser::SimpleExprConcatContext::SimpleExprConcatContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprConcatContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprConcat(this);
}
void MySQLParser::SimpleExprConcatContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprConcat(this);
}

std::any MySQLParser::SimpleExprConcatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprConcat(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleExprLiteralContext ------------------------------------------------------------------

MySQLParser::LiteralOrNullContext* MySQLParser::SimpleExprLiteralContext::literalOrNull() {
  return getRuleContext<MySQLParser::LiteralOrNullContext>(0);
}

MySQLParser::SimpleExprLiteralContext::SimpleExprLiteralContext(SimpleExprContext *ctx) { copyFrom(ctx); }

void MySQLParser::SimpleExprLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprLiteral(this);
}
void MySQLParser::SimpleExprLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprLiteral(this);
}

std::any MySQLParser::SimpleExprLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SimpleExprContext* MySQLParser::simpleExpr() {
   return simpleExpr(0);
}

MySQLParser::SimpleExprContext* MySQLParser::simpleExpr(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  MySQLParser::SimpleExprContext *_localctx = _tracker.createInstance<SimpleExprContext>(_ctx, parentState);
  MySQLParser::SimpleExprContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 936;
  enterRecursionRule(_localctx, 936, MySQLParser::RuleSimpleExpr, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(6763);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 799, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<SimpleExprColumnRefContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(6639);
      columnRef();
      setState(6641);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 789, _ctx)) {
      case 1: {
        setState(6640);
        jsonOperator();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<SimpleExprRuntimeFunctionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6643);
      runtimeFunctionCall();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<SimpleExprFunctionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6644);
      functionCall();
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<SimpleExprLiteralContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6645);
      literalOrNull();
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<SimpleExprParamMarkerContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6646);
      match(MySQLParser::PARAM_MARKER);
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<SimpleExpressionRValueContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6647);
      rvalueSystemOrUserVariable();
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<SimpleExprUserVariableAssignmentContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6648);
      inExpressionUserVariableAssignment();
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<SimpleExprSumContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6649);
      sumExpr();
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<SimpleExprGroupingOperationContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6650);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(6651);
      groupingOperation();
      break;
    }

    case 10: {
      _localctx = _tracker.createInstance<SimpleExprWindowingFunctionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6652);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(6653);
      windowFunctionCall();
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<SimpleExprUnaryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6654);
      antlrcpp::downCast<SimpleExprUnaryContext *>(_localctx)->op = _input->LT(1);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << MySQLParser::PLUS_OPERATOR)
        | (1ULL << MySQLParser::MINUS_OPERATOR)
        | (1ULL << MySQLParser::BITWISE_NOT_OPERATOR))) != 0))) {
        antlrcpp::downCast<SimpleExprUnaryContext *>(_localctx)->op = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6655);
      simpleExpr(15);
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<SimpleExprNotContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6656);
      not2Rule();
      setState(6657);
      simpleExpr(14);
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<SimpleExprListContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6660);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ROW_SYMBOL) {
        setState(6659);
        match(MySQLParser::ROW_SYMBOL);
      }
      setState(6662);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6663);
      exprList();
      setState(6664);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<SimpleExprSubQueryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6667);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXISTS_SYMBOL) {
        setState(6666);
        match(MySQLParser::EXISTS_SYMBOL);
      }
      setState(6669);
      subquery();
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<SimpleExprOdbcContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6670);
      match(MySQLParser::OPEN_CURLY_SYMBOL);
      setState(6671);
      identifier();
      setState(6672);
      expr(0);
      setState(6673);
      match(MySQLParser::CLOSE_CURLY_SYMBOL);
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<SimpleExprMatchContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6675);
      match(MySQLParser::MATCH_SYMBOL);
      setState(6676);
      identListArg();
      setState(6677);
      match(MySQLParser::AGAINST_SYMBOL);
      setState(6678);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6679);
      bitExpr(0);
      setState(6681);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::IN_SYMBOL || _la == MySQLParser::WITH_SYMBOL) {
        setState(6680);
        fulltextOptions();
      }
      setState(6683);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<SimpleExprBinaryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6685);
      match(MySQLParser::BINARY_SYMBOL);
      setState(6686);
      simpleExpr(9);
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<SimpleExprCastContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6687);
      match(MySQLParser::CAST_SYMBOL);
      setState(6688);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6689);
      expr(0);
      setState(6692);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::AT_SYMBOL) {
        setState(6690);
        match(MySQLParser::AT_SYMBOL);
        setState(6691);
        match(MySQLParser::LOCAL_SYMBOL);
      }
      setState(6694);
      match(MySQLParser::AS_SYMBOL);
      setState(6695);
      castType();
      setState(6697);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 794, _ctx)) {
      case 1: {
        setState(6696);
        arrayCast();
        break;
      }

      default:
        break;
      }
      setState(6699);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<SimpleExprCastTimeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6701);

      if (!(serverVersion >= 80022)) throw FailedPredicateException(this, "serverVersion >= 80022");
      setState(6702);
      match(MySQLParser::CAST_SYMBOL);
      setState(6703);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6704);
      expr(0);
      setState(6705);
      match(MySQLParser::AT_SYMBOL);
      setState(6706);
      match(MySQLParser::TIME_SYMBOL);
      setState(6707);
      match(MySQLParser::ZONE_SYMBOL);
      setState(6709);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 795, _ctx)) {
      case 1: {
        setState(6708);
        match(MySQLParser::INTERVAL_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(6711);
      textStringLiteral();
      setState(6712);
      match(MySQLParser::AS_SYMBOL);
      setState(6713);
      match(MySQLParser::DATETIME_SYMBOL);
      setState(6714);
      typeDatetimePrecision();
      setState(6715);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<SimpleExprCaseContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6717);
      match(MySQLParser::CASE_SYMBOL);
      setState(6719);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 796, _ctx)) {
      case 1: {
        setState(6718);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(6724); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(6721);
        whenExpression();
        setState(6722);
        thenExpression();
        setState(6726); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == MySQLParser::WHEN_SYMBOL);
      setState(6729);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ELSE_SYMBOL) {
        setState(6728);
        elseExpression();
      }
      setState(6731);
      match(MySQLParser::END_SYMBOL);
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<SimpleExprConvertContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6733);
      match(MySQLParser::CONVERT_SYMBOL);
      setState(6734);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6735);
      expr(0);
      setState(6736);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6737);
      castType();
      setState(6738);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<SimpleExprConvertUsingContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6740);
      match(MySQLParser::CONVERT_SYMBOL);
      setState(6741);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6742);
      expr(0);
      setState(6743);
      match(MySQLParser::USING_SYMBOL);
      setState(6744);
      charsetName();
      setState(6745);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 23: {
      _localctx = _tracker.createInstance<SimpleExprDefaultContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6747);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(6748);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6749);
      simpleIdentifier();
      setState(6750);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 24: {
      _localctx = _tracker.createInstance<SimpleExprValuesContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6752);
      match(MySQLParser::VALUES_SYMBOL);
      setState(6753);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6754);
      simpleIdentifier();
      setState(6755);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 25: {
      _localctx = _tracker.createInstance<SimpleExprIntervalContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(6757);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(6758);
      expr(0);
      setState(6759);
      interval();
      setState(6760);
      match(MySQLParser::PLUS_OPERATOR);
      setState(6761);
      expr(0);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(6773);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 801, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(6771);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 800, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<SimpleExprConcatContext>(_tracker.createInstance<SimpleExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleSimpleExpr);
          setState(6765);

          if (!(precpred(_ctx, 16))) throw FailedPredicateException(this, "precpred(_ctx, 16)");
          setState(6766);
          match(MySQLParser::CONCAT_PIPES_SYMBOL);
          setState(6767);
          simpleExpr(17);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<SimpleExprCollateContext>(_tracker.createInstance<SimpleExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleSimpleExpr);
          setState(6768);

          if (!(precpred(_ctx, 24))) throw FailedPredicateException(this, "precpred(_ctx, 24)");
          setState(6769);
          match(MySQLParser::COLLATE_SYMBOL);
          setState(6770);
          textOrIdentifier();
          break;
        }

        default:
          break;
        } 
      }
      setState(6775);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 801, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- ArrayCastContext ------------------------------------------------------------------

MySQLParser::ArrayCastContext::ArrayCastContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ArrayCastContext::ARRAY_SYMBOL() {
  return getToken(MySQLParser::ARRAY_SYMBOL, 0);
}


size_t MySQLParser::ArrayCastContext::getRuleIndex() const {
  return MySQLParser::RuleArrayCast;
}

void MySQLParser::ArrayCastContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterArrayCast(this);
}

void MySQLParser::ArrayCastContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitArrayCast(this);
}


std::any MySQLParser::ArrayCastContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitArrayCast(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ArrayCastContext* MySQLParser::arrayCast() {
  ArrayCastContext *_localctx = _tracker.createInstance<ArrayCastContext>(_ctx, getState());
  enterRule(_localctx, 938, MySQLParser::RuleArrayCast);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6776);

    if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
    setState(6777);
    match(MySQLParser::ARRAY_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JsonOperatorContext ------------------------------------------------------------------

MySQLParser::JsonOperatorContext::JsonOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::JsonOperatorContext::JSON_SEPARATOR_SYMBOL() {
  return getToken(MySQLParser::JSON_SEPARATOR_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::JsonOperatorContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::JsonOperatorContext::JSON_UNQUOTED_SEPARATOR_SYMBOL() {
  return getToken(MySQLParser::JSON_UNQUOTED_SEPARATOR_SYMBOL, 0);
}


size_t MySQLParser::JsonOperatorContext::getRuleIndex() const {
  return MySQLParser::RuleJsonOperator;
}

void MySQLParser::JsonOperatorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterJsonOperator(this);
}

void MySQLParser::JsonOperatorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitJsonOperator(this);
}


std::any MySQLParser::JsonOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitJsonOperator(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::JsonOperatorContext* MySQLParser::jsonOperator() {
  JsonOperatorContext *_localctx = _tracker.createInstance<JsonOperatorContext>(_ctx, getState());
  enterRule(_localctx, 940, MySQLParser::RuleJsonOperator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6785);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 802, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6779);

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(6780);
      match(MySQLParser::JSON_SEPARATOR_SYMBOL);
      setState(6781);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6782);

      if (!(serverVersion >= 50713)) throw FailedPredicateException(this, "serverVersion >= 50713");
      setState(6783);
      match(MySQLParser::JSON_UNQUOTED_SEPARATOR_SYMBOL);
      setState(6784);
      textStringLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SumExprContext ------------------------------------------------------------------

MySQLParser::SumExprContext::SumExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SumExprContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::InSumExprContext* MySQLParser::SumExprContext::inSumExpr() {
  return getRuleContext<MySQLParser::InSumExprContext>(0);
}

tree::TerminalNode* MySQLParser::SumExprContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::AVG_SYMBOL() {
  return getToken(MySQLParser::AVG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::DISTINCT_SYMBOL() {
  return getToken(MySQLParser::DISTINCT_SYMBOL, 0);
}

MySQLParser::WindowingClauseContext* MySQLParser::SumExprContext::windowingClause() {
  return getRuleContext<MySQLParser::WindowingClauseContext>(0);
}

tree::TerminalNode* MySQLParser::SumExprContext::BIT_AND_SYMBOL() {
  return getToken(MySQLParser::BIT_AND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::BIT_OR_SYMBOL() {
  return getToken(MySQLParser::BIT_OR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::BIT_XOR_SYMBOL() {
  return getToken(MySQLParser::BIT_XOR_SYMBOL, 0);
}

MySQLParser::JsonFunctionContext* MySQLParser::SumExprContext::jsonFunction() {
  return getRuleContext<MySQLParser::JsonFunctionContext>(0);
}

tree::TerminalNode* MySQLParser::SumExprContext::ST_COLLECT_SYMBOL() {
  return getToken(MySQLParser::ST_COLLECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::COUNT_SYMBOL() {
  return getToken(MySQLParser::COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

MySQLParser::ExprListContext* MySQLParser::SumExprContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::SumExprContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::MIN_SYMBOL() {
  return getToken(MySQLParser::MIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::MAX_SYMBOL() {
  return getToken(MySQLParser::MAX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::STD_SYMBOL() {
  return getToken(MySQLParser::STD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::VARIANCE_SYMBOL() {
  return getToken(MySQLParser::VARIANCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::STDDEV_SAMP_SYMBOL() {
  return getToken(MySQLParser::STDDEV_SAMP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::VAR_SAMP_SYMBOL() {
  return getToken(MySQLParser::VAR_SAMP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::SUM_SYMBOL() {
  return getToken(MySQLParser::SUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::GROUP_CONCAT_SYMBOL() {
  return getToken(MySQLParser::GROUP_CONCAT_SYMBOL, 0);
}

MySQLParser::OrderClauseContext* MySQLParser::SumExprContext::orderClause() {
  return getRuleContext<MySQLParser::OrderClauseContext>(0);
}

tree::TerminalNode* MySQLParser::SumExprContext::SEPARATOR_SYMBOL() {
  return getToken(MySQLParser::SEPARATOR_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::SumExprContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::SumExprContext::getRuleIndex() const {
  return MySQLParser::RuleSumExpr;
}

void MySQLParser::SumExprContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSumExpr(this);
}

void MySQLParser::SumExprContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSumExpr(this);
}


std::any MySQLParser::SumExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSumExpr(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SumExprContext* MySQLParser::sumExpr() {
  SumExprContext *_localctx = _tracker.createInstance<SumExprContext>(_ctx, getState());
  enterRule(_localctx, 942, MySQLParser::RuleSumExpr);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6881);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 819, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6787);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::AVG_SYMBOL);
      setState(6788);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6790);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 803, _ctx)) {
      case 1: {
        setState(6789);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(6792);
      inSumExpr();
      setState(6793);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6796);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 804, _ctx)) {
      case 1: {
        setState(6794);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6795);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6798);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 80) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 80)) & ((1ULL << (MySQLParser::BIT_AND_SYMBOL - 80))
        | (1ULL << (MySQLParser::BIT_OR_SYMBOL - 80))
        | (1ULL << (MySQLParser::BIT_XOR_SYMBOL - 80)))) != 0))) {
        antlrcpp::downCast<SumExprContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6799);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6800);
      inSumExpr();
      setState(6801);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6804);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 805, _ctx)) {
      case 1: {
        setState(6802);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6803);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6806);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(6807);
      jsonFunction();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6808);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(6809);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::ST_COLLECT_SYMBOL);
      setState(6810);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6812);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 806, _ctx)) {
      case 1: {
        setState(6811);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(6814);
      inSumExpr();
      setState(6815);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6817);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 807, _ctx)) {
      case 1: {
        setState(6816);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6819);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::COUNT_SYMBOL);
      setState(6820);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6828);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 809, _ctx)) {
      case 1: {
        setState(6822);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ALL_SYMBOL) {
          setState(6821);
          match(MySQLParser::ALL_SYMBOL);
        }
        setState(6824);
        match(MySQLParser::MULT_OPERATOR);
        break;
      }

      case 2: {
        setState(6825);
        inSumExpr();
        break;
      }

      case 3: {
        setState(6826);
        match(MySQLParser::DISTINCT_SYMBOL);
        setState(6827);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(6830);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6833);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 810, _ctx)) {
      case 1: {
        setState(6831);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6832);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6835);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::MAX_SYMBOL

      || _la == MySQLParser::MIN_SYMBOL)) {
        antlrcpp::downCast<SumExprContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6836);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6838);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 811, _ctx)) {
      case 1: {
        setState(6837);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(6840);
      inSumExpr();
      setState(6841);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6844);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 812, _ctx)) {
      case 1: {
        setState(6842);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6843);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(6846);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 574) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 574)) & ((1ULL << (MySQLParser::STDDEV_SAMP_SYMBOL - 574))
        | (1ULL << (MySQLParser::STD_SYMBOL - 574))
        | (1ULL << (MySQLParser::SUM_SYMBOL - 574)))) != 0) || _la == MySQLParser::VARIANCE_SYMBOL

      || _la == MySQLParser::VAR_SAMP_SYMBOL)) {
        antlrcpp::downCast<SumExprContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6847);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6848);
      inSumExpr();
      setState(6849);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6852);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 813, _ctx)) {
      case 1: {
        setState(6850);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6851);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(6854);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::SUM_SYMBOL);
      setState(6855);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6856);
      match(MySQLParser::DISTINCT_SYMBOL);
      setState(6857);
      inSumExpr();
      setState(6858);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6861);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 814, _ctx)) {
      case 1: {
        setState(6859);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6860);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(6863);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::GROUP_CONCAT_SYMBOL);
      setState(6864);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6866);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 815, _ctx)) {
      case 1: {
        setState(6865);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(6868);
      exprList();
      setState(6870);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ORDER_SYMBOL) {
        setState(6869);
        orderClause();
      }
      setState(6874);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::SEPARATOR_SYMBOL) {
        setState(6872);
        match(MySQLParser::SEPARATOR_SYMBOL);
        setState(6873);
        textString();
      }
      setState(6876);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(6879);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 818, _ctx)) {
      case 1: {
        setState(6877);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6878);
        windowingClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupingOperationContext ------------------------------------------------------------------

MySQLParser::GroupingOperationContext::GroupingOperationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GroupingOperationContext::GROUPING_SYMBOL() {
  return getToken(MySQLParser::GROUPING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupingOperationContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::GroupingOperationContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::GroupingOperationContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::GroupingOperationContext::getRuleIndex() const {
  return MySQLParser::RuleGroupingOperation;
}

void MySQLParser::GroupingOperationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupingOperation(this);
}

void MySQLParser::GroupingOperationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupingOperation(this);
}


std::any MySQLParser::GroupingOperationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupingOperation(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupingOperationContext* MySQLParser::groupingOperation() {
  GroupingOperationContext *_localctx = _tracker.createInstance<GroupingOperationContext>(_ctx, getState());
  enterRule(_localctx, 944, MySQLParser::RuleGroupingOperation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6883);
    match(MySQLParser::GROUPING_SYMBOL);
    setState(6884);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6885);
    exprList();
    setState(6886);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowFunctionCallContext ------------------------------------------------------------------

MySQLParser::WindowFunctionCallContext::WindowFunctionCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ParenthesesContext* MySQLParser::WindowFunctionCallContext::parentheses() {
  return getRuleContext<MySQLParser::ParenthesesContext>(0);
}

MySQLParser::WindowingClauseContext* MySQLParser::WindowFunctionCallContext::windowingClause() {
  return getRuleContext<MySQLParser::WindowingClauseContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::ROW_NUMBER_SYMBOL() {
  return getToken(MySQLParser::ROW_NUMBER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::RANK_SYMBOL() {
  return getToken(MySQLParser::RANK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::DENSE_RANK_SYMBOL() {
  return getToken(MySQLParser::DENSE_RANK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::CUME_DIST_SYMBOL() {
  return getToken(MySQLParser::CUME_DIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::PERCENT_RANK_SYMBOL() {
  return getToken(MySQLParser::PERCENT_RANK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::NTILE_SYMBOL() {
  return getToken(MySQLParser::NTILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::StableIntegerContext* MySQLParser::WindowFunctionCallContext::stableInteger() {
  return getRuleContext<MySQLParser::StableIntegerContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::SimpleExprWithParenthesesContext* MySQLParser::WindowFunctionCallContext::simpleExprWithParentheses() {
  return getRuleContext<MySQLParser::SimpleExprWithParenthesesContext>(0);
}

MySQLParser::ExprContext* MySQLParser::WindowFunctionCallContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::LEAD_SYMBOL() {
  return getToken(MySQLParser::LEAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::LAG_SYMBOL() {
  return getToken(MySQLParser::LAG_SYMBOL, 0);
}

MySQLParser::LeadLagInfoContext* MySQLParser::WindowFunctionCallContext::leadLagInfo() {
  return getRuleContext<MySQLParser::LeadLagInfoContext>(0);
}

MySQLParser::NullTreatmentContext* MySQLParser::WindowFunctionCallContext::nullTreatment() {
  return getRuleContext<MySQLParser::NullTreatmentContext>(0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::WindowFunctionCallContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::FIRST_VALUE_SYMBOL() {
  return getToken(MySQLParser::FIRST_VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::LAST_VALUE_SYMBOL() {
  return getToken(MySQLParser::LAST_VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::NTH_VALUE_SYMBOL() {
  return getToken(MySQLParser::NTH_VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

MySQLParser::SimpleExprContext* MySQLParser::WindowFunctionCallContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::FIRST_SYMBOL() {
  return getToken(MySQLParser::FIRST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::LAST_SYMBOL() {
  return getToken(MySQLParser::LAST_SYMBOL, 0);
}


size_t MySQLParser::WindowFunctionCallContext::getRuleIndex() const {
  return MySQLParser::RuleWindowFunctionCall;
}

void MySQLParser::WindowFunctionCallContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowFunctionCall(this);
}

void MySQLParser::WindowFunctionCallContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowFunctionCall(this);
}


std::any MySQLParser::WindowFunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowFunctionCall(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowFunctionCallContext* MySQLParser::windowFunctionCall() {
  WindowFunctionCallContext *_localctx = _tracker.createInstance<WindowFunctionCallContext>(_ctx, getState());
  enterRule(_localctx, 946, MySQLParser::RuleWindowFunctionCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6937);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CUME_DIST_SYMBOL:
      case MySQLParser::DENSE_RANK_SYMBOL:
      case MySQLParser::PERCENT_RANK_SYMBOL:
      case MySQLParser::RANK_SYMBOL:
      case MySQLParser::ROW_NUMBER_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6888);
        _la = _input->LA(1);
        if (!(((((_la - 703) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 703)) & ((1ULL << (MySQLParser::CUME_DIST_SYMBOL - 703))
          | (1ULL << (MySQLParser::DENSE_RANK_SYMBOL - 703))
          | (1ULL << (MySQLParser::PERCENT_RANK_SYMBOL - 703))
          | (1ULL << (MySQLParser::RANK_SYMBOL - 703))
          | (1ULL << (MySQLParser::ROW_NUMBER_SYMBOL - 703)))) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(6889);
        parentheses();
        setState(6890);
        windowingClause();
        break;
      }

      case MySQLParser::NTILE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6892);
        match(MySQLParser::NTILE_SYMBOL);
        setState(6899);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 820, _ctx)) {
        case 1: {
          setState(6893);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(6894);
          stableInteger();
          setState(6895);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

        case 2: {
          setState(6897);

          if (!(serverVersion < 80024)) throw FailedPredicateException(this, "serverVersion < 80024");
          setState(6898);
          simpleExprWithParentheses();
          break;
        }

        default:
          break;
        }
        setState(6901);
        windowingClause();
        break;
      }

      case MySQLParser::LAG_SYMBOL:
      case MySQLParser::LEAD_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(6903);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::LAG_SYMBOL

        || _la == MySQLParser::LEAD_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(6904);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(6905);
        expr(0);
        setState(6907);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(6906);
          leadLagInfo();
        }
        setState(6909);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(6911);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL) {
          setState(6910);
          nullTreatment();
        }
        setState(6913);
        windowingClause();
        break;
      }

      case MySQLParser::FIRST_VALUE_SYMBOL:
      case MySQLParser::LAST_VALUE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(6915);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::FIRST_VALUE_SYMBOL

        || _la == MySQLParser::LAST_VALUE_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(6916);
        exprWithParentheses();
        setState(6918);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL) {
          setState(6917);
          nullTreatment();
        }
        setState(6920);
        windowingClause();
        break;
      }

      case MySQLParser::NTH_VALUE_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(6922);
        match(MySQLParser::NTH_VALUE_SYMBOL);
        setState(6923);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(6924);
        expr(0);
        setState(6925);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6926);
        simpleExpr(0);
        setState(6927);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(6930);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FROM_SYMBOL) {
          setState(6928);
          match(MySQLParser::FROM_SYMBOL);
          setState(6929);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::FIRST_SYMBOL || _la == MySQLParser::LAST_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        setState(6933);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL) {
          setState(6932);
          nullTreatment();
        }
        setState(6935);
        windowingClause();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SamplingMethodContext ------------------------------------------------------------------

MySQLParser::SamplingMethodContext::SamplingMethodContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SamplingMethodContext::SYSTEM_SYMBOL() {
  return getToken(MySQLParser::SYSTEM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SamplingMethodContext::BERNOULLI_SYMBOL() {
  return getToken(MySQLParser::BERNOULLI_SYMBOL, 0);
}


size_t MySQLParser::SamplingMethodContext::getRuleIndex() const {
  return MySQLParser::RuleSamplingMethod;
}

void MySQLParser::SamplingMethodContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSamplingMethod(this);
}

void MySQLParser::SamplingMethodContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSamplingMethod(this);
}


std::any MySQLParser::SamplingMethodContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSamplingMethod(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SamplingMethodContext* MySQLParser::samplingMethod() {
  SamplingMethodContext *_localctx = _tracker.createInstance<SamplingMethodContext>(_ctx, getState());
  enterRule(_localctx, 948, MySQLParser::RuleSamplingMethod);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6939);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::SYSTEM_SYMBOL || _la == MySQLParser::BERNOULLI_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SamplingPercentageContext ------------------------------------------------------------------

MySQLParser::SamplingPercentageContext::SamplingPercentageContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UlonglongNumberContext* MySQLParser::SamplingPercentageContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

tree::TerminalNode* MySQLParser::SamplingPercentageContext::AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::SamplingPercentageContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::SamplingPercentageContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}


size_t MySQLParser::SamplingPercentageContext::getRuleIndex() const {
  return MySQLParser::RuleSamplingPercentage;
}

void MySQLParser::SamplingPercentageContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSamplingPercentage(this);
}

void MySQLParser::SamplingPercentageContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSamplingPercentage(this);
}


std::any MySQLParser::SamplingPercentageContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSamplingPercentage(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SamplingPercentageContext* MySQLParser::samplingPercentage() {
  SamplingPercentageContext *_localctx = _tracker.createInstance<SamplingPercentageContext>(_ctx, getState());
  enterRule(_localctx, 950, MySQLParser::RuleSamplingPercentage);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6945);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER:
      case MySQLParser::DECIMAL_NUMBER:
      case MySQLParser::FLOAT_NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(6941);
        ulonglongNumber();
        break;
      }

      case MySQLParser::AT_SIGN_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6942);
        match(MySQLParser::AT_SIGN_SYMBOL);
        setState(6943);
        textOrIdentifier();
        break;
      }

      case MySQLParser::PARAM_MARKER: {
        enterOuterAlt(_localctx, 3);
        setState(6944);
        match(MySQLParser::PARAM_MARKER);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablesampleClauseContext ------------------------------------------------------------------

MySQLParser::TablesampleClauseContext::TablesampleClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TablesampleClauseContext::TABLESAMPLE_SYMBOL() {
  return getToken(MySQLParser::TABLESAMPLE_SYMBOL, 0);
}

MySQLParser::SamplingMethodContext* MySQLParser::TablesampleClauseContext::samplingMethod() {
  return getRuleContext<MySQLParser::SamplingMethodContext>(0);
}

tree::TerminalNode* MySQLParser::TablesampleClauseContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::SamplingPercentageContext* MySQLParser::TablesampleClauseContext::samplingPercentage() {
  return getRuleContext<MySQLParser::SamplingPercentageContext>(0);
}

tree::TerminalNode* MySQLParser::TablesampleClauseContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::TablesampleClauseContext::getRuleIndex() const {
  return MySQLParser::RuleTablesampleClause;
}

void MySQLParser::TablesampleClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTablesampleClause(this);
}

void MySQLParser::TablesampleClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTablesampleClause(this);
}


std::any MySQLParser::TablesampleClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTablesampleClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TablesampleClauseContext* MySQLParser::tablesampleClause() {
  TablesampleClauseContext *_localctx = _tracker.createInstance<TablesampleClauseContext>(_ctx, getState());
  enterRule(_localctx, 952, MySQLParser::RuleTablesampleClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6947);

    if (!(serverVersion >= 80400)) throw FailedPredicateException(this, "serverVersion >= 80400");
    setState(6948);
    match(MySQLParser::TABLESAMPLE_SYMBOL);
    setState(6949);
    samplingMethod();
    setState(6950);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6951);
    samplingPercentage();
    setState(6952);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowingClauseContext ------------------------------------------------------------------

MySQLParser::WindowingClauseContext::WindowingClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WindowingClauseContext::OVER_SYMBOL() {
  return getToken(MySQLParser::OVER_SYMBOL, 0);
}

MySQLParser::WindowNameContext* MySQLParser::WindowingClauseContext::windowName() {
  return getRuleContext<MySQLParser::WindowNameContext>(0);
}

MySQLParser::WindowSpecContext* MySQLParser::WindowingClauseContext::windowSpec() {
  return getRuleContext<MySQLParser::WindowSpecContext>(0);
}


size_t MySQLParser::WindowingClauseContext::getRuleIndex() const {
  return MySQLParser::RuleWindowingClause;
}

void MySQLParser::WindowingClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowingClause(this);
}

void MySQLParser::WindowingClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowingClause(this);
}


std::any MySQLParser::WindowingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowingClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowingClauseContext* MySQLParser::windowingClause() {
  WindowingClauseContext *_localctx = _tracker.createInstance<WindowingClauseContext>(_ctx, getState());
  enterRule(_localctx, 954, MySQLParser::RuleWindowingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6954);
    match(MySQLParser::OVER_SYMBOL);
    setState(6957);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 828, _ctx)) {
    case 1: {
      setState(6955);
      windowName();
      break;
    }

    case 2: {
      setState(6956);
      windowSpec();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LeadLagInfoContext ------------------------------------------------------------------

MySQLParser::LeadLagInfoContext::LeadLagInfoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::LeadLagInfoContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::LeadLagInfoContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

MySQLParser::UlonglongNumberContext* MySQLParser::LeadLagInfoContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

tree::TerminalNode* MySQLParser::LeadLagInfoContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}

MySQLParser::StableIntegerContext* MySQLParser::LeadLagInfoContext::stableInteger() {
  return getRuleContext<MySQLParser::StableIntegerContext>(0);
}

MySQLParser::ExprContext* MySQLParser::LeadLagInfoContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::LeadLagInfoContext::getRuleIndex() const {
  return MySQLParser::RuleLeadLagInfo;
}

void MySQLParser::LeadLagInfoContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLeadLagInfo(this);
}

void MySQLParser::LeadLagInfoContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLeadLagInfo(this);
}


std::any MySQLParser::LeadLagInfoContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLeadLagInfo(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LeadLagInfoContext* MySQLParser::leadLagInfo() {
  LeadLagInfoContext *_localctx = _tracker.createInstance<LeadLagInfoContext>(_ctx, getState());
  enterRule(_localctx, 956, MySQLParser::RuleLeadLagInfo);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6959);
    match(MySQLParser::COMMA_SYMBOL);
    setState(6964);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 829, _ctx)) {
    case 1: {
      setState(6960);
      ulonglongNumber();
      break;
    }

    case 2: {
      setState(6961);
      match(MySQLParser::PARAM_MARKER);
      break;
    }

    case 3: {
      setState(6962);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(6963);
      stableInteger();
      break;
    }

    default:
      break;
    }
    setState(6968);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6966);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6967);
      expr(0);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StableIntegerContext ------------------------------------------------------------------

MySQLParser::StableIntegerContext::StableIntegerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::Int64LiteralContext* MySQLParser::StableIntegerContext::int64Literal() {
  return getRuleContext<MySQLParser::Int64LiteralContext>(0);
}

MySQLParser::ParamOrVarContext* MySQLParser::StableIntegerContext::paramOrVar() {
  return getRuleContext<MySQLParser::ParamOrVarContext>(0);
}


size_t MySQLParser::StableIntegerContext::getRuleIndex() const {
  return MySQLParser::RuleStableInteger;
}

void MySQLParser::StableIntegerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStableInteger(this);
}

void MySQLParser::StableIntegerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStableInteger(this);
}


std::any MySQLParser::StableIntegerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStableInteger(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StableIntegerContext* MySQLParser::stableInteger() {
  StableIntegerContext *_localctx = _tracker.createInstance<StableIntegerContext>(_ctx, getState());
  enterRule(_localctx, 958, MySQLParser::RuleStableInteger);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6972);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 831, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6970);
      int64Literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6971);
      paramOrVar();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParamOrVarContext ------------------------------------------------------------------

MySQLParser::ParamOrVarContext::ParamOrVarContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ParamOrVarContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 0);
}

MySQLParser::IdentifierContext* MySQLParser::ParamOrVarContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::UserVariableContext* MySQLParser::ParamOrVarContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}


size_t MySQLParser::ParamOrVarContext::getRuleIndex() const {
  return MySQLParser::RuleParamOrVar;
}

void MySQLParser::ParamOrVarContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterParamOrVar(this);
}

void MySQLParser::ParamOrVarContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitParamOrVar(this);
}


std::any MySQLParser::ParamOrVarContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitParamOrVar(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ParamOrVarContext* MySQLParser::paramOrVar() {
  ParamOrVarContext *_localctx = _tracker.createInstance<ParamOrVarContext>(_ctx, getState());
  enterRule(_localctx, 960, MySQLParser::RuleParamOrVar);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6977);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 832, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6974);
      match(MySQLParser::PARAM_MARKER);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6975);
      identifier();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6976);
      userVariable();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NullTreatmentContext ------------------------------------------------------------------

MySQLParser::NullTreatmentContext::NullTreatmentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NullTreatmentContext::NULLS_SYMBOL() {
  return getToken(MySQLParser::NULLS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NullTreatmentContext::RESPECT_SYMBOL() {
  return getToken(MySQLParser::RESPECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NullTreatmentContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}


size_t MySQLParser::NullTreatmentContext::getRuleIndex() const {
  return MySQLParser::RuleNullTreatment;
}

void MySQLParser::NullTreatmentContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNullTreatment(this);
}

void MySQLParser::NullTreatmentContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNullTreatment(this);
}


std::any MySQLParser::NullTreatmentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNullTreatment(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NullTreatmentContext* MySQLParser::nullTreatment() {
  NullTreatmentContext *_localctx = _tracker.createInstance<NullTreatmentContext>(_ctx, getState());
  enterRule(_localctx, 962, MySQLParser::RuleNullTreatment);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6979);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(6980);
    match(MySQLParser::NULLS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JsonFunctionContext ------------------------------------------------------------------

MySQLParser::JsonFunctionContext::JsonFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::JsonFunctionContext::JSON_ARRAYAGG_SYMBOL() {
  return getToken(MySQLParser::JSON_ARRAYAGG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::JsonFunctionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::InSumExprContext *> MySQLParser::JsonFunctionContext::inSumExpr() {
  return getRuleContexts<MySQLParser::InSumExprContext>();
}

MySQLParser::InSumExprContext* MySQLParser::JsonFunctionContext::inSumExpr(size_t i) {
  return getRuleContext<MySQLParser::InSumExprContext>(i);
}

tree::TerminalNode* MySQLParser::JsonFunctionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::WindowingClauseContext* MySQLParser::JsonFunctionContext::windowingClause() {
  return getRuleContext<MySQLParser::WindowingClauseContext>(0);
}

tree::TerminalNode* MySQLParser::JsonFunctionContext::JSON_OBJECTAGG_SYMBOL() {
  return getToken(MySQLParser::JSON_OBJECTAGG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::JsonFunctionContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}


size_t MySQLParser::JsonFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleJsonFunction;
}

void MySQLParser::JsonFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterJsonFunction(this);
}

void MySQLParser::JsonFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitJsonFunction(this);
}


std::any MySQLParser::JsonFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitJsonFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::JsonFunctionContext* MySQLParser::jsonFunction() {
  JsonFunctionContext *_localctx = _tracker.createInstance<JsonFunctionContext>(_ctx, getState());
  enterRule(_localctx, 964, MySQLParser::RuleJsonFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6998);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::JSON_ARRAYAGG_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6982);
        match(MySQLParser::JSON_ARRAYAGG_SYMBOL);
        setState(6983);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(6984);
        inSumExpr();
        setState(6985);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(6987);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 833, _ctx)) {
        case 1: {
          setState(6986);
          windowingClause();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::JSON_OBJECTAGG_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6989);
        match(MySQLParser::JSON_OBJECTAGG_SYMBOL);
        setState(6990);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(6991);
        inSumExpr();
        setState(6992);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6993);
        inSumExpr();
        setState(6994);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(6996);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 834, _ctx)) {
        case 1: {
          setState(6995);
          windowingClause();
          break;
        }

        default:
          break;
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InSumExprContext ------------------------------------------------------------------

MySQLParser::InSumExprContext::InSumExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::InSumExprContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::InSumExprContext::ALL_SYMBOL() {
  return getToken(MySQLParser::ALL_SYMBOL, 0);
}


size_t MySQLParser::InSumExprContext::getRuleIndex() const {
  return MySQLParser::RuleInSumExpr;
}

void MySQLParser::InSumExprContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInSumExpr(this);
}

void MySQLParser::InSumExprContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInSumExpr(this);
}


std::any MySQLParser::InSumExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInSumExpr(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InSumExprContext* MySQLParser::inSumExpr() {
  InSumExprContext *_localctx = _tracker.createInstance<InSumExprContext>(_ctx, getState());
  enterRule(_localctx, 966, MySQLParser::RuleInSumExpr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7001);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 836, _ctx)) {
    case 1: {
      setState(7000);
      match(MySQLParser::ALL_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(7003);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentListArgContext ------------------------------------------------------------------

MySQLParser::IdentListArgContext::IdentListArgContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentListContext* MySQLParser::IdentListArgContext::identList() {
  return getRuleContext<MySQLParser::IdentListContext>(0);
}

tree::TerminalNode* MySQLParser::IdentListArgContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentListArgContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::IdentListArgContext::getRuleIndex() const {
  return MySQLParser::RuleIdentListArg;
}

void MySQLParser::IdentListArgContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentListArg(this);
}

void MySQLParser::IdentListArgContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentListArg(this);
}


std::any MySQLParser::IdentListArgContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentListArg(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentListArgContext* MySQLParser::identListArg() {
  IdentListArgContext *_localctx = _tracker.createInstance<IdentListArgContext>(_ctx, getState());
  enterRule(_localctx, 968, MySQLParser::RuleIdentListArg);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7010);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 837, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7005);
      identList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7006);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7007);
      identList();
      setState(7008);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentListContext ------------------------------------------------------------------

MySQLParser::IdentListContext::IdentListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SimpleIdentifierContext *> MySQLParser::IdentListContext::simpleIdentifier() {
  return getRuleContexts<MySQLParser::SimpleIdentifierContext>();
}

MySQLParser::SimpleIdentifierContext* MySQLParser::IdentListContext::simpleIdentifier(size_t i) {
  return getRuleContext<MySQLParser::SimpleIdentifierContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::IdentListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::IdentListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::IdentListContext::getRuleIndex() const {
  return MySQLParser::RuleIdentList;
}

void MySQLParser::IdentListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentList(this);
}

void MySQLParser::IdentListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentList(this);
}


std::any MySQLParser::IdentListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentListContext* MySQLParser::identList() {
  IdentListContext *_localctx = _tracker.createInstance<IdentListContext>(_ctx, getState());
  enterRule(_localctx, 970, MySQLParser::RuleIdentList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7012);
    simpleIdentifier();
    setState(7017);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7013);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7014);
      simpleIdentifier();
      setState(7019);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FulltextOptionsContext ------------------------------------------------------------------

MySQLParser::FulltextOptionsContext::FulltextOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::BOOLEAN_SYMBOL() {
  return getToken(MySQLParser::BOOLEAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::MODE_SYMBOL() {
  return getToken(MySQLParser::MODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::NATURAL_SYMBOL() {
  return getToken(MySQLParser::NATURAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::LANGUAGE_SYMBOL() {
  return getToken(MySQLParser::LANGUAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextOptionsContext::EXPANSION_SYMBOL() {
  return getToken(MySQLParser::EXPANSION_SYMBOL, 0);
}


size_t MySQLParser::FulltextOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleFulltextOptions;
}

void MySQLParser::FulltextOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFulltextOptions(this);
}

void MySQLParser::FulltextOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFulltextOptions(this);
}


std::any MySQLParser::FulltextOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFulltextOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FulltextOptionsContext* MySQLParser::fulltextOptions() {
  FulltextOptionsContext *_localctx = _tracker.createInstance<FulltextOptionsContext>(_ctx, getState());
  enterRule(_localctx, 972, MySQLParser::RuleFulltextOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7035);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 840, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7020);
      match(MySQLParser::IN_SYMBOL);
      setState(7021);
      match(MySQLParser::BOOLEAN_SYMBOL);
      setState(7022);
      match(MySQLParser::MODE_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7023);
      match(MySQLParser::IN_SYMBOL);
      setState(7024);
      match(MySQLParser::NATURAL_SYMBOL);
      setState(7025);
      match(MySQLParser::LANGUAGE_SYMBOL);
      setState(7026);
      match(MySQLParser::MODE_SYMBOL);
      setState(7030);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(7027);
        match(MySQLParser::WITH_SYMBOL);
        setState(7028);
        match(MySQLParser::QUERY_SYMBOL);
        setState(7029);
        match(MySQLParser::EXPANSION_SYMBOL);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7032);
      match(MySQLParser::WITH_SYMBOL);
      setState(7033);
      match(MySQLParser::QUERY_SYMBOL);
      setState(7034);
      match(MySQLParser::EXPANSION_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RuntimeFunctionCallContext ------------------------------------------------------------------

MySQLParser::RuntimeFunctionCallContext::RuntimeFunctionCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::CHAR_SYMBOL() {
  return getToken(MySQLParser::CHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::RuntimeFunctionCallContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::CharsetNameContext* MySQLParser::RuntimeFunctionCallContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::CURRENT_USER_SYMBOL() {
  return getToken(MySQLParser::CURRENT_USER_SYMBOL, 0);
}

MySQLParser::ParenthesesContext* MySQLParser::RuntimeFunctionCallContext::parentheses() {
  return getRuleContext<MySQLParser::ParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::RuntimeFunctionCallContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::DAY_SYMBOL() {
  return getToken(MySQLParser::DAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::HOUR_SYMBOL() {
  return getToken(MySQLParser::HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::INSERT_SYMBOL() {
  return getToken(MySQLParser::INSERT_SYMBOL, 0);
}

std::vector<MySQLParser::ExprContext *> MySQLParser::RuntimeFunctionCallContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::RuntimeFunctionCallContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::RuntimeFunctionCallContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::JSON_VALUE_SYMBOL() {
  return getToken(MySQLParser::JSON_VALUE_SYMBOL, 0);
}

MySQLParser::SimpleExprContext* MySQLParser::RuntimeFunctionCallContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

MySQLParser::TextLiteralContext* MySQLParser::RuntimeFunctionCallContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::OnEmptyOrErrorContext* MySQLParser::RuntimeFunctionCallContext::onEmptyOrError() {
  return getRuleContext<MySQLParser::OnEmptyOrErrorContext>(0);
}

MySQLParser::ReturningTypeContext* MySQLParser::RuntimeFunctionCallContext::returningType() {
  return getRuleContext<MySQLParser::ReturningTypeContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::LEFT_SYMBOL() {
  return getToken(MySQLParser::LEFT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::MINUTE_SYMBOL() {
  return getToken(MySQLParser::MINUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::MONTH_SYMBOL() {
  return getToken(MySQLParser::MONTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::RIGHT_SYMBOL() {
  return getToken(MySQLParser::RIGHT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::SECOND_SYMBOL() {
  return getToken(MySQLParser::SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_SYMBOL, 0);
}

MySQLParser::TrimFunctionContext* MySQLParser::RuntimeFunctionCallContext::trimFunction() {
  return getRuleContext<MySQLParser::TrimFunctionContext>(0);
}

MySQLParser::UserFunctionContext* MySQLParser::RuntimeFunctionCallContext::userFunction() {
  return getRuleContext<MySQLParser::UserFunctionContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::VALUES_SYMBOL() {
  return getToken(MySQLParser::VALUES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::YEAR_SYMBOL() {
  return getToken(MySQLParser::YEAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::ADDDATE_SYMBOL() {
  return getToken(MySQLParser::ADDDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::SUBDATE_SYMBOL() {
  return getToken(MySQLParser::SUBDATE_SYMBOL, 0);
}

MySQLParser::IntervalContext* MySQLParser::RuntimeFunctionCallContext::interval() {
  return getRuleContext<MySQLParser::IntervalContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::CURDATE_SYMBOL() {
  return getToken(MySQLParser::CURDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::CURTIME_SYMBOL() {
  return getToken(MySQLParser::CURTIME_SYMBOL, 0);
}

MySQLParser::TimeFunctionParametersContext* MySQLParser::RuntimeFunctionCallContext::timeFunctionParameters() {
  return getRuleContext<MySQLParser::TimeFunctionParametersContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::DATE_ADD_SYMBOL() {
  return getToken(MySQLParser::DATE_ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::DATE_SUB_SYMBOL() {
  return getToken(MySQLParser::DATE_SUB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::EXTRACT_SYMBOL() {
  return getToken(MySQLParser::EXTRACT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::GET_FORMAT_SYMBOL() {
  return getToken(MySQLParser::GET_FORMAT_SYMBOL, 0);
}

MySQLParser::DateTimeTtypeContext* MySQLParser::RuntimeFunctionCallContext::dateTimeTtype() {
  return getRuleContext<MySQLParser::DateTimeTtypeContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::LOG_SYMBOL() {
  return getToken(MySQLParser::LOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::NOW_SYMBOL() {
  return getToken(MySQLParser::NOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::POSITION_SYMBOL() {
  return getToken(MySQLParser::POSITION_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::RuntimeFunctionCallContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

MySQLParser::SubstringFunctionContext* MySQLParser::RuntimeFunctionCallContext::substringFunction() {
  return getRuleContext<MySQLParser::SubstringFunctionContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::SYSDATE_SYMBOL() {
  return getToken(MySQLParser::SYSDATE_SYMBOL, 0);
}

MySQLParser::IntervalTimeStampContext* MySQLParser::RuntimeFunctionCallContext::intervalTimeStamp() {
  return getRuleContext<MySQLParser::IntervalTimeStampContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::TIMESTAMPADD_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMPADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::TIMESTAMPDIFF_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMPDIFF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::UTC_DATE_SYMBOL() {
  return getToken(MySQLParser::UTC_DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::UTC_TIME_SYMBOL() {
  return getToken(MySQLParser::UTC_TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::UTC_TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::UTC_TIMESTAMP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::ASCII_SYMBOL() {
  return getToken(MySQLParser::ASCII_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::CHARSET_SYMBOL() {
  return getToken(MySQLParser::CHARSET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::COALESCE_SYMBOL() {
  return getToken(MySQLParser::COALESCE_SYMBOL, 0);
}

MySQLParser::ExprListWithParenthesesContext* MySQLParser::RuntimeFunctionCallContext::exprListWithParentheses() {
  return getRuleContext<MySQLParser::ExprListWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::COLLATION_SYMBOL() {
  return getToken(MySQLParser::COLLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::DATABASE_SYMBOL() {
  return getToken(MySQLParser::DATABASE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::IF_SYMBOL() {
  return getToken(MySQLParser::IF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::MOD_SYMBOL() {
  return getToken(MySQLParser::MOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::QUARTER_SYMBOL() {
  return getToken(MySQLParser::QUARTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::REPEAT_SYMBOL() {
  return getToken(MySQLParser::REPEAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::REVERSE_SYMBOL() {
  return getToken(MySQLParser::REVERSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::ROW_COUNT_SYMBOL() {
  return getToken(MySQLParser::ROW_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::TRUNCATE_SYMBOL() {
  return getToken(MySQLParser::TRUNCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::WEEK_SYMBOL() {
  return getToken(MySQLParser::WEEK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::WEIGHT_STRING_SYMBOL() {
  return getToken(MySQLParser::WEIGHT_STRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

MySQLParser::WsNumCodepointsContext* MySQLParser::RuntimeFunctionCallContext::wsNumCodepoints() {
  return getRuleContext<MySQLParser::WsNumCodepointsContext>(0);
}

std::vector<MySQLParser::Ulong_numberContext *> MySQLParser::RuntimeFunctionCallContext::ulong_number() {
  return getRuleContexts<MySQLParser::Ulong_numberContext>();
}

MySQLParser::Ulong_numberContext* MySQLParser::RuntimeFunctionCallContext::ulong_number(size_t i) {
  return getRuleContext<MySQLParser::Ulong_numberContext>(i);
}

MySQLParser::WeightStringLevelsContext* MySQLParser::RuntimeFunctionCallContext::weightStringLevels() {
  return getRuleContext<MySQLParser::WeightStringLevelsContext>(0);
}

MySQLParser::GeometryFunctionContext* MySQLParser::RuntimeFunctionCallContext::geometryFunction() {
  return getRuleContext<MySQLParser::GeometryFunctionContext>(0);
}


size_t MySQLParser::RuntimeFunctionCallContext::getRuleIndex() const {
  return MySQLParser::RuleRuntimeFunctionCall;
}

void MySQLParser::RuntimeFunctionCallContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRuntimeFunctionCall(this);
}

void MySQLParser::RuntimeFunctionCallContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRuntimeFunctionCall(this);
}


std::any MySQLParser::RuntimeFunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRuntimeFunctionCall(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RuntimeFunctionCallContext* MySQLParser::runtimeFunctionCall() {
  RuntimeFunctionCallContext *_localctx = _tracker.createInstance<RuntimeFunctionCallContext>(_ctx, getState());
  enterRule(_localctx, 974, MySQLParser::RuleRuntimeFunctionCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7325);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 860, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7037);
      match(MySQLParser::CHAR_SYMBOL);
      setState(7038);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7039);
      exprList();
      setState(7042);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::USING_SYMBOL) {
        setState(7040);
        match(MySQLParser::USING_SYMBOL);
        setState(7041);
        charsetName();
      }
      setState(7044);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7046);
      match(MySQLParser::CURRENT_USER_SYMBOL);
      setState(7048);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 842, _ctx)) {
      case 1: {
        setState(7047);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7050);
      match(MySQLParser::DATE_SYMBOL);
      setState(7051);
      exprWithParentheses();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7052);
      match(MySQLParser::DAY_SYMBOL);
      setState(7053);
      exprWithParentheses();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7054);
      match(MySQLParser::HOUR_SYMBOL);
      setState(7055);
      exprWithParentheses();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(7056);
      match(MySQLParser::INSERT_SYMBOL);
      setState(7057);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7058);
      expr(0);
      setState(7059);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7060);
      expr(0);
      setState(7061);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7062);
      expr(0);
      setState(7063);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7064);
      expr(0);
      setState(7065);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7067);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(7068);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7069);
      expr(0);
      setState(7072); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(7070);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7071);
        expr(0);
        setState(7074); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == MySQLParser::COMMA_SYMBOL);
      setState(7076);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7078);

      if (!(serverVersion >= 80021)) throw FailedPredicateException(this, "serverVersion >= 80021");
      setState(7079);
      match(MySQLParser::JSON_VALUE_SYMBOL);
      setState(7080);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7081);
      simpleExpr(0);
      setState(7082);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7083);
      textLiteral();
      setState(7085);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::RETURNING_SYMBOL) {
        setState(7084);
        returningType();
      }
      setState(7087);
      onEmptyOrError();
      setState(7088);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(7090);
      match(MySQLParser::LEFT_SYMBOL);
      setState(7091);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7092);
      expr(0);
      setState(7093);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7094);
      expr(0);
      setState(7095);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(7097);
      match(MySQLParser::MINUTE_SYMBOL);
      setState(7098);
      exprWithParentheses();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(7099);
      match(MySQLParser::MONTH_SYMBOL);
      setState(7100);
      exprWithParentheses();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(7101);
      match(MySQLParser::RIGHT_SYMBOL);
      setState(7102);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7103);
      expr(0);
      setState(7104);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7105);
      expr(0);
      setState(7106);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(7108);
      match(MySQLParser::SECOND_SYMBOL);
      setState(7109);
      exprWithParentheses();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(7110);
      match(MySQLParser::TIME_SYMBOL);
      setState(7111);
      exprWithParentheses();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(7112);
      match(MySQLParser::TIMESTAMP_SYMBOL);
      setState(7113);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7114);
      expr(0);
      setState(7117);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7115);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7116);
        expr(0);
      }
      setState(7119);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(7121);
      trimFunction();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(7122);
      userFunction();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(7123);
      match(MySQLParser::VALUES_SYMBOL);
      setState(7124);
      exprWithParentheses();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(7125);
      match(MySQLParser::YEAR_SYMBOL);
      setState(7126);
      exprWithParentheses();
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(7127);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ADDDATE_SYMBOL || _la == MySQLParser::SUBDATE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(7128);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7129);
      expr(0);
      setState(7130);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7136);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 846, _ctx)) {
      case 1: {
        setState(7131);
        expr(0);
        break;
      }

      case 2: {
        setState(7132);
        match(MySQLParser::INTERVAL_SYMBOL);
        setState(7133);
        expr(0);
        setState(7134);
        interval();
        break;
      }

      default:
        break;
      }
      setState(7138);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(7140);
      match(MySQLParser::CURDATE_SYMBOL);
      setState(7142);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 847, _ctx)) {
      case 1: {
        setState(7141);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(7144);
      match(MySQLParser::CURTIME_SYMBOL);
      setState(7146);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 848, _ctx)) {
      case 1: {
        setState(7145);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(7148);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DATE_ADD_SYMBOL

      || _la == MySQLParser::DATE_SUB_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(7149);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7150);
      expr(0);
      setState(7151);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7152);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(7153);
      expr(0);
      setState(7154);
      interval();
      setState(7155);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(7157);
      match(MySQLParser::EXTRACT_SYMBOL);
      setState(7158);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7159);
      interval();
      setState(7160);
      match(MySQLParser::FROM_SYMBOL);
      setState(7161);
      expr(0);
      setState(7162);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(7164);
      match(MySQLParser::GET_FORMAT_SYMBOL);
      setState(7165);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7166);
      dateTimeTtype();
      setState(7167);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7168);
      expr(0);
      setState(7169);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(7171);

      if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
      setState(7172);
      match(MySQLParser::LOG_SYMBOL);
      setState(7173);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7174);
      expr(0);
      setState(7177);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7175);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7176);
        expr(0);
      }
      setState(7179);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(7181);
      match(MySQLParser::NOW_SYMBOL);
      setState(7183);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 850, _ctx)) {
      case 1: {
        setState(7182);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(7185);
      match(MySQLParser::POSITION_SYMBOL);
      setState(7186);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7187);
      bitExpr(0);
      setState(7188);
      match(MySQLParser::IN_SYMBOL);
      setState(7189);
      expr(0);
      setState(7190);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(7192);
      substringFunction();
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(7193);
      match(MySQLParser::SYSDATE_SYMBOL);
      setState(7195);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 851, _ctx)) {
      case 1: {
        setState(7194);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(7197);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::TIMESTAMPADD_SYMBOL

      || _la == MySQLParser::TIMESTAMPDIFF_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(7198);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7199);
      intervalTimeStamp();
      setState(7200);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7201);
      expr(0);
      setState(7202);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7203);
      expr(0);
      setState(7204);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(7206);
      match(MySQLParser::UTC_DATE_SYMBOL);
      setState(7208);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 852, _ctx)) {
      case 1: {
        setState(7207);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(7210);
      match(MySQLParser::UTC_TIME_SYMBOL);
      setState(7212);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 853, _ctx)) {
      case 1: {
        setState(7211);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(7214);
      match(MySQLParser::UTC_TIMESTAMP_SYMBOL);
      setState(7216);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 854, _ctx)) {
      case 1: {
        setState(7215);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(7218);
      match(MySQLParser::ASCII_SYMBOL);
      setState(7219);
      exprWithParentheses();
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(7220);
      match(MySQLParser::CHARSET_SYMBOL);
      setState(7221);
      exprWithParentheses();
      break;
    }

    case 37: {
      enterOuterAlt(_localctx, 37);
      setState(7222);
      match(MySQLParser::COALESCE_SYMBOL);
      setState(7223);
      exprListWithParentheses();
      break;
    }

    case 38: {
      enterOuterAlt(_localctx, 38);
      setState(7224);
      match(MySQLParser::COLLATION_SYMBOL);
      setState(7225);
      exprWithParentheses();
      break;
    }

    case 39: {
      enterOuterAlt(_localctx, 39);
      setState(7226);
      match(MySQLParser::DATABASE_SYMBOL);
      setState(7227);
      parentheses();
      break;
    }

    case 40: {
      enterOuterAlt(_localctx, 40);
      setState(7228);
      match(MySQLParser::IF_SYMBOL);
      setState(7229);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7230);
      expr(0);
      setState(7231);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7232);
      expr(0);
      setState(7233);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7234);
      expr(0);
      setState(7235);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 41: {
      enterOuterAlt(_localctx, 41);
      setState(7237);
      match(MySQLParser::FORMAT_SYMBOL);
      setState(7238);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7239);
      expr(0);
      setState(7240);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7241);
      expr(0);
      setState(7244);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7242);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7243);
        expr(0);
      }
      setState(7246);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 42: {
      enterOuterAlt(_localctx, 42);
      setState(7248);
      match(MySQLParser::MICROSECOND_SYMBOL);
      setState(7249);
      exprWithParentheses();
      break;
    }

    case 43: {
      enterOuterAlt(_localctx, 43);
      setState(7250);
      match(MySQLParser::MOD_SYMBOL);
      setState(7251);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7252);
      expr(0);
      setState(7253);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7254);
      expr(0);
      setState(7255);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 44: {
      enterOuterAlt(_localctx, 44);
      setState(7257);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(7258);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(7259);
      exprWithParentheses();
      break;
    }

    case 45: {
      enterOuterAlt(_localctx, 45);
      setState(7260);
      match(MySQLParser::QUARTER_SYMBOL);
      setState(7261);
      exprWithParentheses();
      break;
    }

    case 46: {
      enterOuterAlt(_localctx, 46);
      setState(7262);
      match(MySQLParser::REPEAT_SYMBOL);
      setState(7263);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7264);
      expr(0);
      setState(7265);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7266);
      expr(0);
      setState(7267);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 47: {
      enterOuterAlt(_localctx, 47);
      setState(7269);
      match(MySQLParser::REPLACE_SYMBOL);
      setState(7270);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7271);
      expr(0);
      setState(7272);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7273);
      expr(0);
      setState(7274);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7275);
      expr(0);
      setState(7276);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 48: {
      enterOuterAlt(_localctx, 48);
      setState(7278);
      match(MySQLParser::REVERSE_SYMBOL);
      setState(7279);
      exprWithParentheses();
      break;
    }

    case 49: {
      enterOuterAlt(_localctx, 49);
      setState(7280);
      match(MySQLParser::ROW_COUNT_SYMBOL);
      setState(7281);
      parentheses();
      break;
    }

    case 50: {
      enterOuterAlt(_localctx, 50);
      setState(7282);
      match(MySQLParser::TRUNCATE_SYMBOL);
      setState(7283);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7284);
      expr(0);
      setState(7285);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7286);
      expr(0);
      setState(7287);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 51: {
      enterOuterAlt(_localctx, 51);
      setState(7289);
      match(MySQLParser::WEEK_SYMBOL);
      setState(7290);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7291);
      expr(0);
      setState(7294);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7292);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7293);
        expr(0);
      }
      setState(7296);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 52: {
      enterOuterAlt(_localctx, 52);
      setState(7298);
      match(MySQLParser::WEIGHT_STRING_SYMBOL);
      setState(7299);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7300);
      expr(0);
      setState(7320);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 859, _ctx)) {
      case 1: {
        setState(7304);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 857, _ctx)) {
        case 1: {
          setState(7301);
          match(MySQLParser::AS_SYMBOL);
          setState(7302);
          match(MySQLParser::CHAR_SYMBOL);
          setState(7303);
          wsNumCodepoints();
          break;
        }

        default:
          break;
        }
        setState(7308);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 858, _ctx)) {
        case 1: {
          setState(7306);

          if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
          setState(7307);
          weightStringLevels();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(7310);
        match(MySQLParser::AS_SYMBOL);
        setState(7311);
        match(MySQLParser::BINARY_SYMBOL);
        setState(7312);
        wsNumCodepoints();
        break;
      }

      case 3: {
        setState(7313);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7314);
        ulong_number();
        setState(7315);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7316);
        ulong_number();
        setState(7317);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7318);
        ulong_number();
        break;
      }

      default:
        break;
      }
      setState(7322);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 53: {
      enterOuterAlt(_localctx, 53);
      setState(7324);
      geometryFunction();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReturningTypeContext ------------------------------------------------------------------

MySQLParser::ReturningTypeContext::ReturningTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReturningTypeContext::RETURNING_SYMBOL() {
  return getToken(MySQLParser::RETURNING_SYMBOL, 0);
}

MySQLParser::CastTypeContext* MySQLParser::ReturningTypeContext::castType() {
  return getRuleContext<MySQLParser::CastTypeContext>(0);
}


size_t MySQLParser::ReturningTypeContext::getRuleIndex() const {
  return MySQLParser::RuleReturningType;
}

void MySQLParser::ReturningTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReturningType(this);
}

void MySQLParser::ReturningTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReturningType(this);
}


std::any MySQLParser::ReturningTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReturningType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReturningTypeContext* MySQLParser::returningType() {
  ReturningTypeContext *_localctx = _tracker.createInstance<ReturningTypeContext>(_ctx, getState());
  enterRule(_localctx, 976, MySQLParser::RuleReturningType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7327);
    match(MySQLParser::RETURNING_SYMBOL);
    setState(7328);
    castType();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GeometryFunctionContext ------------------------------------------------------------------

MySQLParser::GeometryFunctionContext::GeometryFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::CONTAINS_SYMBOL() {
  return getToken(MySQLParser::CONTAINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::ExprContext *> MySQLParser::GeometryFunctionContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::GeometryFunctionContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::GEOMETRYCOLLECTION_SYMBOL() {
  return getToken(MySQLParser::GEOMETRYCOLLECTION_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::GeometryFunctionContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::LINESTRING_SYMBOL() {
  return getToken(MySQLParser::LINESTRING_SYMBOL, 0);
}

MySQLParser::ExprListWithParenthesesContext* MySQLParser::GeometryFunctionContext::exprListWithParentheses() {
  return getRuleContext<MySQLParser::ExprListWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::MULTILINESTRING_SYMBOL() {
  return getToken(MySQLParser::MULTILINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::MULTIPOINT_SYMBOL() {
  return getToken(MySQLParser::MULTIPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::MULTIPOLYGON_SYMBOL() {
  return getToken(MySQLParser::MULTIPOLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::POINT_SYMBOL() {
  return getToken(MySQLParser::POINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::POLYGON_SYMBOL() {
  return getToken(MySQLParser::POLYGON_SYMBOL, 0);
}


size_t MySQLParser::GeometryFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleGeometryFunction;
}

void MySQLParser::GeometryFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGeometryFunction(this);
}

void MySQLParser::GeometryFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGeometryFunction(this);
}


std::any MySQLParser::GeometryFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGeometryFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GeometryFunctionContext* MySQLParser::geometryFunction() {
  GeometryFunctionContext *_localctx = _tracker.createInstance<GeometryFunctionContext>(_ctx, getState());
  enterRule(_localctx, 978, MySQLParser::RuleGeometryFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7361);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 862, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7330);

      if (!(serverVersion < 50706)) throw FailedPredicateException(this, "serverVersion < 50706");
      setState(7331);
      match(MySQLParser::CONTAINS_SYMBOL);
      setState(7332);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7333);
      expr(0);
      setState(7334);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7335);
      expr(0);
      setState(7336);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7338);
      match(MySQLParser::GEOMETRYCOLLECTION_SYMBOL);
      setState(7339);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7341);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 861, _ctx)) {
      case 1: {
        setState(7340);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(7343);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7344);
      match(MySQLParser::LINESTRING_SYMBOL);
      setState(7345);
      exprListWithParentheses();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7346);
      match(MySQLParser::MULTILINESTRING_SYMBOL);
      setState(7347);
      exprListWithParentheses();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7348);
      match(MySQLParser::MULTIPOINT_SYMBOL);
      setState(7349);
      exprListWithParentheses();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(7350);
      match(MySQLParser::MULTIPOLYGON_SYMBOL);
      setState(7351);
      exprListWithParentheses();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7352);
      match(MySQLParser::POINT_SYMBOL);
      setState(7353);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7354);
      expr(0);
      setState(7355);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7356);
      expr(0);
      setState(7357);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7359);
      match(MySQLParser::POLYGON_SYMBOL);
      setState(7360);
      exprListWithParentheses();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TimeFunctionParametersContext ------------------------------------------------------------------

MySQLParser::TimeFunctionParametersContext::TimeFunctionParametersContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TimeFunctionParametersContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TimeFunctionParametersContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::FractionalPrecisionContext* MySQLParser::TimeFunctionParametersContext::fractionalPrecision() {
  return getRuleContext<MySQLParser::FractionalPrecisionContext>(0);
}


size_t MySQLParser::TimeFunctionParametersContext::getRuleIndex() const {
  return MySQLParser::RuleTimeFunctionParameters;
}

void MySQLParser::TimeFunctionParametersContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTimeFunctionParameters(this);
}

void MySQLParser::TimeFunctionParametersContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTimeFunctionParameters(this);
}


std::any MySQLParser::TimeFunctionParametersContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTimeFunctionParameters(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TimeFunctionParametersContext* MySQLParser::timeFunctionParameters() {
  TimeFunctionParametersContext *_localctx = _tracker.createInstance<TimeFunctionParametersContext>(_ctx, getState());
  enterRule(_localctx, 980, MySQLParser::RuleTimeFunctionParameters);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7363);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7365);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::INT_NUMBER) {
      setState(7364);
      fractionalPrecision();
    }
    setState(7367);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FractionalPrecisionContext ------------------------------------------------------------------

MySQLParser::FractionalPrecisionContext::FractionalPrecisionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FractionalPrecisionContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}


size_t MySQLParser::FractionalPrecisionContext::getRuleIndex() const {
  return MySQLParser::RuleFractionalPrecision;
}

void MySQLParser::FractionalPrecisionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFractionalPrecision(this);
}

void MySQLParser::FractionalPrecisionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFractionalPrecision(this);
}


std::any MySQLParser::FractionalPrecisionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFractionalPrecision(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FractionalPrecisionContext* MySQLParser::fractionalPrecision() {
  FractionalPrecisionContext *_localctx = _tracker.createInstance<FractionalPrecisionContext>(_ctx, getState());
  enterRule(_localctx, 982, MySQLParser::RuleFractionalPrecision);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7369);
    match(MySQLParser::INT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WeightStringLevelsContext ------------------------------------------------------------------

MySQLParser::WeightStringLevelsContext::WeightStringLevelsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WeightStringLevelsContext::LEVEL_SYMBOL() {
  return getToken(MySQLParser::LEVEL_SYMBOL, 0);
}

std::vector<MySQLParser::Real_ulong_numberContext *> MySQLParser::WeightStringLevelsContext::real_ulong_number() {
  return getRuleContexts<MySQLParser::Real_ulong_numberContext>();
}

MySQLParser::Real_ulong_numberContext* MySQLParser::WeightStringLevelsContext::real_ulong_number(size_t i) {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(i);
}

tree::TerminalNode* MySQLParser::WeightStringLevelsContext::MINUS_OPERATOR() {
  return getToken(MySQLParser::MINUS_OPERATOR, 0);
}

std::vector<MySQLParser::WeightStringLevelListItemContext *> MySQLParser::WeightStringLevelsContext::weightStringLevelListItem() {
  return getRuleContexts<MySQLParser::WeightStringLevelListItemContext>();
}

MySQLParser::WeightStringLevelListItemContext* MySQLParser::WeightStringLevelsContext::weightStringLevelListItem(size_t i) {
  return getRuleContext<MySQLParser::WeightStringLevelListItemContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::WeightStringLevelsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::WeightStringLevelsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::WeightStringLevelsContext::getRuleIndex() const {
  return MySQLParser::RuleWeightStringLevels;
}

void MySQLParser::WeightStringLevelsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWeightStringLevels(this);
}

void MySQLParser::WeightStringLevelsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWeightStringLevels(this);
}


std::any MySQLParser::WeightStringLevelsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWeightStringLevels(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WeightStringLevelsContext* MySQLParser::weightStringLevels() {
  WeightStringLevelsContext *_localctx = _tracker.createInstance<WeightStringLevelsContext>(_ctx, getState());
  enterRule(_localctx, 984, MySQLParser::RuleWeightStringLevels);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7371);
    match(MySQLParser::LEVEL_SYMBOL);
    setState(7384);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 865, _ctx)) {
    case 1: {
      setState(7372);
      real_ulong_number();
      setState(7373);
      match(MySQLParser::MINUS_OPERATOR);
      setState(7374);
      real_ulong_number();
      break;
    }

    case 2: {
      setState(7376);
      weightStringLevelListItem();
      setState(7381);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7377);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7378);
        weightStringLevelListItem();
        setState(7383);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WeightStringLevelListItemContext ------------------------------------------------------------------

MySQLParser::WeightStringLevelListItemContext::WeightStringLevelListItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::Real_ulong_numberContext* MySQLParser::WeightStringLevelListItemContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::WeightStringLevelListItemContext::REVERSE_SYMBOL() {
  return getToken(MySQLParser::REVERSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WeightStringLevelListItemContext::ASC_SYMBOL() {
  return getToken(MySQLParser::ASC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::WeightStringLevelListItemContext::DESC_SYMBOL() {
  return getToken(MySQLParser::DESC_SYMBOL, 0);
}


size_t MySQLParser::WeightStringLevelListItemContext::getRuleIndex() const {
  return MySQLParser::RuleWeightStringLevelListItem;
}

void MySQLParser::WeightStringLevelListItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWeightStringLevelListItem(this);
}

void MySQLParser::WeightStringLevelListItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWeightStringLevelListItem(this);
}


std::any MySQLParser::WeightStringLevelListItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWeightStringLevelListItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WeightStringLevelListItemContext* MySQLParser::weightStringLevelListItem() {
  WeightStringLevelListItemContext *_localctx = _tracker.createInstance<WeightStringLevelListItemContext>(_ctx, getState());
  enterRule(_localctx, 986, MySQLParser::RuleWeightStringLevelListItem);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7386);
    real_ulong_number();
    setState(7392);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ASC_SYMBOL:
      case MySQLParser::DESC_SYMBOL: {
        setState(7387);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(7389);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REVERSE_SYMBOL) {
          setState(7388);
          match(MySQLParser::REVERSE_SYMBOL);
        }
        break;
      }

      case MySQLParser::REVERSE_SYMBOL: {
        setState(7391);
        match(MySQLParser::REVERSE_SYMBOL);
        break;
      }

      case MySQLParser::COMMA_SYMBOL:
      case MySQLParser::CLOSE_PAR_SYMBOL: {
        break;
      }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DateTimeTtypeContext ------------------------------------------------------------------

MySQLParser::DateTimeTtypeContext::DateTimeTtypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DateTimeTtypeContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DateTimeTtypeContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DateTimeTtypeContext::DATETIME_SYMBOL() {
  return getToken(MySQLParser::DATETIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DateTimeTtypeContext::TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_SYMBOL, 0);
}


size_t MySQLParser::DateTimeTtypeContext::getRuleIndex() const {
  return MySQLParser::RuleDateTimeTtype;
}

void MySQLParser::DateTimeTtypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDateTimeTtype(this);
}

void MySQLParser::DateTimeTtypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDateTimeTtype(this);
}


std::any MySQLParser::DateTimeTtypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDateTimeTtype(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DateTimeTtypeContext* MySQLParser::dateTimeTtype() {
  DateTimeTtypeContext *_localctx = _tracker.createInstance<DateTimeTtypeContext>(_ctx, getState());
  enterRule(_localctx, 988, MySQLParser::RuleDateTimeTtype);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7394);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DATETIME_SYMBOL

    || _la == MySQLParser::DATE_SYMBOL || _la == MySQLParser::TIMESTAMP_SYMBOL

    || _la == MySQLParser::TIME_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TrimFunctionContext ------------------------------------------------------------------

MySQLParser::TrimFunctionContext::TrimFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::TRIM_SYMBOL() {
  return getToken(MySQLParser::TRIM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::ExprContext *> MySQLParser::TrimFunctionContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::TrimFunctionContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::LEADING_SYMBOL() {
  return getToken(MySQLParser::LEADING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::TRAILING_SYMBOL() {
  return getToken(MySQLParser::TRAILING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TrimFunctionContext::BOTH_SYMBOL() {
  return getToken(MySQLParser::BOTH_SYMBOL, 0);
}


size_t MySQLParser::TrimFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleTrimFunction;
}

void MySQLParser::TrimFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTrimFunction(this);
}

void MySQLParser::TrimFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTrimFunction(this);
}


std::any MySQLParser::TrimFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTrimFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TrimFunctionContext* MySQLParser::trimFunction() {
  TrimFunctionContext *_localctx = _tracker.createInstance<TrimFunctionContext>(_ctx, getState());
  enterRule(_localctx, 990, MySQLParser::RuleTrimFunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7396);
    match(MySQLParser::TRIM_SYMBOL);
    setState(7397);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7421);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 872, _ctx)) {
    case 1: {
      setState(7398);
      expr(0);
      setState(7401);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FROM_SYMBOL) {
        setState(7399);
        match(MySQLParser::FROM_SYMBOL);
        setState(7400);
        expr(0);
      }
      break;
    }

    case 2: {
      setState(7403);
      match(MySQLParser::LEADING_SYMBOL);
      setState(7405);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 869, _ctx)) {
      case 1: {
        setState(7404);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(7407);
      match(MySQLParser::FROM_SYMBOL);
      setState(7408);
      expr(0);
      break;
    }

    case 3: {
      setState(7409);
      match(MySQLParser::TRAILING_SYMBOL);
      setState(7411);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 870, _ctx)) {
      case 1: {
        setState(7410);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(7413);
      match(MySQLParser::FROM_SYMBOL);
      setState(7414);
      expr(0);
      break;
    }

    case 4: {
      setState(7415);
      match(MySQLParser::BOTH_SYMBOL);
      setState(7417);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 871, _ctx)) {
      case 1: {
        setState(7416);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(7419);
      match(MySQLParser::FROM_SYMBOL);
      setState(7420);
      expr(0);
      break;
    }

    default:
      break;
    }
    setState(7423);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SubstringFunctionContext ------------------------------------------------------------------

MySQLParser::SubstringFunctionContext::SubstringFunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SubstringFunctionContext::SUBSTRING_SYMBOL() {
  return getToken(MySQLParser::SUBSTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubstringFunctionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::ExprContext *> MySQLParser::SubstringFunctionContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::SubstringFunctionContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::SubstringFunctionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::SubstringFunctionContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::SubstringFunctionContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::SubstringFunctionContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubstringFunctionContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}


size_t MySQLParser::SubstringFunctionContext::getRuleIndex() const {
  return MySQLParser::RuleSubstringFunction;
}

void MySQLParser::SubstringFunctionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSubstringFunction(this);
}

void MySQLParser::SubstringFunctionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSubstringFunction(this);
}


std::any MySQLParser::SubstringFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSubstringFunction(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SubstringFunctionContext* MySQLParser::substringFunction() {
  SubstringFunctionContext *_localctx = _tracker.createInstance<SubstringFunctionContext>(_ctx, getState());
  enterRule(_localctx, 992, MySQLParser::RuleSubstringFunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7425);
    match(MySQLParser::SUBSTRING_SYMBOL);
    setState(7426);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7427);
    expr(0);
    setState(7440);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::COMMA_SYMBOL: {
        setState(7428);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7429);
        expr(0);
        setState(7432);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(7430);
          match(MySQLParser::COMMA_SYMBOL);
          setState(7431);
          expr(0);
        }
        break;
      }

      case MySQLParser::FROM_SYMBOL: {
        setState(7434);
        match(MySQLParser::FROM_SYMBOL);
        setState(7435);
        expr(0);
        setState(7438);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FOR_SYMBOL) {
          setState(7436);
          match(MySQLParser::FOR_SYMBOL);
          setState(7437);
          expr(0);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(7442);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionCallContext ------------------------------------------------------------------

MySQLParser::FunctionCallContext::FunctionCallContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PureIdentifierContext* MySQLParser::FunctionCallContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::FunctionCallContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FunctionCallContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::UdfExprListContext* MySQLParser::FunctionCallContext::udfExprList() {
  return getRuleContext<MySQLParser::UdfExprListContext>(0);
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::FunctionCallContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}

MySQLParser::ExprListContext* MySQLParser::FunctionCallContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}


size_t MySQLParser::FunctionCallContext::getRuleIndex() const {
  return MySQLParser::RuleFunctionCall;
}

void MySQLParser::FunctionCallContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFunctionCall(this);
}

void MySQLParser::FunctionCallContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFunctionCall(this);
}


std::any MySQLParser::FunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFunctionCall(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FunctionCallContext* MySQLParser::functionCall() {
  FunctionCallContext *_localctx = _tracker.createInstance<FunctionCallContext>(_ctx, getState());
  enterRule(_localctx, 994, MySQLParser::RuleFunctionCall);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7458);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 878, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7444);
      pureIdentifier();
      setState(7445);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7447);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 876, _ctx)) {
      case 1: {
        setState(7446);
        udfExprList();
        break;
      }

      default:
        break;
      }
      setState(7449);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7451);
      qualifiedIdentifier();
      setState(7452);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7454);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 877, _ctx)) {
      case 1: {
        setState(7453);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(7456);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UdfExprListContext ------------------------------------------------------------------

MySQLParser::UdfExprListContext::UdfExprListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::UdfExprContext *> MySQLParser::UdfExprListContext::udfExpr() {
  return getRuleContexts<MySQLParser::UdfExprContext>();
}

MySQLParser::UdfExprContext* MySQLParser::UdfExprListContext::udfExpr(size_t i) {
  return getRuleContext<MySQLParser::UdfExprContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::UdfExprListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::UdfExprListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::UdfExprListContext::getRuleIndex() const {
  return MySQLParser::RuleUdfExprList;
}

void MySQLParser::UdfExprListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUdfExprList(this);
}

void MySQLParser::UdfExprListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUdfExprList(this);
}


std::any MySQLParser::UdfExprListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUdfExprList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UdfExprListContext* MySQLParser::udfExprList() {
  UdfExprListContext *_localctx = _tracker.createInstance<UdfExprListContext>(_ctx, getState());
  enterRule(_localctx, 996, MySQLParser::RuleUdfExprList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7460);
    udfExpr();
    setState(7465);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7461);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7462);
      udfExpr();
      setState(7467);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UdfExprContext ------------------------------------------------------------------

MySQLParser::UdfExprContext::UdfExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::UdfExprContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::SelectAliasContext* MySQLParser::UdfExprContext::selectAlias() {
  return getRuleContext<MySQLParser::SelectAliasContext>(0);
}


size_t MySQLParser::UdfExprContext::getRuleIndex() const {
  return MySQLParser::RuleUdfExpr;
}

void MySQLParser::UdfExprContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUdfExpr(this);
}

void MySQLParser::UdfExprContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUdfExpr(this);
}


std::any MySQLParser::UdfExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUdfExpr(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UdfExprContext* MySQLParser::udfExpr() {
  UdfExprContext *_localctx = _tracker.createInstance<UdfExprContext>(_ctx, getState());
  enterRule(_localctx, 998, MySQLParser::RuleUdfExpr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7468);
    expr(0);
    setState(7470);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 880, _ctx)) {
    case 1: {
      setState(7469);
      selectAlias();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserVariableContext ------------------------------------------------------------------

MySQLParser::UserVariableContext::UserVariableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UserVariableContext::AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, 0);
}

MySQLParser::UserVariableIdentifierContext* MySQLParser::UserVariableContext::userVariableIdentifier() {
  return getRuleContext<MySQLParser::UserVariableIdentifierContext>(0);
}


size_t MySQLParser::UserVariableContext::getRuleIndex() const {
  return MySQLParser::RuleUserVariable;
}

void MySQLParser::UserVariableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserVariable(this);
}

void MySQLParser::UserVariableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserVariable(this);
}


std::any MySQLParser::UserVariableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserVariable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserVariableContext* MySQLParser::userVariable() {
  UserVariableContext *_localctx = _tracker.createInstance<UserVariableContext>(_ctx, getState());
  enterRule(_localctx, 1000, MySQLParser::RuleUserVariable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7472);
    match(MySQLParser::AT_SIGN_SYMBOL);
    setState(7473);
    userVariableIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserVariableIdentifierContext ------------------------------------------------------------------

MySQLParser::UserVariableIdentifierContext::UserVariableIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::UserVariableIdentifierContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::UserVariableIdentifierContext::SIMPLE_IDENTIFIER() {
  return getToken(MySQLParser::SIMPLE_IDENTIFIER, 0);
}


size_t MySQLParser::UserVariableIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleUserVariableIdentifier;
}

void MySQLParser::UserVariableIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserVariableIdentifier(this);
}

void MySQLParser::UserVariableIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserVariableIdentifier(this);
}


std::any MySQLParser::UserVariableIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserVariableIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserVariableIdentifierContext* MySQLParser::userVariableIdentifier() {
  UserVariableIdentifierContext *_localctx = _tracker.createInstance<UserVariableIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1002, MySQLParser::RuleUserVariableIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7477);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 881, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7475);
      textOrIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7476);
      match(MySQLParser::SIMPLE_IDENTIFIER);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InExpressionUserVariableAssignmentContext ------------------------------------------------------------------

MySQLParser::InExpressionUserVariableAssignmentContext::InExpressionUserVariableAssignmentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserVariableContext* MySQLParser::InExpressionUserVariableAssignmentContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

tree::TerminalNode* MySQLParser::InExpressionUserVariableAssignmentContext::ASSIGN_OPERATOR() {
  return getToken(MySQLParser::ASSIGN_OPERATOR, 0);
}

MySQLParser::ExprContext* MySQLParser::InExpressionUserVariableAssignmentContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::InExpressionUserVariableAssignmentContext::getRuleIndex() const {
  return MySQLParser::RuleInExpressionUserVariableAssignment;
}

void MySQLParser::InExpressionUserVariableAssignmentContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInExpressionUserVariableAssignment(this);
}

void MySQLParser::InExpressionUserVariableAssignmentContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInExpressionUserVariableAssignment(this);
}


std::any MySQLParser::InExpressionUserVariableAssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInExpressionUserVariableAssignment(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InExpressionUserVariableAssignmentContext* MySQLParser::inExpressionUserVariableAssignment() {
  InExpressionUserVariableAssignmentContext *_localctx = _tracker.createInstance<InExpressionUserVariableAssignmentContext>(_ctx, getState());
  enterRule(_localctx, 1004, MySQLParser::RuleInExpressionUserVariableAssignment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7479);
    userVariable();
    setState(7480);
    match(MySQLParser::ASSIGN_OPERATOR);
    setState(7481);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RvalueSystemOrUserVariableContext ------------------------------------------------------------------

MySQLParser::RvalueSystemOrUserVariableContext::RvalueSystemOrUserVariableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserVariableContext* MySQLParser::RvalueSystemOrUserVariableContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

std::vector<tree::TerminalNode *> MySQLParser::RvalueSystemOrUserVariableContext::AT_SIGN_SYMBOL() {
  return getTokens(MySQLParser::AT_SIGN_SYMBOL);
}

tree::TerminalNode* MySQLParser::RvalueSystemOrUserVariableContext::AT_SIGN_SYMBOL(size_t i) {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, i);
}

MySQLParser::RvalueSystemVariableContext* MySQLParser::RvalueSystemOrUserVariableContext::rvalueSystemVariable() {
  return getRuleContext<MySQLParser::RvalueSystemVariableContext>(0);
}

MySQLParser::RvalueSystemVariableTypeContext* MySQLParser::RvalueSystemOrUserVariableContext::rvalueSystemVariableType() {
  return getRuleContext<MySQLParser::RvalueSystemVariableTypeContext>(0);
}


size_t MySQLParser::RvalueSystemOrUserVariableContext::getRuleIndex() const {
  return MySQLParser::RuleRvalueSystemOrUserVariable;
}

void MySQLParser::RvalueSystemOrUserVariableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRvalueSystemOrUserVariable(this);
}

void MySQLParser::RvalueSystemOrUserVariableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRvalueSystemOrUserVariable(this);
}


std::any MySQLParser::RvalueSystemOrUserVariableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRvalueSystemOrUserVariable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RvalueSystemOrUserVariableContext* MySQLParser::rvalueSystemOrUserVariable() {
  RvalueSystemOrUserVariableContext *_localctx = _tracker.createInstance<RvalueSystemOrUserVariableContext>(_ctx, getState());
  enterRule(_localctx, 1006, MySQLParser::RuleRvalueSystemOrUserVariable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7490);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 883, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7483);
      userVariable();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7484);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(7485);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(7487);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 882, _ctx)) {
      case 1: {
        setState(7486);
        rvalueSystemVariableType();
        break;
      }

      default:
        break;
      }
      setState(7489);
      rvalueSystemVariable();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LvalueVariableContext ------------------------------------------------------------------

MySQLParser::LvalueVariableContext::LvalueVariableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::LvalueVariableContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::LValueIdentifierContext* MySQLParser::LvalueVariableContext::lValueIdentifier() {
  return getRuleContext<MySQLParser::LValueIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::LvalueVariableContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::LvalueVariableContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}


size_t MySQLParser::LvalueVariableContext::getRuleIndex() const {
  return MySQLParser::RuleLvalueVariable;
}

void MySQLParser::LvalueVariableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLvalueVariable(this);
}

void MySQLParser::LvalueVariableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLvalueVariable(this);
}


std::any MySQLParser::LvalueVariableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLvalueVariable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LvalueVariableContext* MySQLParser::lvalueVariable() {
  LvalueVariableContext *_localctx = _tracker.createInstance<LvalueVariableContext>(_ctx, getState());
  enterRule(_localctx, 1008, MySQLParser::RuleLvalueVariable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7505);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 887, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7501);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 886, _ctx)) {
      case 1: {
        setState(7492);
        identifier();
        setState(7494);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::DOT_SYMBOL) {
          setState(7493);
          dotIdentifier();
        }
        break;
      }

      case 2: {
        setState(7496);

        if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
        setState(7497);
        lValueIdentifier();
        setState(7499);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::DOT_SYMBOL) {
          setState(7498);
          dotIdentifier();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7503);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(7504);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RvalueSystemVariableContext ------------------------------------------------------------------

MySQLParser::RvalueSystemVariableContext::RvalueSystemVariableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::RvalueSystemVariableContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::RvalueSystemVariableContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::RvalueSystemVariableContext::getRuleIndex() const {
  return MySQLParser::RuleRvalueSystemVariable;
}

void MySQLParser::RvalueSystemVariableContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRvalueSystemVariable(this);
}

void MySQLParser::RvalueSystemVariableContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRvalueSystemVariable(this);
}


std::any MySQLParser::RvalueSystemVariableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRvalueSystemVariable(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RvalueSystemVariableContext* MySQLParser::rvalueSystemVariable() {
  RvalueSystemVariableContext *_localctx = _tracker.createInstance<RvalueSystemVariableContext>(_ctx, getState());
  enterRule(_localctx, 1010, MySQLParser::RuleRvalueSystemVariable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7507);
    textOrIdentifier();
    setState(7509);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 888, _ctx)) {
    case 1: {
      setState(7508);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WhenExpressionContext ------------------------------------------------------------------

MySQLParser::WhenExpressionContext::WhenExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WhenExpressionContext::WHEN_SYMBOL() {
  return getToken(MySQLParser::WHEN_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::WhenExpressionContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::WhenExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleWhenExpression;
}

void MySQLParser::WhenExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWhenExpression(this);
}

void MySQLParser::WhenExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWhenExpression(this);
}


std::any MySQLParser::WhenExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWhenExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WhenExpressionContext* MySQLParser::whenExpression() {
  WhenExpressionContext *_localctx = _tracker.createInstance<WhenExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1012, MySQLParser::RuleWhenExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7511);
    match(MySQLParser::WHEN_SYMBOL);
    setState(7512);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ThenExpressionContext ------------------------------------------------------------------

MySQLParser::ThenExpressionContext::ThenExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ThenExpressionContext::THEN_SYMBOL() {
  return getToken(MySQLParser::THEN_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::ThenExpressionContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::ThenExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleThenExpression;
}

void MySQLParser::ThenExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterThenExpression(this);
}

void MySQLParser::ThenExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitThenExpression(this);
}


std::any MySQLParser::ThenExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitThenExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ThenExpressionContext* MySQLParser::thenExpression() {
  ThenExpressionContext *_localctx = _tracker.createInstance<ThenExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1014, MySQLParser::RuleThenExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7514);
    match(MySQLParser::THEN_SYMBOL);
    setState(7515);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElseExpressionContext ------------------------------------------------------------------

MySQLParser::ElseExpressionContext::ElseExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ElseExpressionContext::ELSE_SYMBOL() {
  return getToken(MySQLParser::ELSE_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::ElseExpressionContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::ElseExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleElseExpression;
}

void MySQLParser::ElseExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterElseExpression(this);
}

void MySQLParser::ElseExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitElseExpression(this);
}


std::any MySQLParser::ElseExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitElseExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ElseExpressionContext* MySQLParser::elseExpression() {
  ElseExpressionContext *_localctx = _tracker.createInstance<ElseExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1016, MySQLParser::RuleElseExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7517);
    match(MySQLParser::ELSE_SYMBOL);
    setState(7518);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CastTypeContext ------------------------------------------------------------------

MySQLParser::CastTypeContext::CastTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CastTypeContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

MySQLParser::FieldLengthContext* MySQLParser::CastTypeContext::fieldLength() {
  return getRuleContext<MySQLParser::FieldLengthContext>(0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::CHAR_SYMBOL() {
  return getToken(MySQLParser::CHAR_SYMBOL, 0);
}

MySQLParser::CharsetWithOptBinaryContext* MySQLParser::CastTypeContext::charsetWithOptBinary() {
  return getRuleContext<MySQLParser::CharsetWithOptBinaryContext>(0);
}

MySQLParser::NcharContext* MySQLParser::CastTypeContext::nchar() {
  return getRuleContext<MySQLParser::NcharContext>(0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::SIGNED_SYMBOL() {
  return getToken(MySQLParser::SIGNED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::INT_SYMBOL() {
  return getToken(MySQLParser::INT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::UNSIGNED_SYMBOL() {
  return getToken(MySQLParser::UNSIGNED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::YEAR_SYMBOL() {
  return getToken(MySQLParser::YEAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

MySQLParser::TypeDatetimePrecisionContext* MySQLParser::CastTypeContext::typeDatetimePrecision() {
  return getRuleContext<MySQLParser::TypeDatetimePrecisionContext>(0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::DATETIME_SYMBOL() {
  return getToken(MySQLParser::DATETIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::DECIMAL_SYMBOL() {
  return getToken(MySQLParser::DECIMAL_SYMBOL, 0);
}

MySQLParser::FloatOptionsContext* MySQLParser::CastTypeContext::floatOptions() {
  return getRuleContext<MySQLParser::FloatOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::JSON_SYMBOL() {
  return getToken(MySQLParser::JSON_SYMBOL, 0);
}

MySQLParser::RealTypeContext* MySQLParser::CastTypeContext::realType() {
  return getRuleContext<MySQLParser::RealTypeContext>(0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::FLOAT_SYMBOL() {
  return getToken(MySQLParser::FLOAT_SYMBOL, 0);
}

MySQLParser::StandardFloatOptionsContext* MySQLParser::CastTypeContext::standardFloatOptions() {
  return getRuleContext<MySQLParser::StandardFloatOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::POINT_SYMBOL() {
  return getToken(MySQLParser::POINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::LINESTRING_SYMBOL() {
  return getToken(MySQLParser::LINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::POLYGON_SYMBOL() {
  return getToken(MySQLParser::POLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::MULTIPOINT_SYMBOL() {
  return getToken(MySQLParser::MULTIPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::MULTILINESTRING_SYMBOL() {
  return getToken(MySQLParser::MULTILINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::MULTIPOLYGON_SYMBOL() {
  return getToken(MySQLParser::MULTIPOLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CastTypeContext::GEOMETRYCOLLECTION_SYMBOL() {
  return getToken(MySQLParser::GEOMETRYCOLLECTION_SYMBOL, 0);
}


size_t MySQLParser::CastTypeContext::getRuleIndex() const {
  return MySQLParser::RuleCastType;
}

void MySQLParser::CastTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCastType(this);
}

void MySQLParser::CastTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCastType(this);
}


std::any MySQLParser::CastTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCastType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CastTypeContext* MySQLParser::castType() {
  CastTypeContext *_localctx = _tracker.createInstance<CastTypeContext>(_ctx, getState());
  enterRule(_localctx, 1018, MySQLParser::RuleCastType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7569);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 899, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7520);
      match(MySQLParser::BINARY_SYMBOL);
      setState(7522);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 889, _ctx)) {
      case 1: {
        setState(7521);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7524);
      match(MySQLParser::CHAR_SYMBOL);
      setState(7526);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 890, _ctx)) {
      case 1: {
        setState(7525);
        fieldLength();
        break;
      }

      default:
        break;
      }
      setState(7529);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 891, _ctx)) {
      case 1: {
        setState(7528);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7531);
      nchar();
      setState(7533);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 892, _ctx)) {
      case 1: {
        setState(7532);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7535);
      match(MySQLParser::SIGNED_SYMBOL);
      setState(7537);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 893, _ctx)) {
      case 1: {
        setState(7536);
        match(MySQLParser::INT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7539);
      match(MySQLParser::UNSIGNED_SYMBOL);
      setState(7541);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 894, _ctx)) {
      case 1: {
        setState(7540);
        match(MySQLParser::INT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(7543);
      match(MySQLParser::DATE_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7544);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(7545);
      match(MySQLParser::YEAR_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7546);
      match(MySQLParser::TIME_SYMBOL);
      setState(7548);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 895, _ctx)) {
      case 1: {
        setState(7547);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(7550);
      match(MySQLParser::DATETIME_SYMBOL);
      setState(7552);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 896, _ctx)) {
      case 1: {
        setState(7551);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(7554);
      match(MySQLParser::DECIMAL_SYMBOL);
      setState(7556);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 897, _ctx)) {
      case 1: {
        setState(7555);
        floatOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(7558);

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(7559);
      match(MySQLParser::JSON_SYMBOL);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(7560);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(7561);
      realType();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(7562);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(7563);
      match(MySQLParser::FLOAT_SYMBOL);
      setState(7565);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 898, _ctx)) {
      case 1: {
        setState(7564);
        standardFloatOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(7567);

      if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
      setState(7568);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::GEOMETRYCOLLECTION_SYMBOL || _la == MySQLParser::LINESTRING_SYMBOL || ((((_la - 382) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 382)) & ((1ULL << (MySQLParser::MULTILINESTRING_SYMBOL - 382))
        | (1ULL << (MySQLParser::MULTIPOINT_SYMBOL - 382))
        | (1ULL << (MySQLParser::MULTIPOLYGON_SYMBOL - 382))
        | (1ULL << (MySQLParser::POINT_SYMBOL - 382))
        | (1ULL << (MySQLParser::POLYGON_SYMBOL - 382)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExprListContext ------------------------------------------------------------------

MySQLParser::ExprListContext::ExprListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::ExprContext *> MySQLParser::ExprListContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::ExprListContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ExprListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ExprListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ExprListContext::getRuleIndex() const {
  return MySQLParser::RuleExprList;
}

void MySQLParser::ExprListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprList(this);
}

void MySQLParser::ExprListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprList(this);
}


std::any MySQLParser::ExprListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExprListContext* MySQLParser::exprList() {
  ExprListContext *_localctx = _tracker.createInstance<ExprListContext>(_ctx, getState());
  enterRule(_localctx, 1020, MySQLParser::RuleExprList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7571);
    expr(0);
    setState(7576);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7572);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7573);
      expr(0);
      setState(7578);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CharsetContext ------------------------------------------------------------------

MySQLParser::CharsetContext::CharsetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CharsetContext::CHAR_SYMBOL() {
  return getToken(MySQLParser::CHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CharsetContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CharsetContext::CHARSET_SYMBOL() {
  return getToken(MySQLParser::CHARSET_SYMBOL, 0);
}


size_t MySQLParser::CharsetContext::getRuleIndex() const {
  return MySQLParser::RuleCharset;
}

void MySQLParser::CharsetContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCharset(this);
}

void MySQLParser::CharsetContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCharset(this);
}


std::any MySQLParser::CharsetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCharset(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CharsetContext* MySQLParser::charset() {
  CharsetContext *_localctx = _tracker.createInstance<CharsetContext>(_ctx, getState());
  enterRule(_localctx, 1022, MySQLParser::RuleCharset);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7582);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CHAR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7579);
        match(MySQLParser::CHAR_SYMBOL);
        setState(7580);
        match(MySQLParser::SET_SYMBOL);
        break;
      }

      case MySQLParser::CHARSET_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7581);
        match(MySQLParser::CHARSET_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NotRuleContext ------------------------------------------------------------------

MySQLParser::NotRuleContext::NotRuleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NotRuleContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NotRuleContext::NOT2_SYMBOL() {
  return getToken(MySQLParser::NOT2_SYMBOL, 0);
}


size_t MySQLParser::NotRuleContext::getRuleIndex() const {
  return MySQLParser::RuleNotRule;
}

void MySQLParser::NotRuleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNotRule(this);
}

void MySQLParser::NotRuleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNotRule(this);
}


std::any MySQLParser::NotRuleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNotRule(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NotRuleContext* MySQLParser::notRule() {
  NotRuleContext *_localctx = _tracker.createInstance<NotRuleContext>(_ctx, getState());
  enterRule(_localctx, 1024, MySQLParser::RuleNotRule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7584);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NOT2_SYMBOL || _la == MySQLParser::NOT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Not2RuleContext ------------------------------------------------------------------

MySQLParser::Not2RuleContext::Not2RuleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::Not2RuleContext::LOGICAL_NOT_OPERATOR() {
  return getToken(MySQLParser::LOGICAL_NOT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::Not2RuleContext::NOT2_SYMBOL() {
  return getToken(MySQLParser::NOT2_SYMBOL, 0);
}


size_t MySQLParser::Not2RuleContext::getRuleIndex() const {
  return MySQLParser::RuleNot2Rule;
}

void MySQLParser::Not2RuleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNot2Rule(this);
}

void MySQLParser::Not2RuleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNot2Rule(this);
}


std::any MySQLParser::Not2RuleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNot2Rule(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::Not2RuleContext* MySQLParser::not2Rule() {
  Not2RuleContext *_localctx = _tracker.createInstance<Not2RuleContext>(_ctx, getState());
  enterRule(_localctx, 1026, MySQLParser::RuleNot2Rule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7586);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NOT2_SYMBOL

    || _la == MySQLParser::LOGICAL_NOT_OPERATOR)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IntervalContext ------------------------------------------------------------------

MySQLParser::IntervalContext::IntervalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IntervalTimeStampContext* MySQLParser::IntervalContext::intervalTimeStamp() {
  return getRuleContext<MySQLParser::IntervalTimeStampContext>(0);
}

tree::TerminalNode* MySQLParser::IntervalContext::SECOND_MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::SECOND_MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::MINUTE_MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::MINUTE_MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::MINUTE_SECOND_SYMBOL() {
  return getToken(MySQLParser::MINUTE_SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::HOUR_MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::HOUR_MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::HOUR_SECOND_SYMBOL() {
  return getToken(MySQLParser::HOUR_SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::HOUR_MINUTE_SYMBOL() {
  return getToken(MySQLParser::HOUR_MINUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::DAY_MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::DAY_MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::DAY_SECOND_SYMBOL() {
  return getToken(MySQLParser::DAY_SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::DAY_MINUTE_SYMBOL() {
  return getToken(MySQLParser::DAY_MINUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::DAY_HOUR_SYMBOL() {
  return getToken(MySQLParser::DAY_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalContext::YEAR_MONTH_SYMBOL() {
  return getToken(MySQLParser::YEAR_MONTH_SYMBOL, 0);
}


size_t MySQLParser::IntervalContext::getRuleIndex() const {
  return MySQLParser::RuleInterval;
}

void MySQLParser::IntervalContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInterval(this);
}

void MySQLParser::IntervalContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInterval(this);
}


std::any MySQLParser::IntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInterval(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IntervalContext* MySQLParser::interval() {
  IntervalContext *_localctx = _tracker.createInstance<IntervalContext>(_ctx, getState());
  enterRule(_localctx, 1028, MySQLParser::RuleInterval);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7590);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::DAY_SYMBOL:
      case MySQLParser::HOUR_SYMBOL:
      case MySQLParser::MICROSECOND_SYMBOL:
      case MySQLParser::MINUTE_SYMBOL:
      case MySQLParser::MONTH_SYMBOL:
      case MySQLParser::QUARTER_SYMBOL:
      case MySQLParser::SECOND_SYMBOL:
      case MySQLParser::WEEK_SYMBOL:
      case MySQLParser::YEAR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7588);
        intervalTimeStamp();
        break;
      }

      case MySQLParser::DAY_HOUR_SYMBOL:
      case MySQLParser::DAY_MICROSECOND_SYMBOL:
      case MySQLParser::DAY_MINUTE_SYMBOL:
      case MySQLParser::DAY_SECOND_SYMBOL:
      case MySQLParser::HOUR_MICROSECOND_SYMBOL:
      case MySQLParser::HOUR_MINUTE_SYMBOL:
      case MySQLParser::HOUR_SECOND_SYMBOL:
      case MySQLParser::MINUTE_MICROSECOND_SYMBOL:
      case MySQLParser::MINUTE_SECOND_SYMBOL:
      case MySQLParser::SECOND_MICROSECOND_SYMBOL:
      case MySQLParser::YEAR_MONTH_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7589);
        _la = _input->LA(1);
        if (!(((((_la - 159) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 159)) & ((1ULL << (MySQLParser::DAY_HOUR_SYMBOL - 159))
          | (1ULL << (MySQLParser::DAY_MICROSECOND_SYMBOL - 159))
          | (1ULL << (MySQLParser::DAY_MINUTE_SYMBOL - 159))
          | (1ULL << (MySQLParser::DAY_SECOND_SYMBOL - 159)))) != 0) || ((((_la - 262) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 262)) & ((1ULL << (MySQLParser::HOUR_MICROSECOND_SYMBOL - 262))
          | (1ULL << (MySQLParser::HOUR_MINUTE_SYMBOL - 262))
          | (1ULL << (MySQLParser::HOUR_SECOND_SYMBOL - 262)))) != 0) || _la == MySQLParser::MINUTE_MICROSECOND_SYMBOL

        || _la == MySQLParser::MINUTE_SECOND_SYMBOL || _la == MySQLParser::SECOND_MICROSECOND_SYMBOL || _la == MySQLParser::YEAR_MONTH_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IntervalTimeStampContext ------------------------------------------------------------------

MySQLParser::IntervalTimeStampContext::IntervalTimeStampContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::SECOND_SYMBOL() {
  return getToken(MySQLParser::SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::MINUTE_SYMBOL() {
  return getToken(MySQLParser::MINUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::HOUR_SYMBOL() {
  return getToken(MySQLParser::HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::DAY_SYMBOL() {
  return getToken(MySQLParser::DAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::WEEK_SYMBOL() {
  return getToken(MySQLParser::WEEK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::MONTH_SYMBOL() {
  return getToken(MySQLParser::MONTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::QUARTER_SYMBOL() {
  return getToken(MySQLParser::QUARTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IntervalTimeStampContext::YEAR_SYMBOL() {
  return getToken(MySQLParser::YEAR_SYMBOL, 0);
}


size_t MySQLParser::IntervalTimeStampContext::getRuleIndex() const {
  return MySQLParser::RuleIntervalTimeStamp;
}

void MySQLParser::IntervalTimeStampContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIntervalTimeStamp(this);
}

void MySQLParser::IntervalTimeStampContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIntervalTimeStamp(this);
}


std::any MySQLParser::IntervalTimeStampContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIntervalTimeStamp(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IntervalTimeStampContext* MySQLParser::intervalTimeStamp() {
  IntervalTimeStampContext *_localctx = _tracker.createInstance<IntervalTimeStampContext>(_ctx, getState());
  enterRule(_localctx, 1030, MySQLParser::RuleIntervalTimeStamp);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7592);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DAY_SYMBOL || _la == MySQLParser::HOUR_SYMBOL || ((((_la - 369) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 369)) & ((1ULL << (MySQLParser::MICROSECOND_SYMBOL - 369))
      | (1ULL << (MySQLParser::MINUTE_SYMBOL - 369))
      | (1ULL << (MySQLParser::MONTH_SYMBOL - 369)))) != 0) || _la == MySQLParser::QUARTER_SYMBOL

    || _la == MySQLParser::SECOND_SYMBOL || _la == MySQLParser::WEEK_SYMBOL

    || _la == MySQLParser::YEAR_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExprListWithParenthesesContext ------------------------------------------------------------------

MySQLParser::ExprListWithParenthesesContext::ExprListWithParenthesesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExprListWithParenthesesContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::ExprListWithParenthesesContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

tree::TerminalNode* MySQLParser::ExprListWithParenthesesContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::ExprListWithParenthesesContext::getRuleIndex() const {
  return MySQLParser::RuleExprListWithParentheses;
}

void MySQLParser::ExprListWithParenthesesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprListWithParentheses(this);
}

void MySQLParser::ExprListWithParenthesesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprListWithParentheses(this);
}


std::any MySQLParser::ExprListWithParenthesesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprListWithParentheses(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExprListWithParenthesesContext* MySQLParser::exprListWithParentheses() {
  ExprListWithParenthesesContext *_localctx = _tracker.createInstance<ExprListWithParenthesesContext>(_ctx, getState());
  enterRule(_localctx, 1032, MySQLParser::RuleExprListWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7594);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7595);
    exprList();
    setState(7596);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExprWithParenthesesContext ------------------------------------------------------------------

MySQLParser::ExprWithParenthesesContext::ExprWithParenthesesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ExprWithParenthesesContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::ExprWithParenthesesContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::ExprWithParenthesesContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::ExprWithParenthesesContext::getRuleIndex() const {
  return MySQLParser::RuleExprWithParentheses;
}

void MySQLParser::ExprWithParenthesesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterExprWithParentheses(this);
}

void MySQLParser::ExprWithParenthesesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitExprWithParentheses(this);
}


std::any MySQLParser::ExprWithParenthesesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitExprWithParentheses(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::exprWithParentheses() {
  ExprWithParenthesesContext *_localctx = _tracker.createInstance<ExprWithParenthesesContext>(_ctx, getState());
  enterRule(_localctx, 1034, MySQLParser::RuleExprWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7598);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7599);
    expr(0);
    setState(7600);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleExprWithParenthesesContext ------------------------------------------------------------------

MySQLParser::SimpleExprWithParenthesesContext::SimpleExprWithParenthesesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SimpleExprWithParenthesesContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::SimpleExprContext* MySQLParser::SimpleExprWithParenthesesContext::simpleExpr() {
  return getRuleContext<MySQLParser::SimpleExprContext>(0);
}

tree::TerminalNode* MySQLParser::SimpleExprWithParenthesesContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::SimpleExprWithParenthesesContext::getRuleIndex() const {
  return MySQLParser::RuleSimpleExprWithParentheses;
}

void MySQLParser::SimpleExprWithParenthesesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleExprWithParentheses(this);
}

void MySQLParser::SimpleExprWithParenthesesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleExprWithParentheses(this);
}


std::any MySQLParser::SimpleExprWithParenthesesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprWithParentheses(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SimpleExprWithParenthesesContext* MySQLParser::simpleExprWithParentheses() {
  SimpleExprWithParenthesesContext *_localctx = _tracker.createInstance<SimpleExprWithParenthesesContext>(_ctx, getState());
  enterRule(_localctx, 1036, MySQLParser::RuleSimpleExprWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7602);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7603);
    simpleExpr(0);
    setState(7604);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OrderListContext ------------------------------------------------------------------

MySQLParser::OrderListContext::OrderListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::OrderExpressionContext *> MySQLParser::OrderListContext::orderExpression() {
  return getRuleContexts<MySQLParser::OrderExpressionContext>();
}

MySQLParser::OrderExpressionContext* MySQLParser::OrderListContext::orderExpression(size_t i) {
  return getRuleContext<MySQLParser::OrderExpressionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::OrderListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::OrderListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::OrderListContext::getRuleIndex() const {
  return MySQLParser::RuleOrderList;
}

void MySQLParser::OrderListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOrderList(this);
}

void MySQLParser::OrderListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOrderList(this);
}


std::any MySQLParser::OrderListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOrderList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OrderListContext* MySQLParser::orderList() {
  OrderListContext *_localctx = _tracker.createInstance<OrderListContext>(_ctx, getState());
  enterRule(_localctx, 1038, MySQLParser::RuleOrderList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7606);
    orderExpression();
    setState(7611);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 903, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7607);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7608);
        orderExpression(); 
      }
      setState(7613);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 903, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OrderExpressionContext ------------------------------------------------------------------

MySQLParser::OrderExpressionContext::OrderExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::OrderExpressionContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::DirectionContext* MySQLParser::OrderExpressionContext::direction() {
  return getRuleContext<MySQLParser::DirectionContext>(0);
}


size_t MySQLParser::OrderExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleOrderExpression;
}

void MySQLParser::OrderExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOrderExpression(this);
}

void MySQLParser::OrderExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOrderExpression(this);
}


std::any MySQLParser::OrderExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOrderExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OrderExpressionContext* MySQLParser::orderExpression() {
  OrderExpressionContext *_localctx = _tracker.createInstance<OrderExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1040, MySQLParser::RuleOrderExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7614);
    expr(0);
    setState(7616);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 904, _ctx)) {
    case 1: {
      setState(7615);
      direction();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupListContext ------------------------------------------------------------------

MySQLParser::GroupListContext::GroupListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::GroupingExpressionContext *> MySQLParser::GroupListContext::groupingExpression() {
  return getRuleContexts<MySQLParser::GroupingExpressionContext>();
}

MySQLParser::GroupingExpressionContext* MySQLParser::GroupListContext::groupingExpression(size_t i) {
  return getRuleContext<MySQLParser::GroupingExpressionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::GroupListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::GroupListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::GroupListContext::getRuleIndex() const {
  return MySQLParser::RuleGroupList;
}

void MySQLParser::GroupListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupList(this);
}

void MySQLParser::GroupListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupList(this);
}


std::any MySQLParser::GroupListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupListContext* MySQLParser::groupList() {
  GroupListContext *_localctx = _tracker.createInstance<GroupListContext>(_ctx, getState());
  enterRule(_localctx, 1042, MySQLParser::RuleGroupList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7618);
    groupingExpression();
    setState(7623);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7619);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7620);
      groupingExpression();
      setState(7625);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GroupingExpressionContext ------------------------------------------------------------------

MySQLParser::GroupingExpressionContext::GroupingExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::GroupingExpressionContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::GroupingExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleGroupingExpression;
}

void MySQLParser::GroupingExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGroupingExpression(this);
}

void MySQLParser::GroupingExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGroupingExpression(this);
}


std::any MySQLParser::GroupingExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGroupingExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GroupingExpressionContext* MySQLParser::groupingExpression() {
  GroupingExpressionContext *_localctx = _tracker.createInstance<GroupingExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1044, MySQLParser::RuleGroupingExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7626);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChannelContext ------------------------------------------------------------------

MySQLParser::ChannelContext::ChannelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ChannelContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChannelContext::CHANNEL_SYMBOL() {
  return getToken(MySQLParser::CHANNEL_SYMBOL, 0);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::ChannelContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}


size_t MySQLParser::ChannelContext::getRuleIndex() const {
  return MySQLParser::RuleChannel;
}

void MySQLParser::ChannelContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChannel(this);
}

void MySQLParser::ChannelContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChannel(this);
}


std::any MySQLParser::ChannelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitChannel(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ChannelContext* MySQLParser::channel() {
  ChannelContext *_localctx = _tracker.createInstance<ChannelContext>(_ctx, getState());
  enterRule(_localctx, 1046, MySQLParser::RuleChannel);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7628);

    if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
    setState(7629);
    match(MySQLParser::FOR_SYMBOL);
    setState(7630);
    match(MySQLParser::CHANNEL_SYMBOL);
    setState(7631);
    textStringNoLinebreak();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CompoundStatementContext ------------------------------------------------------------------

MySQLParser::CompoundStatementContext::CompoundStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SimpleStatementContext* MySQLParser::CompoundStatementContext::simpleStatement() {
  return getRuleContext<MySQLParser::SimpleStatementContext>(0);
}

MySQLParser::ReturnStatementContext* MySQLParser::CompoundStatementContext::returnStatement() {
  return getRuleContext<MySQLParser::ReturnStatementContext>(0);
}

MySQLParser::IfStatementContext* MySQLParser::CompoundStatementContext::ifStatement() {
  return getRuleContext<MySQLParser::IfStatementContext>(0);
}

MySQLParser::CaseStatementContext* MySQLParser::CompoundStatementContext::caseStatement() {
  return getRuleContext<MySQLParser::CaseStatementContext>(0);
}

MySQLParser::LabeledBlockContext* MySQLParser::CompoundStatementContext::labeledBlock() {
  return getRuleContext<MySQLParser::LabeledBlockContext>(0);
}

MySQLParser::UnlabeledBlockContext* MySQLParser::CompoundStatementContext::unlabeledBlock() {
  return getRuleContext<MySQLParser::UnlabeledBlockContext>(0);
}

MySQLParser::LabeledControlContext* MySQLParser::CompoundStatementContext::labeledControl() {
  return getRuleContext<MySQLParser::LabeledControlContext>(0);
}

MySQLParser::UnlabeledControlContext* MySQLParser::CompoundStatementContext::unlabeledControl() {
  return getRuleContext<MySQLParser::UnlabeledControlContext>(0);
}

MySQLParser::LeaveStatementContext* MySQLParser::CompoundStatementContext::leaveStatement() {
  return getRuleContext<MySQLParser::LeaveStatementContext>(0);
}

MySQLParser::IterateStatementContext* MySQLParser::CompoundStatementContext::iterateStatement() {
  return getRuleContext<MySQLParser::IterateStatementContext>(0);
}

MySQLParser::CursorOpenContext* MySQLParser::CompoundStatementContext::cursorOpen() {
  return getRuleContext<MySQLParser::CursorOpenContext>(0);
}

MySQLParser::CursorFetchContext* MySQLParser::CompoundStatementContext::cursorFetch() {
  return getRuleContext<MySQLParser::CursorFetchContext>(0);
}

MySQLParser::CursorCloseContext* MySQLParser::CompoundStatementContext::cursorClose() {
  return getRuleContext<MySQLParser::CursorCloseContext>(0);
}


size_t MySQLParser::CompoundStatementContext::getRuleIndex() const {
  return MySQLParser::RuleCompoundStatement;
}

void MySQLParser::CompoundStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCompoundStatement(this);
}

void MySQLParser::CompoundStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCompoundStatement(this);
}


std::any MySQLParser::CompoundStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCompoundStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CompoundStatementContext* MySQLParser::compoundStatement() {
  CompoundStatementContext *_localctx = _tracker.createInstance<CompoundStatementContext>(_ctx, getState());
  enterRule(_localctx, 1048, MySQLParser::RuleCompoundStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7646);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 906, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7633);
      simpleStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7634);
      returnStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7635);
      ifStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7636);
      caseStatement();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7637);
      labeledBlock();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(7638);
      unlabeledBlock();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7639);
      labeledControl();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7640);
      unlabeledControl();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(7641);
      leaveStatement();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(7642);
      iterateStatement();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(7643);
      cursorOpen();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(7644);
      cursorFetch();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(7645);
      cursorClose();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReturnStatementContext ------------------------------------------------------------------

MySQLParser::ReturnStatementContext::ReturnStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReturnStatementContext::RETURN_SYMBOL() {
  return getToken(MySQLParser::RETURN_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::ReturnStatementContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::ReturnStatementContext::getRuleIndex() const {
  return MySQLParser::RuleReturnStatement;
}

void MySQLParser::ReturnStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReturnStatement(this);
}

void MySQLParser::ReturnStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReturnStatement(this);
}


std::any MySQLParser::ReturnStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReturnStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReturnStatementContext* MySQLParser::returnStatement() {
  ReturnStatementContext *_localctx = _tracker.createInstance<ReturnStatementContext>(_ctx, getState());
  enterRule(_localctx, 1050, MySQLParser::RuleReturnStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7648);
    match(MySQLParser::RETURN_SYMBOL);
    setState(7649);
    expr(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IfStatementContext ------------------------------------------------------------------

MySQLParser::IfStatementContext::IfStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::IfStatementContext::IF_SYMBOL() {
  return getTokens(MySQLParser::IF_SYMBOL);
}

tree::TerminalNode* MySQLParser::IfStatementContext::IF_SYMBOL(size_t i) {
  return getToken(MySQLParser::IF_SYMBOL, i);
}

MySQLParser::IfBodyContext* MySQLParser::IfStatementContext::ifBody() {
  return getRuleContext<MySQLParser::IfBodyContext>(0);
}

tree::TerminalNode* MySQLParser::IfStatementContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}


size_t MySQLParser::IfStatementContext::getRuleIndex() const {
  return MySQLParser::RuleIfStatement;
}

void MySQLParser::IfStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIfStatement(this);
}

void MySQLParser::IfStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIfStatement(this);
}


std::any MySQLParser::IfStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIfStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IfStatementContext* MySQLParser::ifStatement() {
  IfStatementContext *_localctx = _tracker.createInstance<IfStatementContext>(_ctx, getState());
  enterRule(_localctx, 1052, MySQLParser::RuleIfStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7651);
    match(MySQLParser::IF_SYMBOL);
    setState(7652);
    ifBody();
    setState(7653);
    match(MySQLParser::END_SYMBOL);
    setState(7654);
    match(MySQLParser::IF_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IfBodyContext ------------------------------------------------------------------

MySQLParser::IfBodyContext::IfBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ExprContext* MySQLParser::IfBodyContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::ThenStatementContext* MySQLParser::IfBodyContext::thenStatement() {
  return getRuleContext<MySQLParser::ThenStatementContext>(0);
}

tree::TerminalNode* MySQLParser::IfBodyContext::ELSEIF_SYMBOL() {
  return getToken(MySQLParser::ELSEIF_SYMBOL, 0);
}

MySQLParser::IfBodyContext* MySQLParser::IfBodyContext::ifBody() {
  return getRuleContext<MySQLParser::IfBodyContext>(0);
}

tree::TerminalNode* MySQLParser::IfBodyContext::ELSE_SYMBOL() {
  return getToken(MySQLParser::ELSE_SYMBOL, 0);
}

MySQLParser::CompoundStatementListContext* MySQLParser::IfBodyContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}


size_t MySQLParser::IfBodyContext::getRuleIndex() const {
  return MySQLParser::RuleIfBody;
}

void MySQLParser::IfBodyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIfBody(this);
}

void MySQLParser::IfBodyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIfBody(this);
}


std::any MySQLParser::IfBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIfBody(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IfBodyContext* MySQLParser::ifBody() {
  IfBodyContext *_localctx = _tracker.createInstance<IfBodyContext>(_ctx, getState());
  enterRule(_localctx, 1054, MySQLParser::RuleIfBody);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7656);
    expr(0);
    setState(7657);
    thenStatement();
    setState(7662);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ELSEIF_SYMBOL: {
        setState(7658);
        match(MySQLParser::ELSEIF_SYMBOL);
        setState(7659);
        ifBody();
        break;
      }

      case MySQLParser::ELSE_SYMBOL: {
        setState(7660);
        match(MySQLParser::ELSE_SYMBOL);
        setState(7661);
        compoundStatementList();
        break;
      }

      case MySQLParser::END_SYMBOL: {
        break;
      }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ThenStatementContext ------------------------------------------------------------------

MySQLParser::ThenStatementContext::ThenStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ThenStatementContext::THEN_SYMBOL() {
  return getToken(MySQLParser::THEN_SYMBOL, 0);
}

MySQLParser::CompoundStatementListContext* MySQLParser::ThenStatementContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}


size_t MySQLParser::ThenStatementContext::getRuleIndex() const {
  return MySQLParser::RuleThenStatement;
}

void MySQLParser::ThenStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterThenStatement(this);
}

void MySQLParser::ThenStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitThenStatement(this);
}


std::any MySQLParser::ThenStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitThenStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ThenStatementContext* MySQLParser::thenStatement() {
  ThenStatementContext *_localctx = _tracker.createInstance<ThenStatementContext>(_ctx, getState());
  enterRule(_localctx, 1056, MySQLParser::RuleThenStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7664);
    match(MySQLParser::THEN_SYMBOL);
    setState(7665);
    compoundStatementList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CompoundStatementListContext ------------------------------------------------------------------

MySQLParser::CompoundStatementListContext::CompoundStatementListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::CompoundStatementContext *> MySQLParser::CompoundStatementListContext::compoundStatement() {
  return getRuleContexts<MySQLParser::CompoundStatementContext>();
}

MySQLParser::CompoundStatementContext* MySQLParser::CompoundStatementListContext::compoundStatement(size_t i) {
  return getRuleContext<MySQLParser::CompoundStatementContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::CompoundStatementListContext::SEMICOLON_SYMBOL() {
  return getTokens(MySQLParser::SEMICOLON_SYMBOL);
}

tree::TerminalNode* MySQLParser::CompoundStatementListContext::SEMICOLON_SYMBOL(size_t i) {
  return getToken(MySQLParser::SEMICOLON_SYMBOL, i);
}


size_t MySQLParser::CompoundStatementListContext::getRuleIndex() const {
  return MySQLParser::RuleCompoundStatementList;
}

void MySQLParser::CompoundStatementListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCompoundStatementList(this);
}

void MySQLParser::CompoundStatementListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCompoundStatementList(this);
}


std::any MySQLParser::CompoundStatementListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCompoundStatementList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CompoundStatementListContext* MySQLParser::compoundStatementList() {
  CompoundStatementListContext *_localctx = _tracker.createInstance<CompoundStatementListContext>(_ctx, getState());
  enterRule(_localctx, 1058, MySQLParser::RuleCompoundStatementList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7670); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(7667);
              compoundStatement();
              setState(7668);
              match(MySQLParser::SEMICOLON_SYMBOL);
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(7672); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 908, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CaseStatementContext ------------------------------------------------------------------

MySQLParser::CaseStatementContext::CaseStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::CaseStatementContext::CASE_SYMBOL() {
  return getTokens(MySQLParser::CASE_SYMBOL);
}

tree::TerminalNode* MySQLParser::CaseStatementContext::CASE_SYMBOL(size_t i) {
  return getToken(MySQLParser::CASE_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::CaseStatementContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::CaseStatementContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

std::vector<MySQLParser::WhenExpressionContext *> MySQLParser::CaseStatementContext::whenExpression() {
  return getRuleContexts<MySQLParser::WhenExpressionContext>();
}

MySQLParser::WhenExpressionContext* MySQLParser::CaseStatementContext::whenExpression(size_t i) {
  return getRuleContext<MySQLParser::WhenExpressionContext>(i);
}

std::vector<MySQLParser::ThenStatementContext *> MySQLParser::CaseStatementContext::thenStatement() {
  return getRuleContexts<MySQLParser::ThenStatementContext>();
}

MySQLParser::ThenStatementContext* MySQLParser::CaseStatementContext::thenStatement(size_t i) {
  return getRuleContext<MySQLParser::ThenStatementContext>(i);
}

MySQLParser::ElseStatementContext* MySQLParser::CaseStatementContext::elseStatement() {
  return getRuleContext<MySQLParser::ElseStatementContext>(0);
}


size_t MySQLParser::CaseStatementContext::getRuleIndex() const {
  return MySQLParser::RuleCaseStatement;
}

void MySQLParser::CaseStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCaseStatement(this);
}

void MySQLParser::CaseStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCaseStatement(this);
}


std::any MySQLParser::CaseStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCaseStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CaseStatementContext* MySQLParser::caseStatement() {
  CaseStatementContext *_localctx = _tracker.createInstance<CaseStatementContext>(_ctx, getState());
  enterRule(_localctx, 1060, MySQLParser::RuleCaseStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7674);
    match(MySQLParser::CASE_SYMBOL);
    setState(7676);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 909, _ctx)) {
    case 1: {
      setState(7675);
      expr(0);
      break;
    }

    default:
      break;
    }
    setState(7681); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(7678);
      whenExpression();
      setState(7679);
      thenStatement();
      setState(7683); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == MySQLParser::WHEN_SYMBOL);
    setState(7686);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ELSE_SYMBOL) {
      setState(7685);
      elseStatement();
    }
    setState(7688);
    match(MySQLParser::END_SYMBOL);
    setState(7689);
    match(MySQLParser::CASE_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ElseStatementContext ------------------------------------------------------------------

MySQLParser::ElseStatementContext::ElseStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ElseStatementContext::ELSE_SYMBOL() {
  return getToken(MySQLParser::ELSE_SYMBOL, 0);
}

MySQLParser::CompoundStatementListContext* MySQLParser::ElseStatementContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}


size_t MySQLParser::ElseStatementContext::getRuleIndex() const {
  return MySQLParser::RuleElseStatement;
}

void MySQLParser::ElseStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterElseStatement(this);
}

void MySQLParser::ElseStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitElseStatement(this);
}


std::any MySQLParser::ElseStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitElseStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ElseStatementContext* MySQLParser::elseStatement() {
  ElseStatementContext *_localctx = _tracker.createInstance<ElseStatementContext>(_ctx, getState());
  enterRule(_localctx, 1062, MySQLParser::RuleElseStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7691);
    match(MySQLParser::ELSE_SYMBOL);
    setState(7692);
    compoundStatementList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabeledBlockContext ------------------------------------------------------------------

MySQLParser::LabeledBlockContext::LabeledBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LabelContext* MySQLParser::LabeledBlockContext::label() {
  return getRuleContext<MySQLParser::LabelContext>(0);
}

MySQLParser::BeginEndBlockContext* MySQLParser::LabeledBlockContext::beginEndBlock() {
  return getRuleContext<MySQLParser::BeginEndBlockContext>(0);
}

MySQLParser::LabelRefContext* MySQLParser::LabeledBlockContext::labelRef() {
  return getRuleContext<MySQLParser::LabelRefContext>(0);
}


size_t MySQLParser::LabeledBlockContext::getRuleIndex() const {
  return MySQLParser::RuleLabeledBlock;
}

void MySQLParser::LabeledBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabeledBlock(this);
}

void MySQLParser::LabeledBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabeledBlock(this);
}


std::any MySQLParser::LabeledBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLabeledBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LabeledBlockContext* MySQLParser::labeledBlock() {
  LabeledBlockContext *_localctx = _tracker.createInstance<LabeledBlockContext>(_ctx, getState());
  enterRule(_localctx, 1064, MySQLParser::RuleLabeledBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7694);
    label();
    setState(7695);
    beginEndBlock();
    setState(7697);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 912, _ctx)) {
    case 1: {
      setState(7696);
      labelRef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnlabeledBlockContext ------------------------------------------------------------------

MySQLParser::UnlabeledBlockContext::UnlabeledBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::BeginEndBlockContext* MySQLParser::UnlabeledBlockContext::beginEndBlock() {
  return getRuleContext<MySQLParser::BeginEndBlockContext>(0);
}


size_t MySQLParser::UnlabeledBlockContext::getRuleIndex() const {
  return MySQLParser::RuleUnlabeledBlock;
}

void MySQLParser::UnlabeledBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUnlabeledBlock(this);
}

void MySQLParser::UnlabeledBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUnlabeledBlock(this);
}


std::any MySQLParser::UnlabeledBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUnlabeledBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UnlabeledBlockContext* MySQLParser::unlabeledBlock() {
  UnlabeledBlockContext *_localctx = _tracker.createInstance<UnlabeledBlockContext>(_ctx, getState());
  enterRule(_localctx, 1066, MySQLParser::RuleUnlabeledBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7699);
    beginEndBlock();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabelContext ------------------------------------------------------------------

MySQLParser::LabelContext::LabelContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LabelIdentifierContext* MySQLParser::LabelContext::labelIdentifier() {
  return getRuleContext<MySQLParser::LabelIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::LabelContext::COLON_SYMBOL() {
  return getToken(MySQLParser::COLON_SYMBOL, 0);
}


size_t MySQLParser::LabelContext::getRuleIndex() const {
  return MySQLParser::RuleLabel;
}

void MySQLParser::LabelContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabel(this);
}

void MySQLParser::LabelContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabel(this);
}


std::any MySQLParser::LabelContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLabel(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LabelContext* MySQLParser::label() {
  LabelContext *_localctx = _tracker.createInstance<LabelContext>(_ctx, getState());
  enterRule(_localctx, 1068, MySQLParser::RuleLabel);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7701);
    labelIdentifier();
    setState(7702);
    match(MySQLParser::COLON_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BeginEndBlockContext ------------------------------------------------------------------

MySQLParser::BeginEndBlockContext::BeginEndBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::BeginEndBlockContext::BEGIN_SYMBOL() {
  return getToken(MySQLParser::BEGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::BeginEndBlockContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}

MySQLParser::SpDeclarationsContext* MySQLParser::BeginEndBlockContext::spDeclarations() {
  return getRuleContext<MySQLParser::SpDeclarationsContext>(0);
}

MySQLParser::CompoundStatementListContext* MySQLParser::BeginEndBlockContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}


size_t MySQLParser::BeginEndBlockContext::getRuleIndex() const {
  return MySQLParser::RuleBeginEndBlock;
}

void MySQLParser::BeginEndBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBeginEndBlock(this);
}

void MySQLParser::BeginEndBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBeginEndBlock(this);
}


std::any MySQLParser::BeginEndBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitBeginEndBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::BeginEndBlockContext* MySQLParser::beginEndBlock() {
  BeginEndBlockContext *_localctx = _tracker.createInstance<BeginEndBlockContext>(_ctx, getState());
  enterRule(_localctx, 1070, MySQLParser::RuleBeginEndBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7704);
    match(MySQLParser::BEGIN_SYMBOL);
    setState(7706);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 913, _ctx)) {
    case 1: {
      setState(7705);
      spDeclarations();
      break;
    }

    default:
      break;
    }
    setState(7709);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 914, _ctx)) {
    case 1: {
      setState(7708);
      compoundStatementList();
      break;
    }

    default:
      break;
    }
    setState(7711);
    match(MySQLParser::END_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabeledControlContext ------------------------------------------------------------------

MySQLParser::LabeledControlContext::LabeledControlContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LabelContext* MySQLParser::LabeledControlContext::label() {
  return getRuleContext<MySQLParser::LabelContext>(0);
}

MySQLParser::UnlabeledControlContext* MySQLParser::LabeledControlContext::unlabeledControl() {
  return getRuleContext<MySQLParser::UnlabeledControlContext>(0);
}

MySQLParser::LabelRefContext* MySQLParser::LabeledControlContext::labelRef() {
  return getRuleContext<MySQLParser::LabelRefContext>(0);
}


size_t MySQLParser::LabeledControlContext::getRuleIndex() const {
  return MySQLParser::RuleLabeledControl;
}

void MySQLParser::LabeledControlContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabeledControl(this);
}

void MySQLParser::LabeledControlContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabeledControl(this);
}


std::any MySQLParser::LabeledControlContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLabeledControl(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LabeledControlContext* MySQLParser::labeledControl() {
  LabeledControlContext *_localctx = _tracker.createInstance<LabeledControlContext>(_ctx, getState());
  enterRule(_localctx, 1072, MySQLParser::RuleLabeledControl);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7713);
    label();
    setState(7714);
    unlabeledControl();
    setState(7716);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 915, _ctx)) {
    case 1: {
      setState(7715);
      labelRef();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnlabeledControlContext ------------------------------------------------------------------

MySQLParser::UnlabeledControlContext::UnlabeledControlContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LoopBlockContext* MySQLParser::UnlabeledControlContext::loopBlock() {
  return getRuleContext<MySQLParser::LoopBlockContext>(0);
}

MySQLParser::WhileDoBlockContext* MySQLParser::UnlabeledControlContext::whileDoBlock() {
  return getRuleContext<MySQLParser::WhileDoBlockContext>(0);
}

MySQLParser::RepeatUntilBlockContext* MySQLParser::UnlabeledControlContext::repeatUntilBlock() {
  return getRuleContext<MySQLParser::RepeatUntilBlockContext>(0);
}


size_t MySQLParser::UnlabeledControlContext::getRuleIndex() const {
  return MySQLParser::RuleUnlabeledControl;
}

void MySQLParser::UnlabeledControlContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUnlabeledControl(this);
}

void MySQLParser::UnlabeledControlContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUnlabeledControl(this);
}


std::any MySQLParser::UnlabeledControlContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUnlabeledControl(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UnlabeledControlContext* MySQLParser::unlabeledControl() {
  UnlabeledControlContext *_localctx = _tracker.createInstance<UnlabeledControlContext>(_ctx, getState());
  enterRule(_localctx, 1074, MySQLParser::RuleUnlabeledControl);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7721);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::LOOP_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7718);
        loopBlock();
        break;
      }

      case MySQLParser::WHILE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7719);
        whileDoBlock();
        break;
      }

      case MySQLParser::REPEAT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(7720);
        repeatUntilBlock();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LoopBlockContext ------------------------------------------------------------------

MySQLParser::LoopBlockContext::LoopBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::LoopBlockContext::LOOP_SYMBOL() {
  return getTokens(MySQLParser::LOOP_SYMBOL);
}

tree::TerminalNode* MySQLParser::LoopBlockContext::LOOP_SYMBOL(size_t i) {
  return getToken(MySQLParser::LOOP_SYMBOL, i);
}

MySQLParser::CompoundStatementListContext* MySQLParser::LoopBlockContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}

tree::TerminalNode* MySQLParser::LoopBlockContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}


size_t MySQLParser::LoopBlockContext::getRuleIndex() const {
  return MySQLParser::RuleLoopBlock;
}

void MySQLParser::LoopBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLoopBlock(this);
}

void MySQLParser::LoopBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLoopBlock(this);
}


std::any MySQLParser::LoopBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLoopBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LoopBlockContext* MySQLParser::loopBlock() {
  LoopBlockContext *_localctx = _tracker.createInstance<LoopBlockContext>(_ctx, getState());
  enterRule(_localctx, 1076, MySQLParser::RuleLoopBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7723);
    match(MySQLParser::LOOP_SYMBOL);
    setState(7724);
    compoundStatementList();
    setState(7725);
    match(MySQLParser::END_SYMBOL);
    setState(7726);
    match(MySQLParser::LOOP_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WhileDoBlockContext ------------------------------------------------------------------

MySQLParser::WhileDoBlockContext::WhileDoBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::WhileDoBlockContext::WHILE_SYMBOL() {
  return getTokens(MySQLParser::WHILE_SYMBOL);
}

tree::TerminalNode* MySQLParser::WhileDoBlockContext::WHILE_SYMBOL(size_t i) {
  return getToken(MySQLParser::WHILE_SYMBOL, i);
}

MySQLParser::ExprContext* MySQLParser::WhileDoBlockContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::WhileDoBlockContext::DO_SYMBOL() {
  return getToken(MySQLParser::DO_SYMBOL, 0);
}

MySQLParser::CompoundStatementListContext* MySQLParser::WhileDoBlockContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}

tree::TerminalNode* MySQLParser::WhileDoBlockContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}


size_t MySQLParser::WhileDoBlockContext::getRuleIndex() const {
  return MySQLParser::RuleWhileDoBlock;
}

void MySQLParser::WhileDoBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWhileDoBlock(this);
}

void MySQLParser::WhileDoBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWhileDoBlock(this);
}


std::any MySQLParser::WhileDoBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWhileDoBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WhileDoBlockContext* MySQLParser::whileDoBlock() {
  WhileDoBlockContext *_localctx = _tracker.createInstance<WhileDoBlockContext>(_ctx, getState());
  enterRule(_localctx, 1078, MySQLParser::RuleWhileDoBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7728);
    match(MySQLParser::WHILE_SYMBOL);
    setState(7729);
    expr(0);
    setState(7730);
    match(MySQLParser::DO_SYMBOL);
    setState(7731);
    compoundStatementList();
    setState(7732);
    match(MySQLParser::END_SYMBOL);
    setState(7733);
    match(MySQLParser::WHILE_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RepeatUntilBlockContext ------------------------------------------------------------------

MySQLParser::RepeatUntilBlockContext::RepeatUntilBlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::RepeatUntilBlockContext::REPEAT_SYMBOL() {
  return getTokens(MySQLParser::REPEAT_SYMBOL);
}

tree::TerminalNode* MySQLParser::RepeatUntilBlockContext::REPEAT_SYMBOL(size_t i) {
  return getToken(MySQLParser::REPEAT_SYMBOL, i);
}

MySQLParser::CompoundStatementListContext* MySQLParser::RepeatUntilBlockContext::compoundStatementList() {
  return getRuleContext<MySQLParser::CompoundStatementListContext>(0);
}

tree::TerminalNode* MySQLParser::RepeatUntilBlockContext::UNTIL_SYMBOL() {
  return getToken(MySQLParser::UNTIL_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::RepeatUntilBlockContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::RepeatUntilBlockContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}


size_t MySQLParser::RepeatUntilBlockContext::getRuleIndex() const {
  return MySQLParser::RuleRepeatUntilBlock;
}

void MySQLParser::RepeatUntilBlockContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRepeatUntilBlock(this);
}

void MySQLParser::RepeatUntilBlockContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRepeatUntilBlock(this);
}


std::any MySQLParser::RepeatUntilBlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRepeatUntilBlock(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RepeatUntilBlockContext* MySQLParser::repeatUntilBlock() {
  RepeatUntilBlockContext *_localctx = _tracker.createInstance<RepeatUntilBlockContext>(_ctx, getState());
  enterRule(_localctx, 1080, MySQLParser::RuleRepeatUntilBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7735);
    match(MySQLParser::REPEAT_SYMBOL);
    setState(7736);
    compoundStatementList();
    setState(7737);
    match(MySQLParser::UNTIL_SYMBOL);
    setState(7738);
    expr(0);
    setState(7739);
    match(MySQLParser::END_SYMBOL);
    setState(7740);
    match(MySQLParser::REPEAT_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SpDeclarationsContext ------------------------------------------------------------------

MySQLParser::SpDeclarationsContext::SpDeclarationsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::SpDeclarationContext *> MySQLParser::SpDeclarationsContext::spDeclaration() {
  return getRuleContexts<MySQLParser::SpDeclarationContext>();
}

MySQLParser::SpDeclarationContext* MySQLParser::SpDeclarationsContext::spDeclaration(size_t i) {
  return getRuleContext<MySQLParser::SpDeclarationContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::SpDeclarationsContext::SEMICOLON_SYMBOL() {
  return getTokens(MySQLParser::SEMICOLON_SYMBOL);
}

tree::TerminalNode* MySQLParser::SpDeclarationsContext::SEMICOLON_SYMBOL(size_t i) {
  return getToken(MySQLParser::SEMICOLON_SYMBOL, i);
}


size_t MySQLParser::SpDeclarationsContext::getRuleIndex() const {
  return MySQLParser::RuleSpDeclarations;
}

void MySQLParser::SpDeclarationsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSpDeclarations(this);
}

void MySQLParser::SpDeclarationsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSpDeclarations(this);
}


std::any MySQLParser::SpDeclarationsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSpDeclarations(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SpDeclarationsContext* MySQLParser::spDeclarations() {
  SpDeclarationsContext *_localctx = _tracker.createInstance<SpDeclarationsContext>(_ctx, getState());
  enterRule(_localctx, 1082, MySQLParser::RuleSpDeclarations);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7745); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(7742);
              spDeclaration();
              setState(7743);
              match(MySQLParser::SEMICOLON_SYMBOL);
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(7747); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 917, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SpDeclarationContext ------------------------------------------------------------------

MySQLParser::SpDeclarationContext::SpDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::VariableDeclarationContext* MySQLParser::SpDeclarationContext::variableDeclaration() {
  return getRuleContext<MySQLParser::VariableDeclarationContext>(0);
}

MySQLParser::ConditionDeclarationContext* MySQLParser::SpDeclarationContext::conditionDeclaration() {
  return getRuleContext<MySQLParser::ConditionDeclarationContext>(0);
}

MySQLParser::HandlerDeclarationContext* MySQLParser::SpDeclarationContext::handlerDeclaration() {
  return getRuleContext<MySQLParser::HandlerDeclarationContext>(0);
}

MySQLParser::CursorDeclarationContext* MySQLParser::SpDeclarationContext::cursorDeclaration() {
  return getRuleContext<MySQLParser::CursorDeclarationContext>(0);
}


size_t MySQLParser::SpDeclarationContext::getRuleIndex() const {
  return MySQLParser::RuleSpDeclaration;
}

void MySQLParser::SpDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSpDeclaration(this);
}

void MySQLParser::SpDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSpDeclaration(this);
}


std::any MySQLParser::SpDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSpDeclaration(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SpDeclarationContext* MySQLParser::spDeclaration() {
  SpDeclarationContext *_localctx = _tracker.createInstance<SpDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 1084, MySQLParser::RuleSpDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7753);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 918, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7749);
      variableDeclaration();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7750);
      conditionDeclaration();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7751);
      handlerDeclaration();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7752);
      cursorDeclaration();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VariableDeclarationContext ------------------------------------------------------------------

MySQLParser::VariableDeclarationContext::VariableDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::VariableDeclarationContext::DECLARE_SYMBOL() {
  return getToken(MySQLParser::DECLARE_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::VariableDeclarationContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

MySQLParser::DataTypeContext* MySQLParser::VariableDeclarationContext::dataType() {
  return getRuleContext<MySQLParser::DataTypeContext>(0);
}

MySQLParser::CollateContext* MySQLParser::VariableDeclarationContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}

tree::TerminalNode* MySQLParser::VariableDeclarationContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::VariableDeclarationContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}


size_t MySQLParser::VariableDeclarationContext::getRuleIndex() const {
  return MySQLParser::RuleVariableDeclaration;
}

void MySQLParser::VariableDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterVariableDeclaration(this);
}

void MySQLParser::VariableDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitVariableDeclaration(this);
}


std::any MySQLParser::VariableDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitVariableDeclaration(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::VariableDeclarationContext* MySQLParser::variableDeclaration() {
  VariableDeclarationContext *_localctx = _tracker.createInstance<VariableDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 1086, MySQLParser::RuleVariableDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7755);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(7756);
    identifierList();
    setState(7757);
    dataType();
    setState(7759);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COLLATE_SYMBOL) {
      setState(7758);
      collate();
    }
    setState(7763);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(7761);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(7762);
      expr(0);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConditionDeclarationContext ------------------------------------------------------------------

MySQLParser::ConditionDeclarationContext::ConditionDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ConditionDeclarationContext::DECLARE_SYMBOL() {
  return getToken(MySQLParser::DECLARE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::ConditionDeclarationContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::ConditionDeclarationContext::CONDITION_SYMBOL() {
  return getToken(MySQLParser::CONDITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ConditionDeclarationContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::SpConditionContext* MySQLParser::ConditionDeclarationContext::spCondition() {
  return getRuleContext<MySQLParser::SpConditionContext>(0);
}


size_t MySQLParser::ConditionDeclarationContext::getRuleIndex() const {
  return MySQLParser::RuleConditionDeclaration;
}

void MySQLParser::ConditionDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConditionDeclaration(this);
}

void MySQLParser::ConditionDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConditionDeclaration(this);
}


std::any MySQLParser::ConditionDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitConditionDeclaration(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ConditionDeclarationContext* MySQLParser::conditionDeclaration() {
  ConditionDeclarationContext *_localctx = _tracker.createInstance<ConditionDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 1088, MySQLParser::RuleConditionDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7765);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(7766);
    identifier();
    setState(7767);
    match(MySQLParser::CONDITION_SYMBOL);
    setState(7768);
    match(MySQLParser::FOR_SYMBOL);
    setState(7769);
    spCondition();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SpConditionContext ------------------------------------------------------------------

MySQLParser::SpConditionContext::SpConditionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::Ulong_numberContext* MySQLParser::SpConditionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

MySQLParser::SqlstateContext* MySQLParser::SpConditionContext::sqlstate() {
  return getRuleContext<MySQLParser::SqlstateContext>(0);
}


size_t MySQLParser::SpConditionContext::getRuleIndex() const {
  return MySQLParser::RuleSpCondition;
}

void MySQLParser::SpConditionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSpCondition(this);
}

void MySQLParser::SpConditionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSpCondition(this);
}


std::any MySQLParser::SpConditionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSpCondition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SpConditionContext* MySQLParser::spCondition() {
  SpConditionContext *_localctx = _tracker.createInstance<SpConditionContext>(_ctx, getState());
  enterRule(_localctx, 1090, MySQLParser::RuleSpCondition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7773);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER:
      case MySQLParser::HEX_NUMBER:
      case MySQLParser::DECIMAL_NUMBER:
      case MySQLParser::FLOAT_NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(7771);
        ulong_number();
        break;
      }

      case MySQLParser::SQLSTATE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7772);
        sqlstate();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SqlstateContext ------------------------------------------------------------------

MySQLParser::SqlstateContext::SqlstateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SqlstateContext::SQLSTATE_SYMBOL() {
  return getToken(MySQLParser::SQLSTATE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::SqlstateContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::SqlstateContext::VALUE_SYMBOL() {
  return getToken(MySQLParser::VALUE_SYMBOL, 0);
}


size_t MySQLParser::SqlstateContext::getRuleIndex() const {
  return MySQLParser::RuleSqlstate;
}

void MySQLParser::SqlstateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSqlstate(this);
}

void MySQLParser::SqlstateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSqlstate(this);
}


std::any MySQLParser::SqlstateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSqlstate(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SqlstateContext* MySQLParser::sqlstate() {
  SqlstateContext *_localctx = _tracker.createInstance<SqlstateContext>(_ctx, getState());
  enterRule(_localctx, 1092, MySQLParser::RuleSqlstate);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7775);
    match(MySQLParser::SQLSTATE_SYMBOL);
    setState(7777);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 922, _ctx)) {
    case 1: {
      setState(7776);
      match(MySQLParser::VALUE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(7779);
    textLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HandlerDeclarationContext ------------------------------------------------------------------

MySQLParser::HandlerDeclarationContext::HandlerDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::DECLARE_SYMBOL() {
  return getToken(MySQLParser::DECLARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::HANDLER_SYMBOL() {
  return getToken(MySQLParser::HANDLER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

std::vector<MySQLParser::HandlerConditionContext *> MySQLParser::HandlerDeclarationContext::handlerCondition() {
  return getRuleContexts<MySQLParser::HandlerConditionContext>();
}

MySQLParser::HandlerConditionContext* MySQLParser::HandlerDeclarationContext::handlerCondition(size_t i) {
  return getRuleContext<MySQLParser::HandlerConditionContext>(i);
}

MySQLParser::CompoundStatementContext* MySQLParser::HandlerDeclarationContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::CONTINUE_SYMBOL() {
  return getToken(MySQLParser::CONTINUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::EXIT_SYMBOL() {
  return getToken(MySQLParser::EXIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::UNDO_SYMBOL() {
  return getToken(MySQLParser::UNDO_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::HandlerDeclarationContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::HandlerDeclarationContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::HandlerDeclarationContext::getRuleIndex() const {
  return MySQLParser::RuleHandlerDeclaration;
}

void MySQLParser::HandlerDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHandlerDeclaration(this);
}

void MySQLParser::HandlerDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHandlerDeclaration(this);
}


std::any MySQLParser::HandlerDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHandlerDeclaration(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HandlerDeclarationContext* MySQLParser::handlerDeclaration() {
  HandlerDeclarationContext *_localctx = _tracker.createInstance<HandlerDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 1094, MySQLParser::RuleHandlerDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7781);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(7782);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::CONTINUE_SYMBOL || _la == MySQLParser::EXIT_SYMBOL || _la == MySQLParser::UNDO_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(7783);
    match(MySQLParser::HANDLER_SYMBOL);
    setState(7784);
    match(MySQLParser::FOR_SYMBOL);
    setState(7785);
    handlerCondition();
    setState(7790);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 923, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7786);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7787);
        handlerCondition(); 
      }
      setState(7792);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 923, _ctx);
    }
    setState(7793);
    compoundStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HandlerConditionContext ------------------------------------------------------------------

MySQLParser::HandlerConditionContext::HandlerConditionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SpConditionContext* MySQLParser::HandlerConditionContext::spCondition() {
  return getRuleContext<MySQLParser::SpConditionContext>(0);
}

MySQLParser::IdentifierContext* MySQLParser::HandlerConditionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerConditionContext::SQLWARNING_SYMBOL() {
  return getToken(MySQLParser::SQLWARNING_SYMBOL, 0);
}

MySQLParser::NotRuleContext* MySQLParser::HandlerConditionContext::notRule() {
  return getRuleContext<MySQLParser::NotRuleContext>(0);
}

tree::TerminalNode* MySQLParser::HandlerConditionContext::FOUND_SYMBOL() {
  return getToken(MySQLParser::FOUND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::HandlerConditionContext::SQLEXCEPTION_SYMBOL() {
  return getToken(MySQLParser::SQLEXCEPTION_SYMBOL, 0);
}


size_t MySQLParser::HandlerConditionContext::getRuleIndex() const {
  return MySQLParser::RuleHandlerCondition;
}

void MySQLParser::HandlerConditionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterHandlerCondition(this);
}

void MySQLParser::HandlerConditionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitHandlerCondition(this);
}


std::any MySQLParser::HandlerConditionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitHandlerCondition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::HandlerConditionContext* MySQLParser::handlerCondition() {
  HandlerConditionContext *_localctx = _tracker.createInstance<HandlerConditionContext>(_ctx, getState());
  enterRule(_localctx, 1096, MySQLParser::RuleHandlerCondition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7802);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 924, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7795);
      spCondition();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7796);
      identifier();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7797);
      match(MySQLParser::SQLWARNING_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7798);
      notRule();
      setState(7799);
      match(MySQLParser::FOUND_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7801);
      match(MySQLParser::SQLEXCEPTION_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CursorDeclarationContext ------------------------------------------------------------------

MySQLParser::CursorDeclarationContext::CursorDeclarationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CursorDeclarationContext::DECLARE_SYMBOL() {
  return getToken(MySQLParser::DECLARE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CursorDeclarationContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CursorDeclarationContext::CURSOR_SYMBOL() {
  return getToken(MySQLParser::CURSOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CursorDeclarationContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::SelectStatementContext* MySQLParser::CursorDeclarationContext::selectStatement() {
  return getRuleContext<MySQLParser::SelectStatementContext>(0);
}


size_t MySQLParser::CursorDeclarationContext::getRuleIndex() const {
  return MySQLParser::RuleCursorDeclaration;
}

void MySQLParser::CursorDeclarationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCursorDeclaration(this);
}

void MySQLParser::CursorDeclarationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCursorDeclaration(this);
}


std::any MySQLParser::CursorDeclarationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCursorDeclaration(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CursorDeclarationContext* MySQLParser::cursorDeclaration() {
  CursorDeclarationContext *_localctx = _tracker.createInstance<CursorDeclarationContext>(_ctx, getState());
  enterRule(_localctx, 1098, MySQLParser::RuleCursorDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7804);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(7805);
    identifier();
    setState(7806);
    match(MySQLParser::CURSOR_SYMBOL);
    setState(7807);
    match(MySQLParser::FOR_SYMBOL);
    setState(7808);
    selectStatement();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IterateStatementContext ------------------------------------------------------------------

MySQLParser::IterateStatementContext::IterateStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IterateStatementContext::ITERATE_SYMBOL() {
  return getToken(MySQLParser::ITERATE_SYMBOL, 0);
}

MySQLParser::LabelRefContext* MySQLParser::IterateStatementContext::labelRef() {
  return getRuleContext<MySQLParser::LabelRefContext>(0);
}


size_t MySQLParser::IterateStatementContext::getRuleIndex() const {
  return MySQLParser::RuleIterateStatement;
}

void MySQLParser::IterateStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIterateStatement(this);
}

void MySQLParser::IterateStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIterateStatement(this);
}


std::any MySQLParser::IterateStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIterateStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IterateStatementContext* MySQLParser::iterateStatement() {
  IterateStatementContext *_localctx = _tracker.createInstance<IterateStatementContext>(_ctx, getState());
  enterRule(_localctx, 1100, MySQLParser::RuleIterateStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7810);
    match(MySQLParser::ITERATE_SYMBOL);
    setState(7811);
    labelRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LeaveStatementContext ------------------------------------------------------------------

MySQLParser::LeaveStatementContext::LeaveStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LeaveStatementContext::LEAVE_SYMBOL() {
  return getToken(MySQLParser::LEAVE_SYMBOL, 0);
}

MySQLParser::LabelRefContext* MySQLParser::LeaveStatementContext::labelRef() {
  return getRuleContext<MySQLParser::LabelRefContext>(0);
}


size_t MySQLParser::LeaveStatementContext::getRuleIndex() const {
  return MySQLParser::RuleLeaveStatement;
}

void MySQLParser::LeaveStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLeaveStatement(this);
}

void MySQLParser::LeaveStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLeaveStatement(this);
}


std::any MySQLParser::LeaveStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLeaveStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LeaveStatementContext* MySQLParser::leaveStatement() {
  LeaveStatementContext *_localctx = _tracker.createInstance<LeaveStatementContext>(_ctx, getState());
  enterRule(_localctx, 1102, MySQLParser::RuleLeaveStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7813);
    match(MySQLParser::LEAVE_SYMBOL);
    setState(7814);
    labelRef();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GetDiagnosticsStatementContext ------------------------------------------------------------------

MySQLParser::GetDiagnosticsStatementContext::GetDiagnosticsStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GetDiagnosticsStatementContext::GET_SYMBOL() {
  return getToken(MySQLParser::GET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsStatementContext::DIAGNOSTICS_SYMBOL() {
  return getToken(MySQLParser::DIAGNOSTICS_SYMBOL, 0);
}

std::vector<MySQLParser::StatementInformationItemContext *> MySQLParser::GetDiagnosticsStatementContext::statementInformationItem() {
  return getRuleContexts<MySQLParser::StatementInformationItemContext>();
}

MySQLParser::StatementInformationItemContext* MySQLParser::GetDiagnosticsStatementContext::statementInformationItem(size_t i) {
  return getRuleContext<MySQLParser::StatementInformationItemContext>(i);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsStatementContext::CONDITION_SYMBOL() {
  return getToken(MySQLParser::CONDITION_SYMBOL, 0);
}

MySQLParser::SignalAllowedExprContext* MySQLParser::GetDiagnosticsStatementContext::signalAllowedExpr() {
  return getRuleContext<MySQLParser::SignalAllowedExprContext>(0);
}

std::vector<MySQLParser::ConditionInformationItemContext *> MySQLParser::GetDiagnosticsStatementContext::conditionInformationItem() {
  return getRuleContexts<MySQLParser::ConditionInformationItemContext>();
}

MySQLParser::ConditionInformationItemContext* MySQLParser::GetDiagnosticsStatementContext::conditionInformationItem(size_t i) {
  return getRuleContext<MySQLParser::ConditionInformationItemContext>(i);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsStatementContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsStatementContext::STACKED_SYMBOL() {
  return getToken(MySQLParser::STACKED_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::GetDiagnosticsStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::GetDiagnosticsStatementContext::getRuleIndex() const {
  return MySQLParser::RuleGetDiagnosticsStatement;
}

void MySQLParser::GetDiagnosticsStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGetDiagnosticsStatement(this);
}

void MySQLParser::GetDiagnosticsStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGetDiagnosticsStatement(this);
}


std::any MySQLParser::GetDiagnosticsStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGetDiagnosticsStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GetDiagnosticsStatementContext* MySQLParser::getDiagnosticsStatement() {
  GetDiagnosticsStatementContext *_localctx = _tracker.createInstance<GetDiagnosticsStatementContext>(_ctx, getState());
  enterRule(_localctx, 1104, MySQLParser::RuleGetDiagnosticsStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7816);
    match(MySQLParser::GET_SYMBOL);
    setState(7818);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::CURRENT_SYMBOL || _la == MySQLParser::STACKED_SYMBOL) {
      setState(7817);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CURRENT_SYMBOL || _la == MySQLParser::STACKED_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(7820);
    match(MySQLParser::DIAGNOSTICS_SYMBOL);
    setState(7839);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 928, _ctx)) {
    case 1: {
      setState(7821);
      statementInformationItem();
      setState(7826);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7822);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7823);
        statementInformationItem();
        setState(7828);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 2: {
      setState(7829);
      match(MySQLParser::CONDITION_SYMBOL);
      setState(7830);
      signalAllowedExpr();
      setState(7831);
      conditionInformationItem();
      setState(7836);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7832);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7833);
        conditionInformationItem();
        setState(7838);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SignalAllowedExprContext ------------------------------------------------------------------

MySQLParser::SignalAllowedExprContext::SignalAllowedExprContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LiteralContext* MySQLParser::SignalAllowedExprContext::literal() {
  return getRuleContext<MySQLParser::LiteralContext>(0);
}

MySQLParser::RvalueSystemOrUserVariableContext* MySQLParser::SignalAllowedExprContext::rvalueSystemOrUserVariable() {
  return getRuleContext<MySQLParser::RvalueSystemOrUserVariableContext>(0);
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::SignalAllowedExprContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::SignalAllowedExprContext::getRuleIndex() const {
  return MySQLParser::RuleSignalAllowedExpr;
}

void MySQLParser::SignalAllowedExprContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSignalAllowedExpr(this);
}

void MySQLParser::SignalAllowedExprContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSignalAllowedExpr(this);
}


std::any MySQLParser::SignalAllowedExprContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSignalAllowedExpr(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SignalAllowedExprContext* MySQLParser::signalAllowedExpr() {
  SignalAllowedExprContext *_localctx = _tracker.createInstance<SignalAllowedExprContext>(_ctx, getState());
  enterRule(_localctx, 1106, MySQLParser::RuleSignalAllowedExpr);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7844);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 929, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7841);
      literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7842);
      rvalueSystemOrUserVariable();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7843);
      qualifiedIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementInformationItemContext ------------------------------------------------------------------

MySQLParser::StatementInformationItemContext::StatementInformationItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StatementInformationItemContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::StatementInformationItemContext::NUMBER_SYMBOL() {
  return getToken(MySQLParser::NUMBER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StatementInformationItemContext::ROW_COUNT_SYMBOL() {
  return getToken(MySQLParser::ROW_COUNT_SYMBOL, 0);
}

MySQLParser::UserVariableContext* MySQLParser::StatementInformationItemContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

MySQLParser::IdentifierContext* MySQLParser::StatementInformationItemContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::StatementInformationItemContext::getRuleIndex() const {
  return MySQLParser::RuleStatementInformationItem;
}

void MySQLParser::StatementInformationItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStatementInformationItem(this);
}

void MySQLParser::StatementInformationItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStatementInformationItem(this);
}


std::any MySQLParser::StatementInformationItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStatementInformationItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StatementInformationItemContext* MySQLParser::statementInformationItem() {
  StatementInformationItemContext *_localctx = _tracker.createInstance<StatementInformationItemContext>(_ctx, getState());
  enterRule(_localctx, 1108, MySQLParser::RuleStatementInformationItem);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7848);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 930, _ctx)) {
    case 1: {
      setState(7846);
      userVariable();
      break;
    }

    case 2: {
      setState(7847);
      identifier();
      break;
    }

    default:
      break;
    }
    setState(7850);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(7851);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NUMBER_SYMBOL || _la == MySQLParser::ROW_COUNT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConditionInformationItemContext ------------------------------------------------------------------

MySQLParser::ConditionInformationItemContext::ConditionInformationItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ConditionInformationItemContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::UserVariableContext* MySQLParser::ConditionInformationItemContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

MySQLParser::IdentifierContext* MySQLParser::ConditionInformationItemContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::SignalInformationItemNameContext* MySQLParser::ConditionInformationItemContext::signalInformationItemName() {
  return getRuleContext<MySQLParser::SignalInformationItemNameContext>(0);
}

tree::TerminalNode* MySQLParser::ConditionInformationItemContext::RETURNED_SQLSTATE_SYMBOL() {
  return getToken(MySQLParser::RETURNED_SQLSTATE_SYMBOL, 0);
}


size_t MySQLParser::ConditionInformationItemContext::getRuleIndex() const {
  return MySQLParser::RuleConditionInformationItem;
}

void MySQLParser::ConditionInformationItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConditionInformationItem(this);
}

void MySQLParser::ConditionInformationItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConditionInformationItem(this);
}


std::any MySQLParser::ConditionInformationItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitConditionInformationItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ConditionInformationItemContext* MySQLParser::conditionInformationItem() {
  ConditionInformationItemContext *_localctx = _tracker.createInstance<ConditionInformationItemContext>(_ctx, getState());
  enterRule(_localctx, 1110, MySQLParser::RuleConditionInformationItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7855);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 931, _ctx)) {
    case 1: {
      setState(7853);
      userVariable();
      break;
    }

    case 2: {
      setState(7854);
      identifier();
      break;
    }

    default:
      break;
    }
    setState(7857);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(7860);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CATALOG_NAME_SYMBOL:
      case MySQLParser::CLASS_ORIGIN_SYMBOL:
      case MySQLParser::COLUMN_NAME_SYMBOL:
      case MySQLParser::CONSTRAINT_CATALOG_SYMBOL:
      case MySQLParser::CONSTRAINT_NAME_SYMBOL:
      case MySQLParser::CONSTRAINT_SCHEMA_SYMBOL:
      case MySQLParser::CURSOR_NAME_SYMBOL:
      case MySQLParser::MESSAGE_TEXT_SYMBOL:
      case MySQLParser::MYSQL_ERRNO_SYMBOL:
      case MySQLParser::SCHEMA_NAME_SYMBOL:
      case MySQLParser::SUBCLASS_ORIGIN_SYMBOL:
      case MySQLParser::TABLE_NAME_SYMBOL: {
        setState(7858);
        signalInformationItemName();
        break;
      }

      case MySQLParser::RETURNED_SQLSTATE_SYMBOL: {
        setState(7859);
        match(MySQLParser::RETURNED_SQLSTATE_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SignalInformationItemNameContext ------------------------------------------------------------------

MySQLParser::SignalInformationItemNameContext::SignalInformationItemNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::CLASS_ORIGIN_SYMBOL() {
  return getToken(MySQLParser::CLASS_ORIGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::SUBCLASS_ORIGIN_SYMBOL() {
  return getToken(MySQLParser::SUBCLASS_ORIGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::CONSTRAINT_CATALOG_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_CATALOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::CONSTRAINT_SCHEMA_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_SCHEMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::CONSTRAINT_NAME_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::CATALOG_NAME_SYMBOL() {
  return getToken(MySQLParser::CATALOG_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::SCHEMA_NAME_SYMBOL() {
  return getToken(MySQLParser::SCHEMA_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::TABLE_NAME_SYMBOL() {
  return getToken(MySQLParser::TABLE_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::COLUMN_NAME_SYMBOL() {
  return getToken(MySQLParser::COLUMN_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::CURSOR_NAME_SYMBOL() {
  return getToken(MySQLParser::CURSOR_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::MESSAGE_TEXT_SYMBOL() {
  return getToken(MySQLParser::MESSAGE_TEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemNameContext::MYSQL_ERRNO_SYMBOL() {
  return getToken(MySQLParser::MYSQL_ERRNO_SYMBOL, 0);
}


size_t MySQLParser::SignalInformationItemNameContext::getRuleIndex() const {
  return MySQLParser::RuleSignalInformationItemName;
}

void MySQLParser::SignalInformationItemNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSignalInformationItemName(this);
}

void MySQLParser::SignalInformationItemNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSignalInformationItemName(this);
}


std::any MySQLParser::SignalInformationItemNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSignalInformationItemName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SignalInformationItemNameContext* MySQLParser::signalInformationItemName() {
  SignalInformationItemNameContext *_localctx = _tracker.createInstance<SignalInformationItemNameContext>(_ctx, getState());
  enterRule(_localctx, 1112, MySQLParser::RuleSignalInformationItemName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7862);
    _la = _input->LA(1);
    if (!(((((_la - 98) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 98)) & ((1ULL << (MySQLParser::CATALOG_NAME_SYMBOL - 98))
      | (1ULL << (MySQLParser::CLASS_ORIGIN_SYMBOL - 98))
      | (1ULL << (MySQLParser::COLUMN_NAME_SYMBOL - 98))
      | (1ULL << (MySQLParser::CONSTRAINT_CATALOG_SYMBOL - 98))
      | (1ULL << (MySQLParser::CONSTRAINT_NAME_SYMBOL - 98))
      | (1ULL << (MySQLParser::CONSTRAINT_SCHEMA_SYMBOL - 98))
      | (1ULL << (MySQLParser::CURSOR_NAME_SYMBOL - 98)))) != 0) || _la == MySQLParser::MESSAGE_TEXT_SYMBOL

    || _la == MySQLParser::MYSQL_ERRNO_SYMBOL || _la == MySQLParser::SCHEMA_NAME_SYMBOL

    || _la == MySQLParser::SUBCLASS_ORIGIN_SYMBOL || _la == MySQLParser::TABLE_NAME_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SignalStatementContext ------------------------------------------------------------------

MySQLParser::SignalStatementContext::SignalStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SignalStatementContext::SIGNAL_SYMBOL() {
  return getToken(MySQLParser::SIGNAL_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::SignalStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::SqlstateContext* MySQLParser::SignalStatementContext::sqlstate() {
  return getRuleContext<MySQLParser::SqlstateContext>(0);
}

tree::TerminalNode* MySQLParser::SignalStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

std::vector<MySQLParser::SignalInformationItemContext *> MySQLParser::SignalStatementContext::signalInformationItem() {
  return getRuleContexts<MySQLParser::SignalInformationItemContext>();
}

MySQLParser::SignalInformationItemContext* MySQLParser::SignalStatementContext::signalInformationItem(size_t i) {
  return getRuleContext<MySQLParser::SignalInformationItemContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::SignalStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::SignalStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::SignalStatementContext::getRuleIndex() const {
  return MySQLParser::RuleSignalStatement;
}

void MySQLParser::SignalStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSignalStatement(this);
}

void MySQLParser::SignalStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSignalStatement(this);
}


std::any MySQLParser::SignalStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSignalStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SignalStatementContext* MySQLParser::signalStatement() {
  SignalStatementContext *_localctx = _tracker.createInstance<SignalStatementContext>(_ctx, getState());
  enterRule(_localctx, 1114, MySQLParser::RuleSignalStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7864);
    match(MySQLParser::SIGNAL_SYMBOL);
    setState(7867);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 933, _ctx)) {
    case 1: {
      setState(7865);
      identifier();
      break;
    }

    case 2: {
      setState(7866);
      sqlstate();
      break;
    }

    default:
      break;
    }
    setState(7878);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SET_SYMBOL) {
      setState(7869);
      match(MySQLParser::SET_SYMBOL);
      setState(7870);
      signalInformationItem();
      setState(7875);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7871);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7872);
        signalInformationItem();
        setState(7877);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResignalStatementContext ------------------------------------------------------------------

MySQLParser::ResignalStatementContext::ResignalStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ResignalStatementContext::RESIGNAL_SYMBOL() {
  return getToken(MySQLParser::RESIGNAL_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::ResignalStatementContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::SqlstateContext* MySQLParser::ResignalStatementContext::sqlstate() {
  return getRuleContext<MySQLParser::SqlstateContext>(0);
}

tree::TerminalNode* MySQLParser::ResignalStatementContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

std::vector<MySQLParser::SignalInformationItemContext *> MySQLParser::ResignalStatementContext::signalInformationItem() {
  return getRuleContexts<MySQLParser::SignalInformationItemContext>();
}

MySQLParser::SignalInformationItemContext* MySQLParser::ResignalStatementContext::signalInformationItem(size_t i) {
  return getRuleContext<MySQLParser::SignalInformationItemContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ResignalStatementContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ResignalStatementContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ResignalStatementContext::getRuleIndex() const {
  return MySQLParser::RuleResignalStatement;
}

void MySQLParser::ResignalStatementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResignalStatement(this);
}

void MySQLParser::ResignalStatementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResignalStatement(this);
}


std::any MySQLParser::ResignalStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResignalStatement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResignalStatementContext* MySQLParser::resignalStatement() {
  ResignalStatementContext *_localctx = _tracker.createInstance<ResignalStatementContext>(_ctx, getState());
  enterRule(_localctx, 1116, MySQLParser::RuleResignalStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7880);
    match(MySQLParser::RESIGNAL_SYMBOL);
    setState(7883);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 936, _ctx)) {
    case 1: {
      setState(7881);
      identifier();
      break;
    }

    case 2: {
      setState(7882);
      sqlstate();
      break;
    }

    default:
      break;
    }
    setState(7894);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SET_SYMBOL) {
      setState(7885);
      match(MySQLParser::SET_SYMBOL);
      setState(7886);
      signalInformationItem();
      setState(7891);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7887);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7888);
        signalInformationItem();
        setState(7893);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SignalInformationItemContext ------------------------------------------------------------------

MySQLParser::SignalInformationItemContext::SignalInformationItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SignalInformationItemNameContext* MySQLParser::SignalInformationItemContext::signalInformationItemName() {
  return getRuleContext<MySQLParser::SignalInformationItemNameContext>(0);
}

tree::TerminalNode* MySQLParser::SignalInformationItemContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::SignalAllowedExprContext* MySQLParser::SignalInformationItemContext::signalAllowedExpr() {
  return getRuleContext<MySQLParser::SignalAllowedExprContext>(0);
}


size_t MySQLParser::SignalInformationItemContext::getRuleIndex() const {
  return MySQLParser::RuleSignalInformationItem;
}

void MySQLParser::SignalInformationItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSignalInformationItem(this);
}

void MySQLParser::SignalInformationItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSignalInformationItem(this);
}


std::any MySQLParser::SignalInformationItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSignalInformationItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SignalInformationItemContext* MySQLParser::signalInformationItem() {
  SignalInformationItemContext *_localctx = _tracker.createInstance<SignalInformationItemContext>(_ctx, getState());
  enterRule(_localctx, 1118, MySQLParser::RuleSignalInformationItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7896);
    signalInformationItemName();
    setState(7897);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(7898);
    signalAllowedExpr();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CursorOpenContext ------------------------------------------------------------------

MySQLParser::CursorOpenContext::CursorOpenContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CursorOpenContext::OPEN_SYMBOL() {
  return getToken(MySQLParser::OPEN_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CursorOpenContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::CursorOpenContext::getRuleIndex() const {
  return MySQLParser::RuleCursorOpen;
}

void MySQLParser::CursorOpenContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCursorOpen(this);
}

void MySQLParser::CursorOpenContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCursorOpen(this);
}


std::any MySQLParser::CursorOpenContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCursorOpen(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CursorOpenContext* MySQLParser::cursorOpen() {
  CursorOpenContext *_localctx = _tracker.createInstance<CursorOpenContext>(_ctx, getState());
  enterRule(_localctx, 1120, MySQLParser::RuleCursorOpen);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7900);
    match(MySQLParser::OPEN_SYMBOL);
    setState(7901);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CursorCloseContext ------------------------------------------------------------------

MySQLParser::CursorCloseContext::CursorCloseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CursorCloseContext::CLOSE_SYMBOL() {
  return getToken(MySQLParser::CLOSE_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CursorCloseContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::CursorCloseContext::getRuleIndex() const {
  return MySQLParser::RuleCursorClose;
}

void MySQLParser::CursorCloseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCursorClose(this);
}

void MySQLParser::CursorCloseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCursorClose(this);
}


std::any MySQLParser::CursorCloseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCursorClose(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CursorCloseContext* MySQLParser::cursorClose() {
  CursorCloseContext *_localctx = _tracker.createInstance<CursorCloseContext>(_ctx, getState());
  enterRule(_localctx, 1122, MySQLParser::RuleCursorClose);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7903);
    match(MySQLParser::CLOSE_SYMBOL);
    setState(7904);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CursorFetchContext ------------------------------------------------------------------

MySQLParser::CursorFetchContext::CursorFetchContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CursorFetchContext::FETCH_SYMBOL() {
  return getToken(MySQLParser::FETCH_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CursorFetchContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CursorFetchContext::INTO_SYMBOL() {
  return getToken(MySQLParser::INTO_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::CursorFetchContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

tree::TerminalNode* MySQLParser::CursorFetchContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CursorFetchContext::NEXT_SYMBOL() {
  return getToken(MySQLParser::NEXT_SYMBOL, 0);
}


size_t MySQLParser::CursorFetchContext::getRuleIndex() const {
  return MySQLParser::RuleCursorFetch;
}

void MySQLParser::CursorFetchContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCursorFetch(this);
}

void MySQLParser::CursorFetchContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCursorFetch(this);
}


std::any MySQLParser::CursorFetchContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCursorFetch(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CursorFetchContext* MySQLParser::cursorFetch() {
  CursorFetchContext *_localctx = _tracker.createInstance<CursorFetchContext>(_ctx, getState());
  enterRule(_localctx, 1124, MySQLParser::RuleCursorFetch);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7906);
    match(MySQLParser::FETCH_SYMBOL);
    setState(7911);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 940, _ctx)) {
    case 1: {
      setState(7908);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NEXT_SYMBOL) {
        setState(7907);
        match(MySQLParser::NEXT_SYMBOL);
      }
      setState(7910);
      match(MySQLParser::FROM_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(7913);
    identifier();
    setState(7914);
    match(MySQLParser::INTO_SYMBOL);
    setState(7915);
    identifierList();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ScheduleContext ------------------------------------------------------------------

MySQLParser::ScheduleContext::ScheduleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ScheduleContext::AT_SYMBOL() {
  return getToken(MySQLParser::AT_SYMBOL, 0);
}

std::vector<MySQLParser::ExprContext *> MySQLParser::ScheduleContext::expr() {
  return getRuleContexts<MySQLParser::ExprContext>();
}

MySQLParser::ExprContext* MySQLParser::ScheduleContext::expr(size_t i) {
  return getRuleContext<MySQLParser::ExprContext>(i);
}

tree::TerminalNode* MySQLParser::ScheduleContext::EVERY_SYMBOL() {
  return getToken(MySQLParser::EVERY_SYMBOL, 0);
}

MySQLParser::IntervalContext* MySQLParser::ScheduleContext::interval() {
  return getRuleContext<MySQLParser::IntervalContext>(0);
}

tree::TerminalNode* MySQLParser::ScheduleContext::STARTS_SYMBOL() {
  return getToken(MySQLParser::STARTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ScheduleContext::ENDS_SYMBOL() {
  return getToken(MySQLParser::ENDS_SYMBOL, 0);
}


size_t MySQLParser::ScheduleContext::getRuleIndex() const {
  return MySQLParser::RuleSchedule;
}

void MySQLParser::ScheduleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSchedule(this);
}

void MySQLParser::ScheduleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSchedule(this);
}


std::any MySQLParser::ScheduleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSchedule(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ScheduleContext* MySQLParser::schedule() {
  ScheduleContext *_localctx = _tracker.createInstance<ScheduleContext>(_ctx, getState());
  enterRule(_localctx, 1126, MySQLParser::RuleSchedule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7930);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::AT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7917);
        match(MySQLParser::AT_SYMBOL);
        setState(7918);
        expr(0);
        break;
      }

      case MySQLParser::EVERY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7919);
        match(MySQLParser::EVERY_SYMBOL);
        setState(7920);
        expr(0);
        setState(7921);
        interval();
        setState(7924);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::STARTS_SYMBOL) {
          setState(7922);
          match(MySQLParser::STARTS_SYMBOL);
          setState(7923);
          expr(0);
        }
        setState(7928);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ENDS_SYMBOL) {
          setState(7926);
          match(MySQLParser::ENDS_SYMBOL);
          setState(7927);
          expr(0);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnDefinitionContext ------------------------------------------------------------------

MySQLParser::ColumnDefinitionContext::ColumnDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ColumnNameContext* MySQLParser::ColumnDefinitionContext::columnName() {
  return getRuleContext<MySQLParser::ColumnNameContext>(0);
}

MySQLParser::FieldDefinitionContext* MySQLParser::ColumnDefinitionContext::fieldDefinition() {
  return getRuleContext<MySQLParser::FieldDefinitionContext>(0);
}

MySQLParser::CheckOrReferencesContext* MySQLParser::ColumnDefinitionContext::checkOrReferences() {
  return getRuleContext<MySQLParser::CheckOrReferencesContext>(0);
}


size_t MySQLParser::ColumnDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleColumnDefinition;
}

void MySQLParser::ColumnDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnDefinition(this);
}

void MySQLParser::ColumnDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnDefinition(this);
}


std::any MySQLParser::ColumnDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnDefinitionContext* MySQLParser::columnDefinition() {
  ColumnDefinitionContext *_localctx = _tracker.createInstance<ColumnDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 1128, MySQLParser::RuleColumnDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7932);
    columnName();
    setState(7933);
    fieldDefinition();
    setState(7935);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 944, _ctx)) {
    case 1: {
      setState(7934);
      checkOrReferences();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CheckOrReferencesContext ------------------------------------------------------------------

MySQLParser::CheckOrReferencesContext::CheckOrReferencesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CheckConstraintContext* MySQLParser::CheckOrReferencesContext::checkConstraint() {
  return getRuleContext<MySQLParser::CheckConstraintContext>(0);
}

MySQLParser::ReferencesContext* MySQLParser::CheckOrReferencesContext::references() {
  return getRuleContext<MySQLParser::ReferencesContext>(0);
}


size_t MySQLParser::CheckOrReferencesContext::getRuleIndex() const {
  return MySQLParser::RuleCheckOrReferences;
}

void MySQLParser::CheckOrReferencesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCheckOrReferences(this);
}

void MySQLParser::CheckOrReferencesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCheckOrReferences(this);
}


std::any MySQLParser::CheckOrReferencesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCheckOrReferences(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CheckOrReferencesContext* MySQLParser::checkOrReferences() {
  CheckOrReferencesContext *_localctx = _tracker.createInstance<CheckOrReferencesContext>(_ctx, getState());
  enterRule(_localctx, 1130, MySQLParser::RuleCheckOrReferences);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7940);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 945, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7937);

      if (!(serverVersion < 80016)) throw FailedPredicateException(this, "serverVersion < 80016");
      setState(7938);
      checkConstraint();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7939);
      references();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CheckConstraintContext ------------------------------------------------------------------

MySQLParser::CheckConstraintContext::CheckConstraintContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CheckConstraintContext::CHECK_SYMBOL() {
  return getToken(MySQLParser::CHECK_SYMBOL, 0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::CheckConstraintContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}


size_t MySQLParser::CheckConstraintContext::getRuleIndex() const {
  return MySQLParser::RuleCheckConstraint;
}

void MySQLParser::CheckConstraintContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCheckConstraint(this);
}

void MySQLParser::CheckConstraintContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCheckConstraint(this);
}


std::any MySQLParser::CheckConstraintContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCheckConstraint(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CheckConstraintContext* MySQLParser::checkConstraint() {
  CheckConstraintContext *_localctx = _tracker.createInstance<CheckConstraintContext>(_ctx, getState());
  enterRule(_localctx, 1132, MySQLParser::RuleCheckConstraint);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7942);
    match(MySQLParser::CHECK_SYMBOL);
    setState(7943);
    exprWithParentheses();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConstraintEnforcementContext ------------------------------------------------------------------

MySQLParser::ConstraintEnforcementContext::ConstraintEnforcementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ConstraintEnforcementContext::ENFORCED_SYMBOL() {
  return getToken(MySQLParser::ENFORCED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ConstraintEnforcementContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}


size_t MySQLParser::ConstraintEnforcementContext::getRuleIndex() const {
  return MySQLParser::RuleConstraintEnforcement;
}

void MySQLParser::ConstraintEnforcementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConstraintEnforcement(this);
}

void MySQLParser::ConstraintEnforcementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConstraintEnforcement(this);
}


std::any MySQLParser::ConstraintEnforcementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitConstraintEnforcement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ConstraintEnforcementContext* MySQLParser::constraintEnforcement() {
  ConstraintEnforcementContext *_localctx = _tracker.createInstance<ConstraintEnforcementContext>(_ctx, getState());
  enterRule(_localctx, 1134, MySQLParser::RuleConstraintEnforcement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7945);

    if (!( serverVersion >= 80017)) throw FailedPredicateException(this, " serverVersion >= 80017");
    setState(7947);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::NOT_SYMBOL) {
      setState(7946);
      match(MySQLParser::NOT_SYMBOL);
    }
    setState(7949);
    match(MySQLParser::ENFORCED_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableConstraintDefContext ------------------------------------------------------------------

MySQLParser::TableConstraintDefContext::TableConstraintDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::KeyListWithExpressionContext* MySQLParser::TableConstraintDefContext::keyListWithExpression() {
  return getRuleContext<MySQLParser::KeyListWithExpressionContext>(0);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

MySQLParser::IndexNameAndTypeContext* MySQLParser::TableConstraintDefContext::indexNameAndType() {
  return getRuleContext<MySQLParser::IndexNameAndTypeContext>(0);
}

std::vector<MySQLParser::IndexOptionContext *> MySQLParser::TableConstraintDefContext::indexOption() {
  return getRuleContexts<MySQLParser::IndexOptionContext>();
}

MySQLParser::IndexOptionContext* MySQLParser::TableConstraintDefContext::indexOption(size_t i) {
  return getRuleContext<MySQLParser::IndexOptionContext>(i);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::FULLTEXT_SYMBOL() {
  return getToken(MySQLParser::FULLTEXT_SYMBOL, 0);
}

MySQLParser::KeyOrIndexContext* MySQLParser::TableConstraintDefContext::keyOrIndex() {
  return getRuleContext<MySQLParser::KeyOrIndexContext>(0);
}

MySQLParser::IndexNameContext* MySQLParser::TableConstraintDefContext::indexName() {
  return getRuleContext<MySQLParser::IndexNameContext>(0);
}

std::vector<MySQLParser::FulltextIndexOptionContext *> MySQLParser::TableConstraintDefContext::fulltextIndexOption() {
  return getRuleContexts<MySQLParser::FulltextIndexOptionContext>();
}

MySQLParser::FulltextIndexOptionContext* MySQLParser::TableConstraintDefContext::fulltextIndexOption(size_t i) {
  return getRuleContext<MySQLParser::FulltextIndexOptionContext>(i);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::SPATIAL_SYMBOL() {
  return getToken(MySQLParser::SPATIAL_SYMBOL, 0);
}

std::vector<MySQLParser::SpatialIndexOptionContext *> MySQLParser::TableConstraintDefContext::spatialIndexOption() {
  return getRuleContexts<MySQLParser::SpatialIndexOptionContext>();
}

MySQLParser::SpatialIndexOptionContext* MySQLParser::TableConstraintDefContext::spatialIndexOption(size_t i) {
  return getRuleContext<MySQLParser::SpatialIndexOptionContext>(i);
}

MySQLParser::KeyListContext* MySQLParser::TableConstraintDefContext::keyList() {
  return getRuleContext<MySQLParser::KeyListContext>(0);
}

MySQLParser::ReferencesContext* MySQLParser::TableConstraintDefContext::references() {
  return getRuleContext<MySQLParser::ReferencesContext>(0);
}

MySQLParser::CheckConstraintContext* MySQLParser::TableConstraintDefContext::checkConstraint() {
  return getRuleContext<MySQLParser::CheckConstraintContext>(0);
}

MySQLParser::ConstraintNameContext* MySQLParser::TableConstraintDefContext::constraintName() {
  return getRuleContext<MySQLParser::ConstraintNameContext>(0);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::FOREIGN_SYMBOL() {
  return getToken(MySQLParser::FOREIGN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableConstraintDefContext::UNIQUE_SYMBOL() {
  return getToken(MySQLParser::UNIQUE_SYMBOL, 0);
}

MySQLParser::ConstraintEnforcementContext* MySQLParser::TableConstraintDefContext::constraintEnforcement() {
  return getRuleContext<MySQLParser::ConstraintEnforcementContext>(0);
}


size_t MySQLParser::TableConstraintDefContext::getRuleIndex() const {
  return MySQLParser::RuleTableConstraintDef;
}

void MySQLParser::TableConstraintDefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableConstraintDef(this);
}

void MySQLParser::TableConstraintDefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableConstraintDef(this);
}


std::any MySQLParser::TableConstraintDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableConstraintDef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableConstraintDefContext* MySQLParser::tableConstraintDef() {
  TableConstraintDefContext *_localctx = _tracker.createInstance<TableConstraintDefContext>(_ctx, getState());
  enterRule(_localctx, 1136, MySQLParser::RuleTableConstraintDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(8025);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INDEX_SYMBOL:
      case MySQLParser::KEY_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7951);
        antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::INDEX_SYMBOL

        || _la == MySQLParser::KEY_SYMBOL)) {
          antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(7953);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 947, _ctx)) {
        case 1: {
          setState(7952);
          indexNameAndType();
          break;
        }

        default:
          break;
        }
        setState(7955);
        keyListWithExpression();
        setState(7959);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 948, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(7956);
            indexOption(); 
          }
          setState(7961);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 948, _ctx);
        }
        break;
      }

      case MySQLParser::FULLTEXT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7962);
        antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::FULLTEXT_SYMBOL);
        setState(7964);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 949, _ctx)) {
        case 1: {
          setState(7963);
          keyOrIndex();
          break;
        }

        default:
          break;
        }
        setState(7967);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 950, _ctx)) {
        case 1: {
          setState(7966);
          indexName();
          break;
        }

        default:
          break;
        }
        setState(7969);
        keyListWithExpression();
        setState(7973);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 951, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(7970);
            fulltextIndexOption(); 
          }
          setState(7975);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 951, _ctx);
        }
        break;
      }

      case MySQLParser::SPATIAL_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(7976);
        antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::SPATIAL_SYMBOL);
        setState(7978);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 952, _ctx)) {
        case 1: {
          setState(7977);
          keyOrIndex();
          break;
        }

        default:
          break;
        }
        setState(7981);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 953, _ctx)) {
        case 1: {
          setState(7980);
          indexName();
          break;
        }

        default:
          break;
        }
        setState(7983);
        keyListWithExpression();
        setState(7987);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 954, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(7984);
            spatialIndexOption(); 
          }
          setState(7989);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 954, _ctx);
        }
        break;
      }

      case MySQLParser::CHECK_SYMBOL:
      case MySQLParser::CONSTRAINT_SYMBOL:
      case MySQLParser::FOREIGN_SYMBOL:
      case MySQLParser::PRIMARY_SYMBOL:
      case MySQLParser::UNIQUE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(7991);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::CONSTRAINT_SYMBOL) {
          setState(7990);
          constraintName();
        }
        setState(8023);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::PRIMARY_SYMBOL:
          case MySQLParser::UNIQUE_SYMBOL: {
            setState(7999);
            _errHandler->sync(this);
            switch (_input->LA(1)) {
              case MySQLParser::PRIMARY_SYMBOL: {
                setState(7993);
                antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::PRIMARY_SYMBOL);
                setState(7994);
                match(MySQLParser::KEY_SYMBOL);
                break;
              }

              case MySQLParser::UNIQUE_SYMBOL: {
                setState(7995);
                antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::UNIQUE_SYMBOL);
                setState(7997);
                _errHandler->sync(this);

                switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 956, _ctx)) {
                case 1: {
                  setState(7996);
                  keyOrIndex();
                  break;
                }

                default:
                  break;
                }
                break;
              }

            default:
              throw NoViableAltException(this);
            }
            setState(8002);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 958, _ctx)) {
            case 1: {
              setState(8001);
              indexNameAndType();
              break;
            }

            default:
              break;
            }
            setState(8004);
            keyListWithExpression();
            setState(8008);
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 959, _ctx);
            while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
              if (alt == 1) {
                setState(8005);
                indexOption(); 
              }
              setState(8010);
              _errHandler->sync(this);
              alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 959, _ctx);
            }
            break;
          }

          case MySQLParser::FOREIGN_SYMBOL: {
            setState(8011);
            antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::FOREIGN_SYMBOL);
            setState(8012);
            match(MySQLParser::KEY_SYMBOL);
            setState(8014);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 960, _ctx)) {
            case 1: {
              setState(8013);
              indexName();
              break;
            }

            default:
              break;
            }
            setState(8016);
            keyList();
            setState(8017);
            references();
            break;
          }

          case MySQLParser::CHECK_SYMBOL: {
            setState(8019);
            checkConstraint();
            setState(8021);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 961, _ctx)) {
            case 1: {
              setState(8020);
              constraintEnforcement();
              break;
            }

            default:
              break;
            }
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConstraintNameContext ------------------------------------------------------------------

MySQLParser::ConstraintNameContext::ConstraintNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ConstraintNameContext::CONSTRAINT_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::ConstraintNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::ConstraintNameContext::getRuleIndex() const {
  return MySQLParser::RuleConstraintName;
}

void MySQLParser::ConstraintNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConstraintName(this);
}

void MySQLParser::ConstraintNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConstraintName(this);
}


std::any MySQLParser::ConstraintNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitConstraintName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ConstraintNameContext* MySQLParser::constraintName() {
  ConstraintNameContext *_localctx = _tracker.createInstance<ConstraintNameContext>(_ctx, getState());
  enterRule(_localctx, 1138, MySQLParser::RuleConstraintName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8027);
    match(MySQLParser::CONSTRAINT_SYMBOL);
    setState(8029);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 964, _ctx)) {
    case 1: {
      setState(8028);
      identifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldDefinitionContext ------------------------------------------------------------------

MySQLParser::FieldDefinitionContext::FieldDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::DataTypeContext* MySQLParser::FieldDefinitionContext::dataType() {
  return getRuleContext<MySQLParser::DataTypeContext>(0);
}

tree::TerminalNode* MySQLParser::FieldDefinitionContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::FieldDefinitionContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

std::vector<MySQLParser::ColumnAttributeContext *> MySQLParser::FieldDefinitionContext::columnAttribute() {
  return getRuleContexts<MySQLParser::ColumnAttributeContext>();
}

MySQLParser::ColumnAttributeContext* MySQLParser::FieldDefinitionContext::columnAttribute(size_t i) {
  return getRuleContext<MySQLParser::ColumnAttributeContext>(i);
}

MySQLParser::CollateContext* MySQLParser::FieldDefinitionContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}

tree::TerminalNode* MySQLParser::FieldDefinitionContext::GENERATED_SYMBOL() {
  return getToken(MySQLParser::GENERATED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldDefinitionContext::ALWAYS_SYMBOL() {
  return getToken(MySQLParser::ALWAYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldDefinitionContext::VIRTUAL_SYMBOL() {
  return getToken(MySQLParser::VIRTUAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldDefinitionContext::STORED_SYMBOL() {
  return getToken(MySQLParser::STORED_SYMBOL, 0);
}

std::vector<MySQLParser::GcolAttributeContext *> MySQLParser::FieldDefinitionContext::gcolAttribute() {
  return getRuleContexts<MySQLParser::GcolAttributeContext>();
}

MySQLParser::GcolAttributeContext* MySQLParser::FieldDefinitionContext::gcolAttribute(size_t i) {
  return getRuleContext<MySQLParser::GcolAttributeContext>(i);
}


size_t MySQLParser::FieldDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleFieldDefinition;
}

void MySQLParser::FieldDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldDefinition(this);
}

void MySQLParser::FieldDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldDefinition(this);
}


std::any MySQLParser::FieldDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldDefinitionContext* MySQLParser::fieldDefinition() {
  FieldDefinitionContext *_localctx = _tracker.createInstance<FieldDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 1140, MySQLParser::RuleFieldDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8031);
    dataType();
    setState(8067);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 972, _ctx)) {
    case 1: {
      setState(8035);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 965, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(8032);
          columnAttribute(); 
        }
        setState(8037);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 965, _ctx);
      }
      break;
    }

    case 2: {
      setState(8038);

      if (!(serverVersion >= 50707)) throw FailedPredicateException(this, "serverVersion >= 50707");
      setState(8040);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COLLATE_SYMBOL) {
        setState(8039);
        collate();
      }
      setState(8044);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::GENERATED_SYMBOL) {
        setState(8042);
        match(MySQLParser::GENERATED_SYMBOL);
        setState(8043);
        match(MySQLParser::ALWAYS_SYMBOL);
      }
      setState(8046);
      match(MySQLParser::AS_SYMBOL);
      setState(8047);
      exprWithParentheses();
      setState(8049);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 968, _ctx)) {
      case 1: {
        setState(8048);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::STORED_SYMBOL || _la == MySQLParser::VIRTUAL_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      default:
        break;
      }
      setState(8065);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 971, _ctx)) {
      case 1: {
        setState(8051);

        if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
        setState(8055);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 969, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(8052);
            gcolAttribute(); 
          }
          setState(8057);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 969, _ctx);
        }
        break;
      }

      case 2: {
        setState(8058);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(8062);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 970, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(8059);
            columnAttribute(); 
          }
          setState(8064);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 970, _ctx);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnAttributeContext ------------------------------------------------------------------

MySQLParser::ColumnAttributeContext::ColumnAttributeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::NullLiteralContext* MySQLParser::ColumnAttributeContext::nullLiteral() {
  return getRuleContext<MySQLParser::NullLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::SECONDARY_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::NowOrSignedLiteralContext* MySQLParser::ColumnAttributeContext::nowOrSignedLiteral() {
  return getRuleContext<MySQLParser::NowOrSignedLiteralContext>(0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::ColumnAttributeContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::NOW_SYMBOL() {
  return getToken(MySQLParser::NOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::TimeFunctionParametersContext* MySQLParser::ColumnAttributeContext::timeFunctionParameters() {
  return getRuleContext<MySQLParser::TimeFunctionParametersContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::AUTO_INCREMENT_SYMBOL() {
  return getToken(MySQLParser::AUTO_INCREMENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::VALUE_SYMBOL() {
  return getToken(MySQLParser::VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::SERIAL_SYMBOL() {
  return getToken(MySQLParser::SERIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::UNIQUE_SYMBOL() {
  return getToken(MySQLParser::UNIQUE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::ColumnAttributeContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::CollateContext* MySQLParser::ColumnAttributeContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}

MySQLParser::ColumnFormatContext* MySQLParser::ColumnAttributeContext::columnFormat() {
  return getRuleContext<MySQLParser::ColumnFormatContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::COLUMN_FORMAT_SYMBOL() {
  return getToken(MySQLParser::COLUMN_FORMAT_SYMBOL, 0);
}

MySQLParser::StorageMediaContext* MySQLParser::ColumnAttributeContext::storageMedia() {
  return getRuleContext<MySQLParser::StorageMediaContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::ColumnAttributeContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::SRID_SYMBOL() {
  return getToken(MySQLParser::SRID_SYMBOL, 0);
}

MySQLParser::CheckConstraintContext* MySQLParser::ColumnAttributeContext::checkConstraint() {
  return getRuleContext<MySQLParser::CheckConstraintContext>(0);
}

MySQLParser::ConstraintNameContext* MySQLParser::ColumnAttributeContext::constraintName() {
  return getRuleContext<MySQLParser::ConstraintNameContext>(0);
}

MySQLParser::ConstraintEnforcementContext* MySQLParser::ColumnAttributeContext::constraintEnforcement() {
  return getRuleContext<MySQLParser::ConstraintEnforcementContext>(0);
}

MySQLParser::JsonAttributeContext* MySQLParser::ColumnAttributeContext::jsonAttribute() {
  return getRuleContext<MySQLParser::JsonAttributeContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL, 0);
}

MySQLParser::VisibilityContext* MySQLParser::ColumnAttributeContext::visibility() {
  return getRuleContext<MySQLParser::VisibilityContext>(0);
}


size_t MySQLParser::ColumnAttributeContext::getRuleIndex() const {
  return MySQLParser::RuleColumnAttribute;
}

void MySQLParser::ColumnAttributeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnAttribute(this);
}

void MySQLParser::ColumnAttributeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnAttribute(this);
}


std::any MySQLParser::ColumnAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnAttribute(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnAttributeContext* MySQLParser::columnAttribute() {
  ColumnAttributeContext *_localctx = _tracker.createInstance<ColumnAttributeContext>(_ctx, getState());
  enterRule(_localctx, 1142, MySQLParser::RuleColumnAttribute);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8131);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 981, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8070);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(8069);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(8072);
      nullLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8073);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(8074);
      match(MySQLParser::NOT_SYMBOL);
      setState(8075);
      match(MySQLParser::SECONDARY_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8076);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::DEFAULT_SYMBOL);
      setState(8080);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 974, _ctx)) {
      case 1: {
        setState(8077);
        nowOrSignedLiteral();
        break;
      }

      case 2: {
        setState(8078);

        if (!(serverVersion >= 80013)) throw FailedPredicateException(this, "serverVersion >= 80013");
        setState(8079);
        exprWithParentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8082);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::ON_SYMBOL);
      setState(8083);
      match(MySQLParser::UPDATE_SYMBOL);
      setState(8084);
      match(MySQLParser::NOW_SYMBOL);
      setState(8086);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 975, _ctx)) {
      case 1: {
        setState(8085);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(8088);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::AUTO_INCREMENT_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(8089);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::SERIAL_SYMBOL);
      setState(8090);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(8091);
      match(MySQLParser::VALUE_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(8093);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::PRIMARY_SYMBOL) {
        setState(8092);
        match(MySQLParser::PRIMARY_SYMBOL);
      }
      setState(8095);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::KEY_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(8096);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::UNIQUE_SYMBOL);
      setState(8098);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 977, _ctx)) {
      case 1: {
        setState(8097);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(8100);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::COMMENT_SYMBOL);
      setState(8101);
      textLiteral();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(8102);
      collate();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(8103);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::COLUMN_FORMAT_SYMBOL);
      setState(8104);
      columnFormat();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(8105);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::STORAGE_SYMBOL);
      setState(8106);
      storageMedia();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(8107);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(8108);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::SRID_SYMBOL);
      setState(8109);
      real_ulonglong_number();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(8110);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(8112);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::CONSTRAINT_SYMBOL) {
        setState(8111);
        constraintName();
      }
      setState(8114);
      checkConstraint();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(8115);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(8116);
      constraintEnforcement();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(8117);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8118);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL);
      setState(8120);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 979, _ctx)) {
      case 1: {
        setState(8119);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8122);
      jsonAttribute();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(8123);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8124);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL);
      setState(8126);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 980, _ctx)) {
      case 1: {
        setState(8125);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8128);
      jsonAttribute();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(8129);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8130);
      visibility();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnFormatContext ------------------------------------------------------------------

MySQLParser::ColumnFormatContext::ColumnFormatContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ColumnFormatContext::FIXED_SYMBOL() {
  return getToken(MySQLParser::FIXED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnFormatContext::DYNAMIC_SYMBOL() {
  return getToken(MySQLParser::DYNAMIC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnFormatContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}


size_t MySQLParser::ColumnFormatContext::getRuleIndex() const {
  return MySQLParser::RuleColumnFormat;
}

void MySQLParser::ColumnFormatContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnFormat(this);
}

void MySQLParser::ColumnFormatContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnFormat(this);
}


std::any MySQLParser::ColumnFormatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnFormat(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnFormatContext* MySQLParser::columnFormat() {
  ColumnFormatContext *_localctx = _tracker.createInstance<ColumnFormatContext>(_ctx, getState());
  enterRule(_localctx, 1144, MySQLParser::RuleColumnFormat);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8133);
    _la = _input->LA(1);
    if (!(((((_la - 168) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 168)) & ((1ULL << (MySQLParser::DEFAULT_SYMBOL - 168))
      | (1ULL << (MySQLParser::DYNAMIC_SYMBOL - 168))
      | (1ULL << (MySQLParser::FIXED_SYMBOL - 168)))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StorageMediaContext ------------------------------------------------------------------

MySQLParser::StorageMediaContext::StorageMediaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StorageMediaContext::DISK_SYMBOL() {
  return getToken(MySQLParser::DISK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StorageMediaContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::StorageMediaContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}


size_t MySQLParser::StorageMediaContext::getRuleIndex() const {
  return MySQLParser::RuleStorageMedia;
}

void MySQLParser::StorageMediaContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStorageMedia(this);
}

void MySQLParser::StorageMediaContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStorageMedia(this);
}


std::any MySQLParser::StorageMediaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStorageMedia(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StorageMediaContext* MySQLParser::storageMedia() {
  StorageMediaContext *_localctx = _tracker.createInstance<StorageMediaContext>(_ctx, getState());
  enterRule(_localctx, 1146, MySQLParser::RuleStorageMedia);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8135);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DEFAULT_SYMBOL

    || _la == MySQLParser::DISK_SYMBOL || _la == MySQLParser::MEMORY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NowContext ------------------------------------------------------------------

MySQLParser::NowContext::NowContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NowContext::NOW_SYMBOL() {
  return getToken(MySQLParser::NOW_SYMBOL, 0);
}

MySQLParser::FunctionDatetimePrecisionContext* MySQLParser::NowContext::functionDatetimePrecision() {
  return getRuleContext<MySQLParser::FunctionDatetimePrecisionContext>(0);
}


size_t MySQLParser::NowContext::getRuleIndex() const {
  return MySQLParser::RuleNow;
}

void MySQLParser::NowContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNow(this);
}

void MySQLParser::NowContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNow(this);
}


std::any MySQLParser::NowContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNow(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NowContext* MySQLParser::now() {
  NowContext *_localctx = _tracker.createInstance<NowContext>(_ctx, getState());
  enterRule(_localctx, 1148, MySQLParser::RuleNow);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8137);
    match(MySQLParser::NOW_SYMBOL);
    setState(8138);
    functionDatetimePrecision();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NowOrSignedLiteralContext ------------------------------------------------------------------

MySQLParser::NowOrSignedLiteralContext::NowOrSignedLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::NowContext* MySQLParser::NowOrSignedLiteralContext::now() {
  return getRuleContext<MySQLParser::NowContext>(0);
}

MySQLParser::SignedLiteralOrNullContext* MySQLParser::NowOrSignedLiteralContext::signedLiteralOrNull() {
  return getRuleContext<MySQLParser::SignedLiteralOrNullContext>(0);
}


size_t MySQLParser::NowOrSignedLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleNowOrSignedLiteral;
}

void MySQLParser::NowOrSignedLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNowOrSignedLiteral(this);
}

void MySQLParser::NowOrSignedLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNowOrSignedLiteral(this);
}


std::any MySQLParser::NowOrSignedLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNowOrSignedLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NowOrSignedLiteralContext* MySQLParser::nowOrSignedLiteral() {
  NowOrSignedLiteralContext *_localctx = _tracker.createInstance<NowOrSignedLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1150, MySQLParser::RuleNowOrSignedLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8142);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 982, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8140);
      now();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8141);
      signedLiteralOrNull();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- GcolAttributeContext ------------------------------------------------------------------

MySQLParser::GcolAttributeContext::GcolAttributeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::GcolAttributeContext::UNIQUE_SYMBOL() {
  return getToken(MySQLParser::UNIQUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GcolAttributeContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GcolAttributeContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::GcolAttributeContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::GcolAttributeContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

MySQLParser::NotRuleContext* MySQLParser::GcolAttributeContext::notRule() {
  return getRuleContext<MySQLParser::NotRuleContext>(0);
}

tree::TerminalNode* MySQLParser::GcolAttributeContext::PRIMARY_SYMBOL() {
  return getToken(MySQLParser::PRIMARY_SYMBOL, 0);
}


size_t MySQLParser::GcolAttributeContext::getRuleIndex() const {
  return MySQLParser::RuleGcolAttribute;
}

void MySQLParser::GcolAttributeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterGcolAttribute(this);
}

void MySQLParser::GcolAttributeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitGcolAttribute(this);
}


std::any MySQLParser::GcolAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitGcolAttribute(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::GcolAttributeContext* MySQLParser::gcolAttribute() {
  GcolAttributeContext *_localctx = _tracker.createInstance<GcolAttributeContext>(_ctx, getState());
  enterRule(_localctx, 1152, MySQLParser::RuleGcolAttribute);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8158);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UNIQUE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8144);
        match(MySQLParser::UNIQUE_SYMBOL);
        setState(8146);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 983, _ctx)) {
        case 1: {
          setState(8145);
          match(MySQLParser::KEY_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8148);
        match(MySQLParser::COMMENT_SYMBOL);
        setState(8149);
        textString();
        break;
      }

      case MySQLParser::NOT2_SYMBOL:
      case MySQLParser::NOT_SYMBOL:
      case MySQLParser::NULL_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(8151);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NOT2_SYMBOL || _la == MySQLParser::NOT_SYMBOL) {
          setState(8150);
          notRule();
        }
        setState(8153);
        match(MySQLParser::NULL_SYMBOL);
        break;
      }

      case MySQLParser::KEY_SYMBOL:
      case MySQLParser::PRIMARY_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(8155);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::PRIMARY_SYMBOL) {
          setState(8154);
          match(MySQLParser::PRIMARY_SYMBOL);
        }
        setState(8157);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReferencesContext ------------------------------------------------------------------

MySQLParser::ReferencesContext::ReferencesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReferencesContext::REFERENCES_SYMBOL() {
  return getToken(MySQLParser::REFERENCES_SYMBOL, 0);
}

MySQLParser::TableRefContext* MySQLParser::ReferencesContext::tableRef() {
  return getRuleContext<MySQLParser::TableRefContext>(0);
}

MySQLParser::IdentifierListWithParenthesesContext* MySQLParser::ReferencesContext::identifierListWithParentheses() {
  return getRuleContext<MySQLParser::IdentifierListWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::ReferencesContext::MATCH_SYMBOL() {
  return getToken(MySQLParser::MATCH_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ReferencesContext::ON_SYMBOL() {
  return getTokens(MySQLParser::ON_SYMBOL);
}

tree::TerminalNode* MySQLParser::ReferencesContext::ON_SYMBOL(size_t i) {
  return getToken(MySQLParser::ON_SYMBOL, i);
}

std::vector<MySQLParser::DeleteOptionContext *> MySQLParser::ReferencesContext::deleteOption() {
  return getRuleContexts<MySQLParser::DeleteOptionContext>();
}

MySQLParser::DeleteOptionContext* MySQLParser::ReferencesContext::deleteOption(size_t i) {
  return getRuleContext<MySQLParser::DeleteOptionContext>(i);
}

tree::TerminalNode* MySQLParser::ReferencesContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReferencesContext::DELETE_SYMBOL() {
  return getToken(MySQLParser::DELETE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReferencesContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReferencesContext::PARTIAL_SYMBOL() {
  return getToken(MySQLParser::PARTIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReferencesContext::SIMPLE_SYMBOL() {
  return getToken(MySQLParser::SIMPLE_SYMBOL, 0);
}


size_t MySQLParser::ReferencesContext::getRuleIndex() const {
  return MySQLParser::RuleReferences;
}

void MySQLParser::ReferencesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReferences(this);
}

void MySQLParser::ReferencesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReferences(this);
}


std::any MySQLParser::ReferencesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReferences(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReferencesContext* MySQLParser::references() {
  ReferencesContext *_localctx = _tracker.createInstance<ReferencesContext>(_ctx, getState());
  enterRule(_localctx, 1154, MySQLParser::RuleReferences);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8160);
    match(MySQLParser::REFERENCES_SYMBOL);
    setState(8161);
    tableRef();
    setState(8163);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(8162);
      identifierListWithParentheses();
    }
    setState(8167);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::MATCH_SYMBOL) {
      setState(8165);
      match(MySQLParser::MATCH_SYMBOL);
      setState(8166);
      antlrcpp::downCast<ReferencesContext *>(_localctx)->match = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::FULL_SYMBOL || _la == MySQLParser::PARTIAL_SYMBOL || _la == MySQLParser::SIMPLE_SYMBOL)) {
        antlrcpp::downCast<ReferencesContext *>(_localctx)->match = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(8185);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 991, _ctx)) {
    case 1: {
      setState(8169);
      match(MySQLParser::ON_SYMBOL);
      setState(8170);
      antlrcpp::downCast<ReferencesContext *>(_localctx)->option = match(MySQLParser::UPDATE_SYMBOL);
      setState(8171);
      deleteOption();
      setState(8175);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ON_SYMBOL) {
        setState(8172);
        match(MySQLParser::ON_SYMBOL);
        setState(8173);
        match(MySQLParser::DELETE_SYMBOL);
        setState(8174);
        deleteOption();
      }
      break;
    }

    case 2: {
      setState(8177);
      match(MySQLParser::ON_SYMBOL);
      setState(8178);
      antlrcpp::downCast<ReferencesContext *>(_localctx)->option = match(MySQLParser::DELETE_SYMBOL);
      setState(8179);
      deleteOption();
      setState(8183);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ON_SYMBOL) {
        setState(8180);
        match(MySQLParser::ON_SYMBOL);
        setState(8181);
        match(MySQLParser::UPDATE_SYMBOL);
        setState(8182);
        deleteOption();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DeleteOptionContext ------------------------------------------------------------------

MySQLParser::DeleteOptionContext::DeleteOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DeleteOptionContext::RESTRICT_SYMBOL() {
  return getToken(MySQLParser::RESTRICT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteOptionContext::CASCADE_SYMBOL() {
  return getToken(MySQLParser::CASCADE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteOptionContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

MySQLParser::NullLiteralContext* MySQLParser::DeleteOptionContext::nullLiteral() {
  return getRuleContext<MySQLParser::NullLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::DeleteOptionContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteOptionContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DeleteOptionContext::ACTION_SYMBOL() {
  return getToken(MySQLParser::ACTION_SYMBOL, 0);
}


size_t MySQLParser::DeleteOptionContext::getRuleIndex() const {
  return MySQLParser::RuleDeleteOption;
}

void MySQLParser::DeleteOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDeleteOption(this);
}

void MySQLParser::DeleteOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDeleteOption(this);
}


std::any MySQLParser::DeleteOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDeleteOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DeleteOptionContext* MySQLParser::deleteOption() {
  DeleteOptionContext *_localctx = _tracker.createInstance<DeleteOptionContext>(_ctx, getState());
  enterRule(_localctx, 1156, MySQLParser::RuleDeleteOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8194);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 992, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8187);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8188);
      match(MySQLParser::SET_SYMBOL);
      setState(8189);
      nullLiteral();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8190);
      match(MySQLParser::SET_SYMBOL);
      setState(8191);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8192);
      match(MySQLParser::NO_SYMBOL);
      setState(8193);
      match(MySQLParser::ACTION_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyListContext ------------------------------------------------------------------

MySQLParser::KeyListContext::KeyListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::KeyListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::KeyPartContext *> MySQLParser::KeyListContext::keyPart() {
  return getRuleContexts<MySQLParser::KeyPartContext>();
}

MySQLParser::KeyPartContext* MySQLParser::KeyListContext::keyPart(size_t i) {
  return getRuleContext<MySQLParser::KeyPartContext>(i);
}

tree::TerminalNode* MySQLParser::KeyListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::KeyListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::KeyListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::KeyListContext::getRuleIndex() const {
  return MySQLParser::RuleKeyList;
}

void MySQLParser::KeyListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyList(this);
}

void MySQLParser::KeyListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyList(this);
}


std::any MySQLParser::KeyListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyListContext* MySQLParser::keyList() {
  KeyListContext *_localctx = _tracker.createInstance<KeyListContext>(_ctx, getState());
  enterRule(_localctx, 1158, MySQLParser::RuleKeyList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8196);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8197);
    keyPart();
    setState(8202);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8198);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8199);
      keyPart();
      setState(8204);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8205);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyPartContext ------------------------------------------------------------------

MySQLParser::KeyPartContext::KeyPartContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::KeyPartContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::FieldLengthContext* MySQLParser::KeyPartContext::fieldLength() {
  return getRuleContext<MySQLParser::FieldLengthContext>(0);
}

MySQLParser::DirectionContext* MySQLParser::KeyPartContext::direction() {
  return getRuleContext<MySQLParser::DirectionContext>(0);
}


size_t MySQLParser::KeyPartContext::getRuleIndex() const {
  return MySQLParser::RuleKeyPart;
}

void MySQLParser::KeyPartContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyPart(this);
}

void MySQLParser::KeyPartContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyPart(this);
}


std::any MySQLParser::KeyPartContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyPart(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyPartContext* MySQLParser::keyPart() {
  KeyPartContext *_localctx = _tracker.createInstance<KeyPartContext>(_ctx, getState());
  enterRule(_localctx, 1160, MySQLParser::RuleKeyPart);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8207);
    identifier();
    setState(8209);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(8208);
      fieldLength();
    }
    setState(8212);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
      setState(8211);
      direction();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyListWithExpressionContext ------------------------------------------------------------------

MySQLParser::KeyListWithExpressionContext::KeyListWithExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::KeyListWithExpressionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::KeyPartOrExpressionContext *> MySQLParser::KeyListWithExpressionContext::keyPartOrExpression() {
  return getRuleContexts<MySQLParser::KeyPartOrExpressionContext>();
}

MySQLParser::KeyPartOrExpressionContext* MySQLParser::KeyListWithExpressionContext::keyPartOrExpression(size_t i) {
  return getRuleContext<MySQLParser::KeyPartOrExpressionContext>(i);
}

tree::TerminalNode* MySQLParser::KeyListWithExpressionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::KeyListWithExpressionContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::KeyListWithExpressionContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::KeyListWithExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleKeyListWithExpression;
}

void MySQLParser::KeyListWithExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyListWithExpression(this);
}

void MySQLParser::KeyListWithExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyListWithExpression(this);
}


std::any MySQLParser::KeyListWithExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyListWithExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyListWithExpressionContext* MySQLParser::keyListWithExpression() {
  KeyListWithExpressionContext *_localctx = _tracker.createInstance<KeyListWithExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1162, MySQLParser::RuleKeyListWithExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8214);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8215);
    keyPartOrExpression();
    setState(8220);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8216);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8217);
      keyPartOrExpression();
      setState(8222);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8223);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- KeyPartOrExpressionContext ------------------------------------------------------------------

MySQLParser::KeyPartOrExpressionContext::KeyPartOrExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::KeyPartContext* MySQLParser::KeyPartOrExpressionContext::keyPart() {
  return getRuleContext<MySQLParser::KeyPartContext>(0);
}

MySQLParser::ExprWithParenthesesContext* MySQLParser::KeyPartOrExpressionContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

MySQLParser::DirectionContext* MySQLParser::KeyPartOrExpressionContext::direction() {
  return getRuleContext<MySQLParser::DirectionContext>(0);
}


size_t MySQLParser::KeyPartOrExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleKeyPartOrExpression;
}

void MySQLParser::KeyPartOrExpressionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterKeyPartOrExpression(this);
}

void MySQLParser::KeyPartOrExpressionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitKeyPartOrExpression(this);
}


std::any MySQLParser::KeyPartOrExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitKeyPartOrExpression(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::KeyPartOrExpressionContext* MySQLParser::keyPartOrExpression() {
  KeyPartOrExpressionContext *_localctx = _tracker.createInstance<KeyPartOrExpressionContext>(_ctx, getState());
  enterRule(_localctx, 1164, MySQLParser::RuleKeyPartOrExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8231);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 998, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8225);
      keyPart();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8226);

      if (!(serverVersion >= 80013)) throw FailedPredicateException(this, "serverVersion >= 80013");
      setState(8227);
      exprWithParentheses();
      setState(8229);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
        setState(8228);
        direction();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexTypeContext ------------------------------------------------------------------

MySQLParser::IndexTypeContext::IndexTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IndexTypeContext::BTREE_SYMBOL() {
  return getToken(MySQLParser::BTREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexTypeContext::RTREE_SYMBOL() {
  return getToken(MySQLParser::RTREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexTypeContext::HASH_SYMBOL() {
  return getToken(MySQLParser::HASH_SYMBOL, 0);
}


size_t MySQLParser::IndexTypeContext::getRuleIndex() const {
  return MySQLParser::RuleIndexType;
}

void MySQLParser::IndexTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexType(this);
}

void MySQLParser::IndexTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexType(this);
}


std::any MySQLParser::IndexTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexTypeContext* MySQLParser::indexType() {
  IndexTypeContext *_localctx = _tracker.createInstance<IndexTypeContext>(_ctx, getState());
  enterRule(_localctx, 1166, MySQLParser::RuleIndexType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8233);
    antlrcpp::downCast<IndexTypeContext *>(_localctx)->algorithm = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::BTREE_SYMBOL || _la == MySQLParser::HASH_SYMBOL || _la == MySQLParser::RTREE_SYMBOL)) {
      antlrcpp::downCast<IndexTypeContext *>(_localctx)->algorithm = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexOptionContext ------------------------------------------------------------------

MySQLParser::IndexOptionContext::IndexOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CommonIndexOptionContext* MySQLParser::IndexOptionContext::commonIndexOption() {
  return getRuleContext<MySQLParser::CommonIndexOptionContext>(0);
}

MySQLParser::IndexTypeClauseContext* MySQLParser::IndexOptionContext::indexTypeClause() {
  return getRuleContext<MySQLParser::IndexTypeClauseContext>(0);
}


size_t MySQLParser::IndexOptionContext::getRuleIndex() const {
  return MySQLParser::RuleIndexOption;
}

void MySQLParser::IndexOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexOption(this);
}

void MySQLParser::IndexOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexOption(this);
}


std::any MySQLParser::IndexOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexOptionContext* MySQLParser::indexOption() {
  IndexOptionContext *_localctx = _tracker.createInstance<IndexOptionContext>(_ctx, getState());
  enterRule(_localctx, 1168, MySQLParser::RuleIndexOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8237);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 999, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8235);
      commonIndexOption();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8236);
      indexTypeClause();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CommonIndexOptionContext ------------------------------------------------------------------

MySQLParser::CommonIndexOptionContext::CommonIndexOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CommonIndexOptionContext::KEY_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::KEY_BLOCK_SIZE_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::CommonIndexOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::CommonIndexOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CommonIndexOptionContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::CommonIndexOptionContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::VisibilityContext* MySQLParser::CommonIndexOptionContext::visibility() {
  return getRuleContext<MySQLParser::VisibilityContext>(0);
}

tree::TerminalNode* MySQLParser::CommonIndexOptionContext::ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL, 0);
}

MySQLParser::JsonAttributeContext* MySQLParser::CommonIndexOptionContext::jsonAttribute() {
  return getRuleContext<MySQLParser::JsonAttributeContext>(0);
}

tree::TerminalNode* MySQLParser::CommonIndexOptionContext::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL, 0);
}


size_t MySQLParser::CommonIndexOptionContext::getRuleIndex() const {
  return MySQLParser::RuleCommonIndexOption;
}

void MySQLParser::CommonIndexOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCommonIndexOption(this);
}

void MySQLParser::CommonIndexOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCommonIndexOption(this);
}


std::any MySQLParser::CommonIndexOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCommonIndexOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CommonIndexOptionContext* MySQLParser::commonIndexOption() {
  CommonIndexOptionContext *_localctx = _tracker.createInstance<CommonIndexOptionContext>(_ctx, getState());
  enterRule(_localctx, 1170, MySQLParser::RuleCommonIndexOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8260);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1003, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8239);
      match(MySQLParser::KEY_BLOCK_SIZE_SYMBOL);
      setState(8241);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8240);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8243);
      ulong_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8244);
      match(MySQLParser::COMMENT_SYMBOL);
      setState(8245);
      textLiteral();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8246);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(8247);
      visibility();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8248);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8249);
      match(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL);
      setState(8251);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1001, _ctx)) {
      case 1: {
        setState(8250);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8253);
      jsonAttribute();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(8254);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8255);
      match(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL);
      setState(8257);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1002, _ctx)) {
      case 1: {
        setState(8256);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8259);
      jsonAttribute();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- VisibilityContext ------------------------------------------------------------------

MySQLParser::VisibilityContext::VisibilityContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::VisibilityContext::VISIBLE_SYMBOL() {
  return getToken(MySQLParser::VISIBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::VisibilityContext::INVISIBLE_SYMBOL() {
  return getToken(MySQLParser::INVISIBLE_SYMBOL, 0);
}


size_t MySQLParser::VisibilityContext::getRuleIndex() const {
  return MySQLParser::RuleVisibility;
}

void MySQLParser::VisibilityContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterVisibility(this);
}

void MySQLParser::VisibilityContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitVisibility(this);
}


std::any MySQLParser::VisibilityContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitVisibility(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::VisibilityContext* MySQLParser::visibility() {
  VisibilityContext *_localctx = _tracker.createInstance<VisibilityContext>(_ctx, getState());
  enterRule(_localctx, 1172, MySQLParser::RuleVisibility);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8262);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::INVISIBLE_SYMBOL

    || _la == MySQLParser::VISIBLE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexTypeClauseContext ------------------------------------------------------------------

MySQLParser::IndexTypeClauseContext::IndexTypeClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IndexTypeContext* MySQLParser::IndexTypeClauseContext::indexType() {
  return getRuleContext<MySQLParser::IndexTypeContext>(0);
}

tree::TerminalNode* MySQLParser::IndexTypeClauseContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IndexTypeClauseContext::TYPE_SYMBOL() {
  return getToken(MySQLParser::TYPE_SYMBOL, 0);
}


size_t MySQLParser::IndexTypeClauseContext::getRuleIndex() const {
  return MySQLParser::RuleIndexTypeClause;
}

void MySQLParser::IndexTypeClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexTypeClause(this);
}

void MySQLParser::IndexTypeClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexTypeClause(this);
}


std::any MySQLParser::IndexTypeClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexTypeClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexTypeClauseContext* MySQLParser::indexTypeClause() {
  IndexTypeClauseContext *_localctx = _tracker.createInstance<IndexTypeClauseContext>(_ctx, getState());
  enterRule(_localctx, 1174, MySQLParser::RuleIndexTypeClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8264);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TYPE_SYMBOL

    || _la == MySQLParser::USING_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(8265);
    indexType();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FulltextIndexOptionContext ------------------------------------------------------------------

MySQLParser::FulltextIndexOptionContext::FulltextIndexOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CommonIndexOptionContext* MySQLParser::FulltextIndexOptionContext::commonIndexOption() {
  return getRuleContext<MySQLParser::CommonIndexOptionContext>(0);
}

tree::TerminalNode* MySQLParser::FulltextIndexOptionContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FulltextIndexOptionContext::PARSER_SYMBOL() {
  return getToken(MySQLParser::PARSER_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::FulltextIndexOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::FulltextIndexOptionContext::getRuleIndex() const {
  return MySQLParser::RuleFulltextIndexOption;
}

void MySQLParser::FulltextIndexOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFulltextIndexOption(this);
}

void MySQLParser::FulltextIndexOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFulltextIndexOption(this);
}


std::any MySQLParser::FulltextIndexOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFulltextIndexOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FulltextIndexOptionContext* MySQLParser::fulltextIndexOption() {
  FulltextIndexOptionContext *_localctx = _tracker.createInstance<FulltextIndexOptionContext>(_ctx, getState());
  enterRule(_localctx, 1176, MySQLParser::RuleFulltextIndexOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8271);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1004, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8267);
      commonIndexOption();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8268);
      match(MySQLParser::WITH_SYMBOL);
      setState(8269);
      match(MySQLParser::PARSER_SYMBOL);
      setState(8270);
      identifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SpatialIndexOptionContext ------------------------------------------------------------------

MySQLParser::SpatialIndexOptionContext::SpatialIndexOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CommonIndexOptionContext* MySQLParser::SpatialIndexOptionContext::commonIndexOption() {
  return getRuleContext<MySQLParser::CommonIndexOptionContext>(0);
}


size_t MySQLParser::SpatialIndexOptionContext::getRuleIndex() const {
  return MySQLParser::RuleSpatialIndexOption;
}

void MySQLParser::SpatialIndexOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSpatialIndexOption(this);
}

void MySQLParser::SpatialIndexOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSpatialIndexOption(this);
}


std::any MySQLParser::SpatialIndexOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSpatialIndexOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SpatialIndexOptionContext* MySQLParser::spatialIndexOption() {
  SpatialIndexOptionContext *_localctx = _tracker.createInstance<SpatialIndexOptionContext>(_ctx, getState());
  enterRule(_localctx, 1178, MySQLParser::RuleSpatialIndexOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8273);
    commonIndexOption();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DataTypeDefinitionContext ------------------------------------------------------------------

MySQLParser::DataTypeDefinitionContext::DataTypeDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::DataTypeContext* MySQLParser::DataTypeDefinitionContext::dataType() {
  return getRuleContext<MySQLParser::DataTypeContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeDefinitionContext::EOF() {
  return getToken(MySQLParser::EOF, 0);
}


size_t MySQLParser::DataTypeDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleDataTypeDefinition;
}

void MySQLParser::DataTypeDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDataTypeDefinition(this);
}

void MySQLParser::DataTypeDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDataTypeDefinition(this);
}


std::any MySQLParser::DataTypeDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDataTypeDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DataTypeDefinitionContext* MySQLParser::dataTypeDefinition() {
  DataTypeDefinitionContext *_localctx = _tracker.createInstance<DataTypeDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 1180, MySQLParser::RuleDataTypeDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8275);
    dataType();
    setState(8276);
    match(MySQLParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DataTypeContext ------------------------------------------------------------------

MySQLParser::DataTypeContext::DataTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DataTypeContext::INT_SYMBOL() {
  return getToken(MySQLParser::INT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::TINYINT_SYMBOL() {
  return getToken(MySQLParser::TINYINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::SMALLINT_SYMBOL() {
  return getToken(MySQLParser::SMALLINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::MEDIUMINT_SYMBOL() {
  return getToken(MySQLParser::MEDIUMINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::BIGINT_SYMBOL() {
  return getToken(MySQLParser::BIGINT_SYMBOL, 0);
}

MySQLParser::FieldLengthContext* MySQLParser::DataTypeContext::fieldLength() {
  return getRuleContext<MySQLParser::FieldLengthContext>(0);
}

MySQLParser::FieldOptionsContext* MySQLParser::DataTypeContext::fieldOptions() {
  return getRuleContext<MySQLParser::FieldOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::REAL_SYMBOL() {
  return getToken(MySQLParser::REAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::DOUBLE_SYMBOL() {
  return getToken(MySQLParser::DOUBLE_SYMBOL, 0);
}

MySQLParser::PrecisionContext* MySQLParser::DataTypeContext::precision() {
  return getRuleContext<MySQLParser::PrecisionContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::PRECISION_SYMBOL() {
  return getToken(MySQLParser::PRECISION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::FLOAT_SYMBOL() {
  return getToken(MySQLParser::FLOAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::DECIMAL_SYMBOL() {
  return getToken(MySQLParser::DECIMAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::NUMERIC_SYMBOL() {
  return getToken(MySQLParser::NUMERIC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::FIXED_SYMBOL() {
  return getToken(MySQLParser::FIXED_SYMBOL, 0);
}

MySQLParser::FloatOptionsContext* MySQLParser::DataTypeContext::floatOptions() {
  return getRuleContext<MySQLParser::FloatOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::BIT_SYMBOL() {
  return getToken(MySQLParser::BIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::BOOL_SYMBOL() {
  return getToken(MySQLParser::BOOL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::BOOLEAN_SYMBOL() {
  return getToken(MySQLParser::BOOLEAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::CHAR_SYMBOL() {
  return getToken(MySQLParser::CHAR_SYMBOL, 0);
}

MySQLParser::CharsetWithOptBinaryContext* MySQLParser::DataTypeContext::charsetWithOptBinary() {
  return getRuleContext<MySQLParser::CharsetWithOptBinaryContext>(0);
}

MySQLParser::NcharContext* MySQLParser::DataTypeContext::nchar() {
  return getRuleContext<MySQLParser::NcharContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::VARYING_SYMBOL() {
  return getToken(MySQLParser::VARYING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::VARCHAR_SYMBOL() {
  return getToken(MySQLParser::VARCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::NATIONAL_SYMBOL() {
  return getToken(MySQLParser::NATIONAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::NVARCHAR_SYMBOL() {
  return getToken(MySQLParser::NVARCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::NCHAR_SYMBOL() {
  return getToken(MySQLParser::NCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::VARBINARY_SYMBOL() {
  return getToken(MySQLParser::VARBINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::VECTOR_SYMBOL() {
  return getToken(MySQLParser::VECTOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::YEAR_SYMBOL() {
  return getToken(MySQLParser::YEAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

MySQLParser::TypeDatetimePrecisionContext* MySQLParser::DataTypeContext::typeDatetimePrecision() {
  return getRuleContext<MySQLParser::TypeDatetimePrecisionContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::DATETIME_SYMBOL() {
  return getToken(MySQLParser::DATETIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::TINYBLOB_SYMBOL() {
  return getToken(MySQLParser::TINYBLOB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::BLOB_SYMBOL() {
  return getToken(MySQLParser::BLOB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::MEDIUMBLOB_SYMBOL() {
  return getToken(MySQLParser::MEDIUMBLOB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::LONGBLOB_SYMBOL() {
  return getToken(MySQLParser::LONGBLOB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::LONG_SYMBOL() {
  return getToken(MySQLParser::LONG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::TINYTEXT_SYMBOL() {
  return getToken(MySQLParser::TINYTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::TEXT_SYMBOL() {
  return getToken(MySQLParser::TEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::MEDIUMTEXT_SYMBOL() {
  return getToken(MySQLParser::MEDIUMTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::LONGTEXT_SYMBOL() {
  return getToken(MySQLParser::LONGTEXT_SYMBOL, 0);
}

MySQLParser::StringListContext* MySQLParser::DataTypeContext::stringList() {
  return getRuleContext<MySQLParser::StringListContext>(0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::ENUM_SYMBOL() {
  return getToken(MySQLParser::ENUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::SERIAL_SYMBOL() {
  return getToken(MySQLParser::SERIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::JSON_SYMBOL() {
  return getToken(MySQLParser::JSON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::GEOMETRY_SYMBOL() {
  return getToken(MySQLParser::GEOMETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::GEOMETRYCOLLECTION_SYMBOL() {
  return getToken(MySQLParser::GEOMETRYCOLLECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::POINT_SYMBOL() {
  return getToken(MySQLParser::POINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::MULTIPOINT_SYMBOL() {
  return getToken(MySQLParser::MULTIPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::LINESTRING_SYMBOL() {
  return getToken(MySQLParser::LINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::MULTILINESTRING_SYMBOL() {
  return getToken(MySQLParser::MULTILINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::POLYGON_SYMBOL() {
  return getToken(MySQLParser::POLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DataTypeContext::MULTIPOLYGON_SYMBOL() {
  return getToken(MySQLParser::MULTIPOLYGON_SYMBOL, 0);
}


size_t MySQLParser::DataTypeContext::getRuleIndex() const {
  return MySQLParser::RuleDataType;
}

void MySQLParser::DataTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDataType(this);
}

void MySQLParser::DataTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDataType(this);
}


std::any MySQLParser::DataTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDataType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DataTypeContext* MySQLParser::dataType() {
  DataTypeContext *_localctx = _tracker.createInstance<DataTypeContext>(_ctx, getState());
  enterRule(_localctx, 1182, MySQLParser::RuleDataType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8429);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1039, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8278);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::BIGINT_SYMBOL || _la == MySQLParser::INT_SYMBOL || _la == MySQLParser::MEDIUMINT_SYMBOL || _la == MySQLParser::SMALLINT_SYMBOL || _la == MySQLParser::TINYINT_SYMBOL)) {
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(8280);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1005, _ctx)) {
      case 1: {
        setState(8279);
        fieldLength();
        break;
      }

      default:
        break;
      }
      setState(8283);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1006, _ctx)) {
      case 1: {
        setState(8282);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8290);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::REAL_SYMBOL: {
          setState(8285);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::REAL_SYMBOL);
          break;
        }

        case MySQLParser::DOUBLE_SYMBOL: {
          setState(8286);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::DOUBLE_SYMBOL);
          setState(8288);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1007, _ctx)) {
          case 1: {
            setState(8287);
            match(MySQLParser::PRECISION_SYMBOL);
            break;
          }

          default:
            break;
          }
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(8293);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1009, _ctx)) {
      case 1: {
        setState(8292);
        precision();
        break;
      }

      default:
        break;
      }
      setState(8296);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1010, _ctx)) {
      case 1: {
        setState(8295);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8298);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DECIMAL_SYMBOL || _la == MySQLParser::FIXED_SYMBOL

      || _la == MySQLParser::FLOAT_SYMBOL || _la == MySQLParser::NUMERIC_SYMBOL)) {
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(8300);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1011, _ctx)) {
      case 1: {
        setState(8299);
        floatOptions();
        break;
      }

      default:
        break;
      }
      setState(8303);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1012, _ctx)) {
      case 1: {
        setState(8302);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8305);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::BIT_SYMBOL);
      setState(8307);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1013, _ctx)) {
      case 1: {
        setState(8306);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(8309);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::BOOLEAN_SYMBOL

      || _la == MySQLParser::BOOL_SYMBOL)) {
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(8310);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::CHAR_SYMBOL);
      setState(8312);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1014, _ctx)) {
      case 1: {
        setState(8311);
        fieldLength();
        break;
      }

      default:
        break;
      }
      setState(8315);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1015, _ctx)) {
      case 1: {
        setState(8314);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(8317);
      nchar();
      setState(8319);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1016, _ctx)) {
      case 1: {
        setState(8318);
        fieldLength();
        break;
      }

      default:
        break;
      }
      setState(8322);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1017, _ctx)) {
      case 1: {
        setState(8321);
        match(MySQLParser::BINARY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(8324);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::BINARY_SYMBOL);
      setState(8326);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1018, _ctx)) {
      case 1: {
        setState(8325);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(8331);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::CHAR_SYMBOL: {
          setState(8328);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::CHAR_SYMBOL);
          setState(8329);
          match(MySQLParser::VARYING_SYMBOL);
          break;
        }

        case MySQLParser::VARCHAR_SYMBOL: {
          setState(8330);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::VARCHAR_SYMBOL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(8333);
      fieldLength();
      setState(8335);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1020, _ctx)) {
      case 1: {
        setState(8334);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(8347);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1021, _ctx)) {
      case 1: {
        setState(8337);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NATIONAL_SYMBOL);
        setState(8338);
        match(MySQLParser::VARCHAR_SYMBOL);
        break;
      }

      case 2: {
        setState(8339);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NVARCHAR_SYMBOL);
        break;
      }

      case 3: {
        setState(8340);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NCHAR_SYMBOL);
        setState(8341);
        match(MySQLParser::VARCHAR_SYMBOL);
        break;
      }

      case 4: {
        setState(8342);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NATIONAL_SYMBOL);
        setState(8343);
        match(MySQLParser::CHAR_SYMBOL);
        setState(8344);
        match(MySQLParser::VARYING_SYMBOL);
        break;
      }

      case 5: {
        setState(8345);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NCHAR_SYMBOL);
        setState(8346);
        match(MySQLParser::VARYING_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(8349);
      fieldLength();
      setState(8351);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1022, _ctx)) {
      case 1: {
        setState(8350);
        match(MySQLParser::BINARY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(8353);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::VARBINARY_SYMBOL);
      setState(8354);
      fieldLength();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(8355);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::VECTOR_SYMBOL);
      setState(8357);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1023, _ctx)) {
      case 1: {
        setState(8356);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(8359);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::YEAR_SYMBOL);
      setState(8361);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1024, _ctx)) {
      case 1: {
        setState(8360);
        fieldLength();
        break;
      }

      default:
        break;
      }
      setState(8364);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1025, _ctx)) {
      case 1: {
        setState(8363);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(8366);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::DATE_SYMBOL);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(8367);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TIME_SYMBOL);
      setState(8369);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1026, _ctx)) {
      case 1: {
        setState(8368);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(8371);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TIMESTAMP_SYMBOL);
      setState(8373);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1027, _ctx)) {
      case 1: {
        setState(8372);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(8375);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::DATETIME_SYMBOL);
      setState(8377);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1028, _ctx)) {
      case 1: {
        setState(8376);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(8379);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TINYBLOB_SYMBOL);
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(8380);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::BLOB_SYMBOL);
      setState(8382);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1029, _ctx)) {
      case 1: {
        setState(8381);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(8384);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LONGBLOB_SYMBOL

      || _la == MySQLParser::MEDIUMBLOB_SYMBOL)) {
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(8385);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::LONG_SYMBOL);
      setState(8386);
      match(MySQLParser::VARBINARY_SYMBOL);
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(8387);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::LONG_SYMBOL);
      setState(8391);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1030, _ctx)) {
      case 1: {
        setState(8388);
        match(MySQLParser::CHAR_SYMBOL);
        setState(8389);
        match(MySQLParser::VARYING_SYMBOL);
        break;
      }

      case 2: {
        setState(8390);
        match(MySQLParser::VARCHAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(8394);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1031, _ctx)) {
      case 1: {
        setState(8393);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(8396);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TINYTEXT_SYMBOL);
      setState(8398);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1032, _ctx)) {
      case 1: {
        setState(8397);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(8400);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TEXT_SYMBOL);
      setState(8402);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1033, _ctx)) {
      case 1: {
        setState(8401);
        fieldLength();
        break;
      }

      default:
        break;
      }
      setState(8405);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1034, _ctx)) {
      case 1: {
        setState(8404);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(8407);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::MEDIUMTEXT_SYMBOL);
      setState(8409);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1035, _ctx)) {
      case 1: {
        setState(8408);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(8411);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::LONGTEXT_SYMBOL);
      setState(8413);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1036, _ctx)) {
      case 1: {
        setState(8412);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(8415);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::ENUM_SYMBOL);
      setState(8416);
      stringList();
      setState(8418);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1037, _ctx)) {
      case 1: {
        setState(8417);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(8420);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::SET_SYMBOL);
      setState(8421);
      stringList();
      setState(8423);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1038, _ctx)) {
      case 1: {
        setState(8422);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(8425);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::SERIAL_SYMBOL);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(8426);

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(8427);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::JSON_SYMBOL);
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(8428);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::GEOMETRYCOLLECTION_SYMBOL

      || _la == MySQLParser::GEOMETRY_SYMBOL || _la == MySQLParser::LINESTRING_SYMBOL || ((((_la - 382) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 382)) & ((1ULL << (MySQLParser::MULTILINESTRING_SYMBOL - 382))
        | (1ULL << (MySQLParser::MULTIPOINT_SYMBOL - 382))
        | (1ULL << (MySQLParser::MULTIPOLYGON_SYMBOL - 382))
        | (1ULL << (MySQLParser::POINT_SYMBOL - 382))
        | (1ULL << (MySQLParser::POLYGON_SYMBOL - 382)))) != 0))) {
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NcharContext ------------------------------------------------------------------

MySQLParser::NcharContext::NcharContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NcharContext::NCHAR_SYMBOL() {
  return getToken(MySQLParser::NCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NcharContext::CHAR_SYMBOL() {
  return getToken(MySQLParser::CHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NcharContext::NATIONAL_SYMBOL() {
  return getToken(MySQLParser::NATIONAL_SYMBOL, 0);
}


size_t MySQLParser::NcharContext::getRuleIndex() const {
  return MySQLParser::RuleNchar;
}

void MySQLParser::NcharContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNchar(this);
}

void MySQLParser::NcharContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNchar(this);
}


std::any MySQLParser::NcharContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNchar(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NcharContext* MySQLParser::nchar() {
  NcharContext *_localctx = _tracker.createInstance<NcharContext>(_ctx, getState());
  enterRule(_localctx, 1184, MySQLParser::RuleNchar);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8434);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::NCHAR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8431);
        antlrcpp::downCast<NcharContext *>(_localctx)->type = match(MySQLParser::NCHAR_SYMBOL);
        break;
      }

      case MySQLParser::NATIONAL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8432);
        antlrcpp::downCast<NcharContext *>(_localctx)->type = match(MySQLParser::NATIONAL_SYMBOL);
        setState(8433);
        match(MySQLParser::CHAR_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RealTypeContext ------------------------------------------------------------------

MySQLParser::RealTypeContext::RealTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RealTypeContext::REAL_SYMBOL() {
  return getToken(MySQLParser::REAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RealTypeContext::DOUBLE_SYMBOL() {
  return getToken(MySQLParser::DOUBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RealTypeContext::PRECISION_SYMBOL() {
  return getToken(MySQLParser::PRECISION_SYMBOL, 0);
}


size_t MySQLParser::RealTypeContext::getRuleIndex() const {
  return MySQLParser::RuleRealType;
}

void MySQLParser::RealTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRealType(this);
}

void MySQLParser::RealTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRealType(this);
}


std::any MySQLParser::RealTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRealType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RealTypeContext* MySQLParser::realType() {
  RealTypeContext *_localctx = _tracker.createInstance<RealTypeContext>(_ctx, getState());
  enterRule(_localctx, 1186, MySQLParser::RuleRealType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8441);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REAL_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8436);
        antlrcpp::downCast<RealTypeContext *>(_localctx)->type = match(MySQLParser::REAL_SYMBOL);
        break;
      }

      case MySQLParser::DOUBLE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8437);
        antlrcpp::downCast<RealTypeContext *>(_localctx)->type = match(MySQLParser::DOUBLE_SYMBOL);
        setState(8439);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1041, _ctx)) {
        case 1: {
          setState(8438);
          match(MySQLParser::PRECISION_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldLengthContext ------------------------------------------------------------------

MySQLParser::FieldLengthContext::FieldLengthContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FieldLengthContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldLengthContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::FieldLengthContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::FieldLengthContext::DECIMAL_NUMBER() {
  return getToken(MySQLParser::DECIMAL_NUMBER, 0);
}


size_t MySQLParser::FieldLengthContext::getRuleIndex() const {
  return MySQLParser::RuleFieldLength;
}

void MySQLParser::FieldLengthContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldLength(this);
}

void MySQLParser::FieldLengthContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldLength(this);
}


std::any MySQLParser::FieldLengthContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldLength(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldLengthContext* MySQLParser::fieldLength() {
  FieldLengthContext *_localctx = _tracker.createInstance<FieldLengthContext>(_ctx, getState());
  enterRule(_localctx, 1188, MySQLParser::RuleFieldLength);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8443);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8446);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1043, _ctx)) {
    case 1: {
      setState(8444);
      real_ulonglong_number();
      break;
    }

    case 2: {
      setState(8445);
      match(MySQLParser::DECIMAL_NUMBER);
      break;
    }

    default:
      break;
    }
    setState(8448);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldOptionsContext ------------------------------------------------------------------

MySQLParser::FieldOptionsContext::FieldOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::FieldOptionsContext::SIGNED_SYMBOL() {
  return getTokens(MySQLParser::SIGNED_SYMBOL);
}

tree::TerminalNode* MySQLParser::FieldOptionsContext::SIGNED_SYMBOL(size_t i) {
  return getToken(MySQLParser::SIGNED_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::FieldOptionsContext::UNSIGNED_SYMBOL() {
  return getTokens(MySQLParser::UNSIGNED_SYMBOL);
}

tree::TerminalNode* MySQLParser::FieldOptionsContext::UNSIGNED_SYMBOL(size_t i) {
  return getToken(MySQLParser::UNSIGNED_SYMBOL, i);
}

std::vector<tree::TerminalNode *> MySQLParser::FieldOptionsContext::ZEROFILL_SYMBOL() {
  return getTokens(MySQLParser::ZEROFILL_SYMBOL);
}

tree::TerminalNode* MySQLParser::FieldOptionsContext::ZEROFILL_SYMBOL(size_t i) {
  return getToken(MySQLParser::ZEROFILL_SYMBOL, i);
}


size_t MySQLParser::FieldOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleFieldOptions;
}

void MySQLParser::FieldOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldOptions(this);
}

void MySQLParser::FieldOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldOptions(this);
}


std::any MySQLParser::FieldOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldOptionsContext* MySQLParser::fieldOptions() {
  FieldOptionsContext *_localctx = _tracker.createInstance<FieldOptionsContext>(_ctx, getState());
  enterRule(_localctx, 1190, MySQLParser::RuleFieldOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8451); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(8450);
              _la = _input->LA(1);
              if (!(_la == MySQLParser::SIGNED_SYMBOL || _la == MySQLParser::UNSIGNED_SYMBOL

              || _la == MySQLParser::ZEROFILL_SYMBOL)) {
              _errHandler->recoverInline(this);
              }
              else {
                _errHandler->reportMatch(this);
                consume();
              }
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(8453); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1044, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CharsetWithOptBinaryContext ------------------------------------------------------------------

MySQLParser::CharsetWithOptBinaryContext::CharsetWithOptBinaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::AsciiContext* MySQLParser::CharsetWithOptBinaryContext::ascii() {
  return getRuleContext<MySQLParser::AsciiContext>(0);
}

MySQLParser::UnicodeContext* MySQLParser::CharsetWithOptBinaryContext::unicode() {
  return getRuleContext<MySQLParser::UnicodeContext>(0);
}

tree::TerminalNode* MySQLParser::CharsetWithOptBinaryContext::BYTE_SYMBOL() {
  return getToken(MySQLParser::BYTE_SYMBOL, 0);
}

MySQLParser::CharsetContext* MySQLParser::CharsetWithOptBinaryContext::charset() {
  return getRuleContext<MySQLParser::CharsetContext>(0);
}

MySQLParser::CharsetNameContext* MySQLParser::CharsetWithOptBinaryContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}

tree::TerminalNode* MySQLParser::CharsetWithOptBinaryContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}


size_t MySQLParser::CharsetWithOptBinaryContext::getRuleIndex() const {
  return MySQLParser::RuleCharsetWithOptBinary;
}

void MySQLParser::CharsetWithOptBinaryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCharsetWithOptBinary(this);
}

void MySQLParser::CharsetWithOptBinaryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCharsetWithOptBinary(this);
}


std::any MySQLParser::CharsetWithOptBinaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCharsetWithOptBinary(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CharsetWithOptBinaryContext* MySQLParser::charsetWithOptBinary() {
  CharsetWithOptBinaryContext *_localctx = _tracker.createInstance<CharsetWithOptBinaryContext>(_ctx, getState());
  enterRule(_localctx, 1192, MySQLParser::RuleCharsetWithOptBinary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8469);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1047, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8455);
      ascii();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8456);
      unicode();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8457);
      match(MySQLParser::BYTE_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8458);
      charset();
      setState(8459);
      charsetName();
      setState(8461);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1045, _ctx)) {
      case 1: {
        setState(8460);
        match(MySQLParser::BINARY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(8463);
      match(MySQLParser::BINARY_SYMBOL);
      setState(8467);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1046, _ctx)) {
      case 1: {
        setState(8464);
        charset();
        setState(8465);
        charsetName();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AsciiContext ------------------------------------------------------------------

MySQLParser::AsciiContext::AsciiContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::AsciiContext::ASCII_SYMBOL() {
  return getToken(MySQLParser::ASCII_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AsciiContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}


size_t MySQLParser::AsciiContext::getRuleIndex() const {
  return MySQLParser::RuleAscii;
}

void MySQLParser::AsciiContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAscii(this);
}

void MySQLParser::AsciiContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAscii(this);
}


std::any MySQLParser::AsciiContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAscii(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AsciiContext* MySQLParser::ascii() {
  AsciiContext *_localctx = _tracker.createInstance<AsciiContext>(_ctx, getState());
  enterRule(_localctx, 1194, MySQLParser::RuleAscii);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8477);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ASCII_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8471);
        match(MySQLParser::ASCII_SYMBOL);
        setState(8473);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1048, _ctx)) {
        case 1: {
          setState(8472);
          match(MySQLParser::BINARY_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::BINARY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8475);
        match(MySQLParser::BINARY_SYMBOL);
        setState(8476);
        match(MySQLParser::ASCII_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UnicodeContext ------------------------------------------------------------------

MySQLParser::UnicodeContext::UnicodeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UnicodeContext::UNICODE_SYMBOL() {
  return getToken(MySQLParser::UNICODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UnicodeContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}


size_t MySQLParser::UnicodeContext::getRuleIndex() const {
  return MySQLParser::RuleUnicode;
}

void MySQLParser::UnicodeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUnicode(this);
}

void MySQLParser::UnicodeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUnicode(this);
}


std::any MySQLParser::UnicodeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUnicode(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UnicodeContext* MySQLParser::unicode() {
  UnicodeContext *_localctx = _tracker.createInstance<UnicodeContext>(_ctx, getState());
  enterRule(_localctx, 1196, MySQLParser::RuleUnicode);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8485);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UNICODE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8479);
        match(MySQLParser::UNICODE_SYMBOL);
        setState(8481);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1050, _ctx)) {
        case 1: {
          setState(8480);
          match(MySQLParser::BINARY_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::BINARY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8483);
        match(MySQLParser::BINARY_SYMBOL);
        setState(8484);
        match(MySQLParser::UNICODE_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WsNumCodepointsContext ------------------------------------------------------------------

MySQLParser::WsNumCodepointsContext::WsNumCodepointsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::WsNumCodepointsContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::WsNumCodepointsContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::WsNumCodepointsContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::WsNumCodepointsContext::getRuleIndex() const {
  return MySQLParser::RuleWsNumCodepoints;
}

void MySQLParser::WsNumCodepointsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWsNumCodepoints(this);
}

void MySQLParser::WsNumCodepointsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWsNumCodepoints(this);
}


std::any MySQLParser::WsNumCodepointsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWsNumCodepoints(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WsNumCodepointsContext* MySQLParser::wsNumCodepoints() {
  WsNumCodepointsContext *_localctx = _tracker.createInstance<WsNumCodepointsContext>(_ctx, getState());
  enterRule(_localctx, 1198, MySQLParser::RuleWsNumCodepoints);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8487);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8488);
    real_ulong_number();
    setState(8489);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeDatetimePrecisionContext ------------------------------------------------------------------

MySQLParser::TypeDatetimePrecisionContext::TypeDatetimePrecisionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TypeDatetimePrecisionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TypeDatetimePrecisionContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::TypeDatetimePrecisionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::TypeDatetimePrecisionContext::getRuleIndex() const {
  return MySQLParser::RuleTypeDatetimePrecision;
}

void MySQLParser::TypeDatetimePrecisionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTypeDatetimePrecision(this);
}

void MySQLParser::TypeDatetimePrecisionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTypeDatetimePrecision(this);
}


std::any MySQLParser::TypeDatetimePrecisionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTypeDatetimePrecision(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TypeDatetimePrecisionContext* MySQLParser::typeDatetimePrecision() {
  TypeDatetimePrecisionContext *_localctx = _tracker.createInstance<TypeDatetimePrecisionContext>(_ctx, getState());
  enterRule(_localctx, 1200, MySQLParser::RuleTypeDatetimePrecision);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8491);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8492);
    match(MySQLParser::INT_NUMBER);
    setState(8493);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionDatetimePrecisionContext ------------------------------------------------------------------

MySQLParser::FunctionDatetimePrecisionContext::FunctionDatetimePrecisionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ParenthesesContext* MySQLParser::FunctionDatetimePrecisionContext::parentheses() {
  return getRuleContext<MySQLParser::ParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::FunctionDatetimePrecisionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FunctionDatetimePrecisionContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::FunctionDatetimePrecisionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::FunctionDatetimePrecisionContext::getRuleIndex() const {
  return MySQLParser::RuleFunctionDatetimePrecision;
}

void MySQLParser::FunctionDatetimePrecisionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFunctionDatetimePrecision(this);
}

void MySQLParser::FunctionDatetimePrecisionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFunctionDatetimePrecision(this);
}


std::any MySQLParser::FunctionDatetimePrecisionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFunctionDatetimePrecision(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FunctionDatetimePrecisionContext* MySQLParser::functionDatetimePrecision() {
  FunctionDatetimePrecisionContext *_localctx = _tracker.createInstance<FunctionDatetimePrecisionContext>(_ctx, getState());
  enterRule(_localctx, 1202, MySQLParser::RuleFunctionDatetimePrecision);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8500);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1052, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);

      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8496);
      parentheses();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8497);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(8498);
      match(MySQLParser::INT_NUMBER);
      setState(8499);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CharsetNameContext ------------------------------------------------------------------

MySQLParser::CharsetNameContext::CharsetNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::CharsetNameContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CharsetNameContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CharsetNameContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}


size_t MySQLParser::CharsetNameContext::getRuleIndex() const {
  return MySQLParser::RuleCharsetName;
}

void MySQLParser::CharsetNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCharsetName(this);
}

void MySQLParser::CharsetNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCharsetName(this);
}


std::any MySQLParser::CharsetNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCharsetName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CharsetNameContext* MySQLParser::charsetName() {
  CharsetNameContext *_localctx = _tracker.createInstance<CharsetNameContext>(_ctx, getState());
  enterRule(_localctx, 1204, MySQLParser::RuleCharsetName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8506);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1053, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8502);
      textOrIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8503);
      match(MySQLParser::BINARY_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8504);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(8505);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CollationNameContext ------------------------------------------------------------------

MySQLParser::CollationNameContext::CollationNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::CollationNameContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CollationNameContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CollationNameContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}


size_t MySQLParser::CollationNameContext::getRuleIndex() const {
  return MySQLParser::RuleCollationName;
}

void MySQLParser::CollationNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCollationName(this);
}

void MySQLParser::CollationNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCollationName(this);
}


std::any MySQLParser::CollationNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCollationName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CollationNameContext* MySQLParser::collationName() {
  CollationNameContext *_localctx = _tracker.createInstance<CollationNameContext>(_ctx, getState());
  enterRule(_localctx, 1206, MySQLParser::RuleCollationName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8513);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1054, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8508);
      textOrIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8509);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(8510);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8511);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(8512);
      match(MySQLParser::BINARY_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTableOptionsContext ------------------------------------------------------------------

MySQLParser::CreateTableOptionsContext::CreateTableOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::CreateTableOptionContext *> MySQLParser::CreateTableOptionsContext::createTableOption() {
  return getRuleContexts<MySQLParser::CreateTableOptionContext>();
}

MySQLParser::CreateTableOptionContext* MySQLParser::CreateTableOptionsContext::createTableOption(size_t i) {
  return getRuleContext<MySQLParser::CreateTableOptionContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::CreateTableOptionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::CreateTableOptionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::CreateTableOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTableOptions;
}

void MySQLParser::CreateTableOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTableOptions(this);
}

void MySQLParser::CreateTableOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTableOptions(this);
}


std::any MySQLParser::CreateTableOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTableOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTableOptionsContext* MySQLParser::createTableOptions() {
  CreateTableOptionsContext *_localctx = _tracker.createInstance<CreateTableOptionsContext>(_ctx, getState());
  enterRule(_localctx, 1208, MySQLParser::RuleCreateTableOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8515);
    createTableOption();
    setState(8522);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1056, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(8517);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1055, _ctx)) {
        case 1: {
          setState(8516);
          match(MySQLParser::COMMA_SYMBOL);
          break;
        }

        default:
          break;
        }
        setState(8519);
        createTableOption(); 
      }
      setState(8524);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1056, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTableOptionsEtcContext ------------------------------------------------------------------

MySQLParser::CreateTableOptionsEtcContext::CreateTableOptionsEtcContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CreateTableOptionsContext* MySQLParser::CreateTableOptionsEtcContext::createTableOptions() {
  return getRuleContext<MySQLParser::CreateTableOptionsContext>(0);
}

MySQLParser::CreatePartitioningEtcContext* MySQLParser::CreateTableOptionsEtcContext::createPartitioningEtc() {
  return getRuleContext<MySQLParser::CreatePartitioningEtcContext>(0);
}


size_t MySQLParser::CreateTableOptionsEtcContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTableOptionsEtc;
}

void MySQLParser::CreateTableOptionsEtcContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTableOptionsEtc(this);
}

void MySQLParser::CreateTableOptionsEtcContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTableOptionsEtc(this);
}


std::any MySQLParser::CreateTableOptionsEtcContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTableOptionsEtc(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTableOptionsEtcContext* MySQLParser::createTableOptionsEtc() {
  CreateTableOptionsEtcContext *_localctx = _tracker.createInstance<CreateTableOptionsEtcContext>(_ctx, getState());
  enterRule(_localctx, 1210, MySQLParser::RuleCreateTableOptionsEtc);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8530);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1058, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8525);
      createTableOptions();
      setState(8527);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1057, _ctx)) {
      case 1: {
        setState(8526);
        createPartitioningEtc();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8529);
      createPartitioningEtc();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreatePartitioningEtcContext ------------------------------------------------------------------

MySQLParser::CreatePartitioningEtcContext::CreatePartitioningEtcContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PartitionClauseContext* MySQLParser::CreatePartitioningEtcContext::partitionClause() {
  return getRuleContext<MySQLParser::PartitionClauseContext>(0);
}

MySQLParser::DuplicateAsQeContext* MySQLParser::CreatePartitioningEtcContext::duplicateAsQe() {
  return getRuleContext<MySQLParser::DuplicateAsQeContext>(0);
}


size_t MySQLParser::CreatePartitioningEtcContext::getRuleIndex() const {
  return MySQLParser::RuleCreatePartitioningEtc;
}

void MySQLParser::CreatePartitioningEtcContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreatePartitioningEtc(this);
}

void MySQLParser::CreatePartitioningEtcContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreatePartitioningEtc(this);
}


std::any MySQLParser::CreatePartitioningEtcContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreatePartitioningEtc(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreatePartitioningEtcContext* MySQLParser::createPartitioningEtc() {
  CreatePartitioningEtcContext *_localctx = _tracker.createInstance<CreatePartitioningEtcContext>(_ctx, getState());
  enterRule(_localctx, 1212, MySQLParser::RuleCreatePartitioningEtc);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8537);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1060, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8532);
      partitionClause();
      setState(8534);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1059, _ctx)) {
      case 1: {
        setState(8533);
        duplicateAsQe();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8536);
      duplicateAsQe();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTableOptionsSpaceSeparatedContext ------------------------------------------------------------------

MySQLParser::CreateTableOptionsSpaceSeparatedContext::CreateTableOptionsSpaceSeparatedContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::CreateTableOptionContext *> MySQLParser::CreateTableOptionsSpaceSeparatedContext::createTableOption() {
  return getRuleContexts<MySQLParser::CreateTableOptionContext>();
}

MySQLParser::CreateTableOptionContext* MySQLParser::CreateTableOptionsSpaceSeparatedContext::createTableOption(size_t i) {
  return getRuleContext<MySQLParser::CreateTableOptionContext>(i);
}


size_t MySQLParser::CreateTableOptionsSpaceSeparatedContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTableOptionsSpaceSeparated;
}

void MySQLParser::CreateTableOptionsSpaceSeparatedContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTableOptionsSpaceSeparated(this);
}

void MySQLParser::CreateTableOptionsSpaceSeparatedContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTableOptionsSpaceSeparated(this);
}


std::any MySQLParser::CreateTableOptionsSpaceSeparatedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTableOptionsSpaceSeparated(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTableOptionsSpaceSeparatedContext* MySQLParser::createTableOptionsSpaceSeparated() {
  CreateTableOptionsSpaceSeparatedContext *_localctx = _tracker.createInstance<CreateTableOptionsSpaceSeparatedContext>(_ctx, getState());
  enterRule(_localctx, 1214, MySQLParser::RuleCreateTableOptionsSpaceSeparated);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8540); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(8539);
              createTableOption();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(8542); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1061, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateTableOptionContext ------------------------------------------------------------------

MySQLParser::CreateTableOptionContext::CreateTableOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::EngineRefContext* MySQLParser::CreateTableOptionContext::engineRef() {
  return getRuleContext<MySQLParser::EngineRefContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::SECONDARY_ENGINE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::CreateTableOptionContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::EqualContext* MySQLParser::CreateTableOptionContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::UlonglongNumberContext* MySQLParser::CreateTableOptionContext::ulonglongNumber() {
  return getRuleContext<MySQLParser::UlonglongNumberContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::MAX_ROWS_SYMBOL() {
  return getToken(MySQLParser::MAX_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::MIN_ROWS_SYMBOL() {
  return getToken(MySQLParser::MIN_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::AVG_ROW_LENGTH_SYMBOL() {
  return getToken(MySQLParser::AVG_ROW_LENGTH_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::CreateTableOptionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::CreateTableOptionContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::COMPRESSION_SYMBOL() {
  return getToken(MySQLParser::COMPRESSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::ENCRYPTION_SYMBOL() {
  return getToken(MySQLParser::ENCRYPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::AUTO_INCREMENT_SYMBOL() {
  return getToken(MySQLParser::AUTO_INCREMENT_SYMBOL, 0);
}

MySQLParser::TernaryOptionContext* MySQLParser::CreateTableOptionContext::ternaryOption() {
  return getRuleContext<MySQLParser::TernaryOptionContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::PACK_KEYS_SYMBOL() {
  return getToken(MySQLParser::PACK_KEYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::STATS_AUTO_RECALC_SYMBOL() {
  return getToken(MySQLParser::STATS_AUTO_RECALC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::STATS_PERSISTENT_SYMBOL() {
  return getToken(MySQLParser::STATS_PERSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::STATS_SAMPLE_PAGES_SYMBOL() {
  return getToken(MySQLParser::STATS_SAMPLE_PAGES_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::CreateTableOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::TABLE_CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::TABLE_CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::DELAY_KEY_WRITE_SYMBOL() {
  return getToken(MySQLParser::DELAY_KEY_WRITE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::ROW_FORMAT_SYMBOL() {
  return getToken(MySQLParser::ROW_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::DYNAMIC_SYMBOL() {
  return getToken(MySQLParser::DYNAMIC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::FIXED_SYMBOL() {
  return getToken(MySQLParser::FIXED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::COMPRESSED_SYMBOL() {
  return getToken(MySQLParser::COMPRESSED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::REDUNDANT_SYMBOL() {
  return getToken(MySQLParser::REDUNDANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::COMPACT_SYMBOL() {
  return getToken(MySQLParser::COMPACT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::TableRefListContext* MySQLParser::CreateTableOptionContext::tableRefList() {
  return getRuleContext<MySQLParser::TableRefListContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::UNION_SYMBOL() {
  return getToken(MySQLParser::UNION_SYMBOL, 0);
}

MySQLParser::DefaultCharsetContext* MySQLParser::CreateTableOptionContext::defaultCharset() {
  return getRuleContext<MySQLParser::DefaultCharsetContext>(0);
}

MySQLParser::DefaultCollationContext* MySQLParser::CreateTableOptionContext::defaultCollation() {
  return getRuleContext<MySQLParser::DefaultCollationContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::INSERT_METHOD_SYMBOL() {
  return getToken(MySQLParser::INSERT_METHOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::FIRST_SYMBOL() {
  return getToken(MySQLParser::FIRST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::LAST_SYMBOL() {
  return getToken(MySQLParser::LAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::CreateTableOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::DISK_SYMBOL() {
  return getToken(MySQLParser::DISK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::CONNECTION_SYMBOL() {
  return getToken(MySQLParser::CONNECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::KEY_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::KEY_BLOCK_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::TRANSACTION_SYMBOL() {
  return getToken(MySQLParser::TRANSACTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

MySQLParser::JsonAttributeContext* MySQLParser::CreateTableOptionContext::jsonAttribute() {
  return getRuleContext<MySQLParser::JsonAttributeContext>(0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateTableOptionContext::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL, 0);
}

MySQLParser::TsOptionAutoextendSizeContext* MySQLParser::CreateTableOptionContext::tsOptionAutoextendSize() {
  return getRuleContext<MySQLParser::TsOptionAutoextendSizeContext>(0);
}


size_t MySQLParser::CreateTableOptionContext::getRuleIndex() const {
  return MySQLParser::RuleCreateTableOption;
}

void MySQLParser::CreateTableOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateTableOption(this);
}

void MySQLParser::CreateTableOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateTableOption(this);
}


std::any MySQLParser::CreateTableOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateTableOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateTableOptionContext* MySQLParser::createTableOption() {
  CreateTableOptionContext *_localctx = _tracker.createInstance<CreateTableOptionContext>(_ctx, getState());
  enterRule(_localctx, 1216, MySQLParser::RuleCreateTableOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8690);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1088, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8544);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ENGINE_SYMBOL);
      setState(8546);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1062, _ctx)) {
      case 1: {
        setState(8545);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8548);
      engineRef();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8549);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(8550);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::SECONDARY_ENGINE_SYMBOL);
      setState(8552);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1063, _ctx)) {
      case 1: {
        setState(8551);
        equal();
        break;
      }

      default:
        break;
      }
      setState(8556);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1064, _ctx)) {
      case 1: {
        setState(8554);
        match(MySQLParser::NULL_SYMBOL);
        break;
      }

      case 2: {
        setState(8555);
        textOrIdentifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8558);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::MAX_ROWS_SYMBOL);
      setState(8560);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8559);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8562);
      ulonglongNumber();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8563);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::MIN_ROWS_SYMBOL);
      setState(8565);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8564);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8567);
      ulonglongNumber();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(8568);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::AVG_ROW_LENGTH_SYMBOL);
      setState(8570);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8569);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8572);
      ulonglongNumber();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(8573);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::PASSWORD_SYMBOL);
      setState(8575);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1068, _ctx)) {
      case 1: {
        setState(8574);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8577);
      textStringLiteral();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(8578);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::COMMENT_SYMBOL);
      setState(8580);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1069, _ctx)) {
      case 1: {
        setState(8579);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8582);
      textStringLiteral();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(8583);

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(8584);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::COMPRESSION_SYMBOL);
      setState(8586);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1070, _ctx)) {
      case 1: {
        setState(8585);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8588);
      textString();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(8589);

      if (!(serverVersion >= 50711)) throw FailedPredicateException(this, "serverVersion >= 50711");
      setState(8590);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ENCRYPTION_SYMBOL);
      setState(8592);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1071, _ctx)) {
      case 1: {
        setState(8591);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8594);
      textString();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(8595);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::AUTO_INCREMENT_SYMBOL);
      setState(8597);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8596);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8599);
      ulonglongNumber();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(8600);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::PACK_KEYS_SYMBOL);
      setState(8602);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8601);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8604);
      ternaryOption();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(8605);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 570) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 570)) & ((1ULL << (MySQLParser::STATS_AUTO_RECALC_SYMBOL - 570))
        | (1ULL << (MySQLParser::STATS_PERSISTENT_SYMBOL - 570))
        | (1ULL << (MySQLParser::STATS_SAMPLE_PAGES_SYMBOL - 570)))) != 0))) {
        antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(8607);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8606);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8609);
      ternaryOption();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(8610);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CHECKSUM_SYMBOL || _la == MySQLParser::TABLE_CHECKSUM_SYMBOL)) {
        antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(8612);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8611);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8614);
      ulong_number();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(8615);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::DELAY_KEY_WRITE_SYMBOL);
      setState(8617);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8616);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8619);
      ulong_number();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(8620);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ROW_FORMAT_SYMBOL);
      setState(8622);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8621);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8624);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->format = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 122) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 122)) & ((1ULL << (MySQLParser::COMPACT_SYMBOL - 122))
        | (1ULL << (MySQLParser::COMPRESSED_SYMBOL - 122))
        | (1ULL << (MySQLParser::DEFAULT_SYMBOL - 122)))) != 0) || _la == MySQLParser::DYNAMIC_SYMBOL

      || _la == MySQLParser::FIXED_SYMBOL || _la == MySQLParser::REDUNDANT_SYMBOL)) {
        antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->format = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(8625);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::UNION_SYMBOL);
      setState(8627);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8626);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8629);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(8630);
      tableRefList();
      setState(8631);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(8633);
      defaultCharset();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(8634);
      defaultCollation();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(8635);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::INSERT_METHOD_SYMBOL);
      setState(8637);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8636);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8639);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->method = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::FIRST_SYMBOL || _la == MySQLParser::LAST_SYMBOL || _la == MySQLParser::NO_SYMBOL)) {
        antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->method = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(8640);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::DATA_SYMBOL);
      setState(8641);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(8643);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1080, _ctx)) {
      case 1: {
        setState(8642);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8645);
      textString();
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(8646);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::INDEX_SYMBOL);
      setState(8647);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(8649);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1081, _ctx)) {
      case 1: {
        setState(8648);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8651);
      textString();
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(8652);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::TABLESPACE_SYMBOL);
      setState(8658);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1083, _ctx)) {
      case 1: {
        setState(8653);

        if (!(serverVersion >= 50707)) throw FailedPredicateException(this, "serverVersion >= 50707");
        setState(8655);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1082, _ctx)) {
        case 1: {
          setState(8654);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        break;
      }

      default:
        break;
      }
      setState(8660);
      identifier();
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(8661);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::STORAGE_SYMBOL);
      setState(8662);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DISK_SYMBOL || _la == MySQLParser::MEMORY_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(8663);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::CONNECTION_SYMBOL);
      setState(8665);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1084, _ctx)) {
      case 1: {
        setState(8664);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8667);
      textString();
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(8668);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::KEY_BLOCK_SIZE_SYMBOL);
      setState(8670);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(8669);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(8672);
      ulonglongNumber();
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(8673);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8674);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::START_SYMBOL);
      setState(8675);
      match(MySQLParser::TRANSACTION_SYMBOL);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(8676);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8677);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL);
      setState(8679);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1086, _ctx)) {
      case 1: {
        setState(8678);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8681);
      jsonAttribute();
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(8682);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8683);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL);
      setState(8685);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1087, _ctx)) {
      case 1: {
        setState(8684);
        match(MySQLParser::EQUAL_OPERATOR);
        break;
      }

      default:
        break;
      }
      setState(8687);
      jsonAttribute();
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(8688);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(8689);
      tsOptionAutoextendSize();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TernaryOptionContext ------------------------------------------------------------------

MySQLParser::TernaryOptionContext::TernaryOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::Ulong_numberContext* MySQLParser::TernaryOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::TernaryOptionContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}


size_t MySQLParser::TernaryOptionContext::getRuleIndex() const {
  return MySQLParser::RuleTernaryOption;
}

void MySQLParser::TernaryOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTernaryOption(this);
}

void MySQLParser::TernaryOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTernaryOption(this);
}


std::any MySQLParser::TernaryOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTernaryOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TernaryOptionContext* MySQLParser::ternaryOption() {
  TernaryOptionContext *_localctx = _tracker.createInstance<TernaryOptionContext>(_ctx, getState());
  enterRule(_localctx, 1218, MySQLParser::RuleTernaryOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8694);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER:
      case MySQLParser::HEX_NUMBER:
      case MySQLParser::DECIMAL_NUMBER:
      case MySQLParser::FLOAT_NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(8692);
        ulong_number();
        break;
      }

      case MySQLParser::DEFAULT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8693);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultCollationContext ------------------------------------------------------------------

MySQLParser::DefaultCollationContext::DefaultCollationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DefaultCollationContext::COLLATE_SYMBOL() {
  return getToken(MySQLParser::COLLATE_SYMBOL, 0);
}

MySQLParser::CollationNameContext* MySQLParser::DefaultCollationContext::collationName() {
  return getRuleContext<MySQLParser::CollationNameContext>(0);
}

tree::TerminalNode* MySQLParser::DefaultCollationContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DefaultCollationContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::DefaultCollationContext::getRuleIndex() const {
  return MySQLParser::RuleDefaultCollation;
}

void MySQLParser::DefaultCollationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDefaultCollation(this);
}

void MySQLParser::DefaultCollationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDefaultCollation(this);
}


std::any MySQLParser::DefaultCollationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDefaultCollation(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DefaultCollationContext* MySQLParser::defaultCollation() {
  DefaultCollationContext *_localctx = _tracker.createInstance<DefaultCollationContext>(_ctx, getState());
  enterRule(_localctx, 1220, MySQLParser::RuleDefaultCollation);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8697);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(8696);
      match(MySQLParser::DEFAULT_SYMBOL);
    }
    setState(8699);
    match(MySQLParser::COLLATE_SYMBOL);
    setState(8701);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1091, _ctx)) {
    case 1: {
      setState(8700);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(8703);
    collationName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultEncryptionContext ------------------------------------------------------------------

MySQLParser::DefaultEncryptionContext::DefaultEncryptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DefaultEncryptionContext::ENCRYPTION_SYMBOL() {
  return getToken(MySQLParser::ENCRYPTION_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::DefaultEncryptionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::DefaultEncryptionContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DefaultEncryptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::DefaultEncryptionContext::getRuleIndex() const {
  return MySQLParser::RuleDefaultEncryption;
}

void MySQLParser::DefaultEncryptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDefaultEncryption(this);
}

void MySQLParser::DefaultEncryptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDefaultEncryption(this);
}


std::any MySQLParser::DefaultEncryptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDefaultEncryption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DefaultEncryptionContext* MySQLParser::defaultEncryption() {
  DefaultEncryptionContext *_localctx = _tracker.createInstance<DefaultEncryptionContext>(_ctx, getState());
  enterRule(_localctx, 1222, MySQLParser::RuleDefaultEncryption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8706);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(8705);
      match(MySQLParser::DEFAULT_SYMBOL);
    }
    setState(8708);
    match(MySQLParser::ENCRYPTION_SYMBOL);
    setState(8710);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1093, _ctx)) {
    case 1: {
      setState(8709);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(8712);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefaultCharsetContext ------------------------------------------------------------------

MySQLParser::DefaultCharsetContext::DefaultCharsetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CharsetContext* MySQLParser::DefaultCharsetContext::charset() {
  return getRuleContext<MySQLParser::CharsetContext>(0);
}

MySQLParser::CharsetNameContext* MySQLParser::DefaultCharsetContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}

tree::TerminalNode* MySQLParser::DefaultCharsetContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DefaultCharsetContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}


size_t MySQLParser::DefaultCharsetContext::getRuleIndex() const {
  return MySQLParser::RuleDefaultCharset;
}

void MySQLParser::DefaultCharsetContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDefaultCharset(this);
}

void MySQLParser::DefaultCharsetContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDefaultCharset(this);
}


std::any MySQLParser::DefaultCharsetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDefaultCharset(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DefaultCharsetContext* MySQLParser::defaultCharset() {
  DefaultCharsetContext *_localctx = _tracker.createInstance<DefaultCharsetContext>(_ctx, getState());
  enterRule(_localctx, 1224, MySQLParser::RuleDefaultCharset);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8715);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(8714);
      match(MySQLParser::DEFAULT_SYMBOL);
    }
    setState(8717);
    charset();
    setState(8719);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1095, _ctx)) {
    case 1: {
      setState(8718);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(8721);
    charsetName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionClauseContext ------------------------------------------------------------------

MySQLParser::PartitionClauseContext::PartitionClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PartitionClauseContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionClauseContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::PartitionTypeDefContext* MySQLParser::PartitionClauseContext::partitionTypeDef() {
  return getRuleContext<MySQLParser::PartitionTypeDefContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionClauseContext::PARTITIONS_SYMBOL() {
  return getToken(MySQLParser::PARTITIONS_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::PartitionClauseContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

MySQLParser::SubPartitionsContext* MySQLParser::PartitionClauseContext::subPartitions() {
  return getRuleContext<MySQLParser::SubPartitionsContext>(0);
}

MySQLParser::PartitionDefinitionsContext* MySQLParser::PartitionClauseContext::partitionDefinitions() {
  return getRuleContext<MySQLParser::PartitionDefinitionsContext>(0);
}


size_t MySQLParser::PartitionClauseContext::getRuleIndex() const {
  return MySQLParser::RulePartitionClause;
}

void MySQLParser::PartitionClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionClause(this);
}

void MySQLParser::PartitionClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionClause(this);
}


std::any MySQLParser::PartitionClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionClauseContext* MySQLParser::partitionClause() {
  PartitionClauseContext *_localctx = _tracker.createInstance<PartitionClauseContext>(_ctx, getState());
  enterRule(_localctx, 1226, MySQLParser::RulePartitionClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8723);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(8724);
    match(MySQLParser::BY_SYMBOL);
    setState(8725);
    partitionTypeDef();
    setState(8728);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1096, _ctx)) {
    case 1: {
      setState(8726);
      match(MySQLParser::PARTITIONS_SYMBOL);
      setState(8727);
      real_ulong_number();
      break;
    }

    default:
      break;
    }
    setState(8731);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1097, _ctx)) {
    case 1: {
      setState(8730);
      subPartitions();
      break;
    }

    default:
      break;
    }
    setState(8734);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1098, _ctx)) {
    case 1: {
      setState(8733);
      partitionDefinitions();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionTypeDefContext ------------------------------------------------------------------

MySQLParser::PartitionTypeDefContext::PartitionTypeDefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t MySQLParser::PartitionTypeDefContext::getRuleIndex() const {
  return MySQLParser::RulePartitionTypeDef;
}

void MySQLParser::PartitionTypeDefContext::copyFrom(PartitionTypeDefContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- PartitionDefRangeListContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PartitionDefRangeListContext::RANGE_SYMBOL() {
  return getToken(MySQLParser::RANGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefRangeListContext::LIST_SYMBOL() {
  return getToken(MySQLParser::LIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefRangeListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::PartitionDefRangeListContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionDefRangeListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefRangeListContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::PartitionDefRangeListContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

MySQLParser::PartitionDefRangeListContext::PartitionDefRangeListContext(PartitionTypeDefContext *ctx) { copyFrom(ctx); }

void MySQLParser::PartitionDefRangeListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionDefRangeList(this);
}
void MySQLParser::PartitionDefRangeListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionDefRangeList(this);
}

std::any MySQLParser::PartitionDefRangeListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionDefRangeList(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PartitionDefKeyContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PartitionDefKeyContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefKeyContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefKeyContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefKeyContext::LINEAR_SYMBOL() {
  return getToken(MySQLParser::LINEAR_SYMBOL, 0);
}

MySQLParser::PartitionKeyAlgorithmContext* MySQLParser::PartitionDefKeyContext::partitionKeyAlgorithm() {
  return getRuleContext<MySQLParser::PartitionKeyAlgorithmContext>(0);
}

MySQLParser::IdentifierListContext* MySQLParser::PartitionDefKeyContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

MySQLParser::PartitionDefKeyContext::PartitionDefKeyContext(PartitionTypeDefContext *ctx) { copyFrom(ctx); }

void MySQLParser::PartitionDefKeyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionDefKey(this);
}
void MySQLParser::PartitionDefKeyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionDefKey(this);
}

std::any MySQLParser::PartitionDefKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionDefKey(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PartitionDefHashContext ------------------------------------------------------------------

tree::TerminalNode* MySQLParser::PartitionDefHashContext::HASH_SYMBOL() {
  return getToken(MySQLParser::HASH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefHashContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::PartitionDefHashContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionDefHashContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefHashContext::LINEAR_SYMBOL() {
  return getToken(MySQLParser::LINEAR_SYMBOL, 0);
}

MySQLParser::PartitionDefHashContext::PartitionDefHashContext(PartitionTypeDefContext *ctx) { copyFrom(ctx); }

void MySQLParser::PartitionDefHashContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionDefHash(this);
}
void MySQLParser::PartitionDefHashContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionDefHash(this);
}

std::any MySQLParser::PartitionDefHashContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionDefHash(this);
  else
    return visitor->visitChildren(this);
}
MySQLParser::PartitionTypeDefContext* MySQLParser::partitionTypeDef() {
  PartitionTypeDefContext *_localctx = _tracker.createInstance<PartitionTypeDefContext>(_ctx, getState());
  enterRule(_localctx, 1228, MySQLParser::RulePartitionTypeDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8769);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1105, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<MySQLParser::PartitionDefKeyContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(8737);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LINEAR_SYMBOL) {
        setState(8736);
        match(MySQLParser::LINEAR_SYMBOL);
      }
      setState(8739);
      match(MySQLParser::KEY_SYMBOL);
      setState(8741);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ALGORITHM_SYMBOL) {
        setState(8740);
        partitionKeyAlgorithm();
      }
      setState(8743);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(8745);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1101, _ctx)) {
      case 1: {
        setState(8744);
        identifierList();
        break;
      }

      default:
        break;
      }
      setState(8747);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<MySQLParser::PartitionDefHashContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(8749);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LINEAR_SYMBOL) {
        setState(8748);
        match(MySQLParser::LINEAR_SYMBOL);
      }
      setState(8751);
      match(MySQLParser::HASH_SYMBOL);
      setState(8752);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(8753);
      bitExpr(0);
      setState(8754);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<MySQLParser::PartitionDefRangeListContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(8756);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LIST_SYMBOL || _la == MySQLParser::RANGE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(8767);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::OPEN_PAR_SYMBOL: {
          setState(8757);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(8758);
          bitExpr(0);
          setState(8759);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

        case MySQLParser::COLUMNS_SYMBOL: {
          setState(8761);
          match(MySQLParser::COLUMNS_SYMBOL);
          setState(8762);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(8764);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1103, _ctx)) {
          case 1: {
            setState(8763);
            identifierList();
            break;
          }

          default:
            break;
          }
          setState(8766);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SubPartitionsContext ------------------------------------------------------------------

MySQLParser::SubPartitionsContext::SubPartitionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::SUBPARTITION_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::HASH_SYMBOL() {
  return getToken(MySQLParser::HASH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::SubPartitionsContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 0);
}

MySQLParser::IdentifierListWithParenthesesContext* MySQLParser::SubPartitionsContext::identifierListWithParentheses() {
  return getRuleContext<MySQLParser::IdentifierListWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::LINEAR_SYMBOL() {
  return getToken(MySQLParser::LINEAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SubPartitionsContext::SUBPARTITIONS_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITIONS_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::SubPartitionsContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

MySQLParser::PartitionKeyAlgorithmContext* MySQLParser::SubPartitionsContext::partitionKeyAlgorithm() {
  return getRuleContext<MySQLParser::PartitionKeyAlgorithmContext>(0);
}


size_t MySQLParser::SubPartitionsContext::getRuleIndex() const {
  return MySQLParser::RuleSubPartitions;
}

void MySQLParser::SubPartitionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSubPartitions(this);
}

void MySQLParser::SubPartitionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSubPartitions(this);
}


std::any MySQLParser::SubPartitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSubPartitions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SubPartitionsContext* MySQLParser::subPartitions() {
  SubPartitionsContext *_localctx = _tracker.createInstance<SubPartitionsContext>(_ctx, getState());
  enterRule(_localctx, 1230, MySQLParser::RuleSubPartitions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8771);
    match(MySQLParser::SUBPARTITION_SYMBOL);
    setState(8772);
    match(MySQLParser::BY_SYMBOL);
    setState(8774);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LINEAR_SYMBOL) {
      setState(8773);
      match(MySQLParser::LINEAR_SYMBOL);
    }
    setState(8786);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::HASH_SYMBOL: {
        setState(8776);
        match(MySQLParser::HASH_SYMBOL);
        setState(8777);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(8778);
        bitExpr(0);
        setState(8779);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::KEY_SYMBOL: {
        setState(8781);
        match(MySQLParser::KEY_SYMBOL);
        setState(8783);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ALGORITHM_SYMBOL) {
          setState(8782);
          partitionKeyAlgorithm();
        }
        setState(8785);
        identifierListWithParentheses();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(8790);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1109, _ctx)) {
    case 1: {
      setState(8788);
      match(MySQLParser::SUBPARTITIONS_SYMBOL);
      setState(8789);
      real_ulong_number();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionKeyAlgorithmContext ------------------------------------------------------------------

MySQLParser::PartitionKeyAlgorithmContext::PartitionKeyAlgorithmContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PartitionKeyAlgorithmContext::ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionKeyAlgorithmContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::PartitionKeyAlgorithmContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}


size_t MySQLParser::PartitionKeyAlgorithmContext::getRuleIndex() const {
  return MySQLParser::RulePartitionKeyAlgorithm;
}

void MySQLParser::PartitionKeyAlgorithmContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionKeyAlgorithm(this);
}

void MySQLParser::PartitionKeyAlgorithmContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionKeyAlgorithm(this);
}


std::any MySQLParser::PartitionKeyAlgorithmContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionKeyAlgorithm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionKeyAlgorithmContext* MySQLParser::partitionKeyAlgorithm() {
  PartitionKeyAlgorithmContext *_localctx = _tracker.createInstance<PartitionKeyAlgorithmContext>(_ctx, getState());
  enterRule(_localctx, 1232, MySQLParser::RulePartitionKeyAlgorithm);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8792);
    match(MySQLParser::ALGORITHM_SYMBOL);
    setState(8793);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(8794);
    real_ulong_number();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionDefinitionsContext ------------------------------------------------------------------

MySQLParser::PartitionDefinitionsContext::PartitionDefinitionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PartitionDefinitionsContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::PartitionDefinitionContext *> MySQLParser::PartitionDefinitionsContext::partitionDefinition() {
  return getRuleContexts<MySQLParser::PartitionDefinitionContext>();
}

MySQLParser::PartitionDefinitionContext* MySQLParser::PartitionDefinitionsContext::partitionDefinition(size_t i) {
  return getRuleContext<MySQLParser::PartitionDefinitionContext>(i);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionsContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::PartitionDefinitionsContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionsContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::PartitionDefinitionsContext::getRuleIndex() const {
  return MySQLParser::RulePartitionDefinitions;
}

void MySQLParser::PartitionDefinitionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionDefinitions(this);
}

void MySQLParser::PartitionDefinitionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionDefinitions(this);
}


std::any MySQLParser::PartitionDefinitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionDefinitions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionDefinitionsContext* MySQLParser::partitionDefinitions() {
  PartitionDefinitionsContext *_localctx = _tracker.createInstance<PartitionDefinitionsContext>(_ctx, getState());
  enterRule(_localctx, 1234, MySQLParser::RulePartitionDefinitions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8796);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8797);
    partitionDefinition();
    setState(8802);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8798);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8799);
      partitionDefinition();
      setState(8804);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8805);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionDefinitionContext ------------------------------------------------------------------

MySQLParser::PartitionDefinitionContext::PartitionDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::PartitionDefinitionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::VALUES_SYMBOL() {
  return getToken(MySQLParser::VALUES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::LESS_SYMBOL() {
  return getToken(MySQLParser::LESS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::THAN_SYMBOL() {
  return getToken(MySQLParser::THAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

MySQLParser::PartitionValuesInContext* MySQLParser::PartitionDefinitionContext::partitionValuesIn() {
  return getRuleContext<MySQLParser::PartitionValuesInContext>(0);
}

std::vector<MySQLParser::PartitionOptionContext *> MySQLParser::PartitionDefinitionContext::partitionOption() {
  return getRuleContexts<MySQLParser::PartitionOptionContext>();
}

MySQLParser::PartitionOptionContext* MySQLParser::PartitionDefinitionContext::partitionOption(size_t i) {
  return getRuleContext<MySQLParser::PartitionOptionContext>(i);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::SubpartitionDefinitionContext *> MySQLParser::PartitionDefinitionContext::subpartitionDefinition() {
  return getRuleContexts<MySQLParser::SubpartitionDefinitionContext>();
}

MySQLParser::SubpartitionDefinitionContext* MySQLParser::PartitionDefinitionContext::subpartitionDefinition(size_t i) {
  return getRuleContext<MySQLParser::SubpartitionDefinitionContext>(i);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

MySQLParser::PartitionValueItemListParenContext* MySQLParser::PartitionDefinitionContext::partitionValueItemListParen() {
  return getRuleContext<MySQLParser::PartitionValueItemListParenContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::MAXVALUE_SYMBOL() {
  return getToken(MySQLParser::MAXVALUE_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::PartitionDefinitionContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::PartitionDefinitionContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::PartitionDefinitionContext::getRuleIndex() const {
  return MySQLParser::RulePartitionDefinition;
}

void MySQLParser::PartitionDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionDefinition(this);
}

void MySQLParser::PartitionDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionDefinition(this);
}


std::any MySQLParser::PartitionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionDefinitionContext* MySQLParser::partitionDefinition() {
  PartitionDefinitionContext *_localctx = _tracker.createInstance<PartitionDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 1236, MySQLParser::RulePartitionDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8807);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(8808);
    identifier();
    setState(8819);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1112, _ctx)) {
    case 1: {
      setState(8809);
      match(MySQLParser::VALUES_SYMBOL);
      setState(8810);
      match(MySQLParser::LESS_SYMBOL);
      setState(8811);
      match(MySQLParser::THAN_SYMBOL);
      setState(8814);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::OPEN_PAR_SYMBOL: {
          setState(8812);
          partitionValueItemListParen();
          break;
        }

        case MySQLParser::MAXVALUE_SYMBOL: {
          setState(8813);
          match(MySQLParser::MAXVALUE_SYMBOL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    case 2: {
      setState(8816);
      match(MySQLParser::VALUES_SYMBOL);
      setState(8817);
      match(MySQLParser::IN_SYMBOL);
      setState(8818);
      partitionValuesIn();
      break;
    }

    default:
      break;
    }
    setState(8824);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMENT_SYMBOL

    || _la == MySQLParser::DATA_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INDEX_SYMBOL || ((((_la - 355) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 355)) & ((1ULL << (MySQLParser::MAX_ROWS_SYMBOL - 355))
      | (1ULL << (MySQLParser::MIN_ROWS_SYMBOL - 355))
      | (1ULL << (MySQLParser::NODEGROUP_SYMBOL - 355)))) != 0) || _la == MySQLParser::STORAGE_SYMBOL

    || _la == MySQLParser::TABLESPACE_SYMBOL) {
      setState(8821);
      partitionOption();
      setState(8826);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8838);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(8827);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(8828);
      subpartitionDefinition();
      setState(8833);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(8829);
        match(MySQLParser::COMMA_SYMBOL);
        setState(8830);
        subpartitionDefinition();
        setState(8835);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(8836);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionValuesInContext ------------------------------------------------------------------

MySQLParser::PartitionValuesInContext::PartitionValuesInContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::PartitionValueItemListParenContext *> MySQLParser::PartitionValuesInContext::partitionValueItemListParen() {
  return getRuleContexts<MySQLParser::PartitionValueItemListParenContext>();
}

MySQLParser::PartitionValueItemListParenContext* MySQLParser::PartitionValuesInContext::partitionValueItemListParen(size_t i) {
  return getRuleContext<MySQLParser::PartitionValueItemListParenContext>(i);
}

tree::TerminalNode* MySQLParser::PartitionValuesInContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionValuesInContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::PartitionValuesInContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::PartitionValuesInContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::PartitionValuesInContext::getRuleIndex() const {
  return MySQLParser::RulePartitionValuesIn;
}

void MySQLParser::PartitionValuesInContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionValuesIn(this);
}

void MySQLParser::PartitionValuesInContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionValuesIn(this);
}


std::any MySQLParser::PartitionValuesInContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionValuesIn(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionValuesInContext* MySQLParser::partitionValuesIn() {
  PartitionValuesInContext *_localctx = _tracker.createInstance<PartitionValuesInContext>(_ctx, getState());
  enterRule(_localctx, 1238, MySQLParser::RulePartitionValuesIn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8852);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1117, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8840);
      partitionValueItemListParen();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8841);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(8842);
      partitionValueItemListParen();
      setState(8847);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(8843);
        match(MySQLParser::COMMA_SYMBOL);
        setState(8844);
        partitionValueItemListParen();
        setState(8849);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(8850);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionOptionContext ------------------------------------------------------------------

MySQLParser::PartitionOptionContext::PartitionOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::PartitionOptionContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::EngineRefContext* MySQLParser::PartitionOptionContext::engineRef() {
  return getRuleContext<MySQLParser::EngineRefContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::PartitionOptionContext::real_ulong_number() {
  return getRuleContext<MySQLParser::Real_ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::NODEGROUP_SYMBOL() {
  return getToken(MySQLParser::NODEGROUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::MAX_ROWS_SYMBOL() {
  return getToken(MySQLParser::MAX_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::MIN_ROWS_SYMBOL() {
  return getToken(MySQLParser::MIN_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::PartitionOptionContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::INDEX_SYMBOL() {
  return getToken(MySQLParser::INDEX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PartitionOptionContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}


size_t MySQLParser::PartitionOptionContext::getRuleIndex() const {
  return MySQLParser::RulePartitionOption;
}

void MySQLParser::PartitionOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionOption(this);
}

void MySQLParser::PartitionOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionOption(this);
}


std::any MySQLParser::PartitionOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionOptionContext* MySQLParser::partitionOption() {
  PartitionOptionContext *_localctx = _tracker.createInstance<PartitionOptionContext>(_ctx, getState());
  enterRule(_localctx, 1240, MySQLParser::RulePartitionOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8888);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::TABLESPACE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8854);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::TABLESPACE_SYMBOL);
        setState(8856);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1118, _ctx)) {
        case 1: {
          setState(8855);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        setState(8858);
        identifier();
        break;
      }

      case MySQLParser::ENGINE_SYMBOL:
      case MySQLParser::STORAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8860);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::STORAGE_SYMBOL) {
          setState(8859);
          match(MySQLParser::STORAGE_SYMBOL);
        }
        setState(8862);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::ENGINE_SYMBOL);
        setState(8864);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1120, _ctx)) {
        case 1: {
          setState(8863);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        setState(8866);
        engineRef();
        break;
      }

      case MySQLParser::NODEGROUP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(8867);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::NODEGROUP_SYMBOL);
        setState(8869);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::EQUAL_OPERATOR) {
          setState(8868);
          match(MySQLParser::EQUAL_OPERATOR);
        }
        setState(8871);
        real_ulong_number();
        break;
      }

      case MySQLParser::MAX_ROWS_SYMBOL:
      case MySQLParser::MIN_ROWS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(8872);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::MAX_ROWS_SYMBOL

        || _la == MySQLParser::MIN_ROWS_SYMBOL)) {
          antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(8874);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::EQUAL_OPERATOR) {
          setState(8873);
          match(MySQLParser::EQUAL_OPERATOR);
        }
        setState(8876);
        real_ulong_number();
        break;
      }

      case MySQLParser::DATA_SYMBOL:
      case MySQLParser::INDEX_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(8877);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::DATA_SYMBOL || _la == MySQLParser::INDEX_SYMBOL)) {
          antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(8878);
        match(MySQLParser::DIRECTORY_SYMBOL);
        setState(8880);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1123, _ctx)) {
        case 1: {
          setState(8879);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        setState(8882);
        textLiteral();
        break;
      }

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(8883);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::COMMENT_SYMBOL);
        setState(8885);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1124, _ctx)) {
        case 1: {
          setState(8884);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        setState(8887);
        textLiteral();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SubpartitionDefinitionContext ------------------------------------------------------------------

MySQLParser::SubpartitionDefinitionContext::SubpartitionDefinitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SubpartitionDefinitionContext::SUBPARTITION_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITION_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::SubpartitionDefinitionContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

std::vector<MySQLParser::PartitionOptionContext *> MySQLParser::SubpartitionDefinitionContext::partitionOption() {
  return getRuleContexts<MySQLParser::PartitionOptionContext>();
}

MySQLParser::PartitionOptionContext* MySQLParser::SubpartitionDefinitionContext::partitionOption(size_t i) {
  return getRuleContext<MySQLParser::PartitionOptionContext>(i);
}


size_t MySQLParser::SubpartitionDefinitionContext::getRuleIndex() const {
  return MySQLParser::RuleSubpartitionDefinition;
}

void MySQLParser::SubpartitionDefinitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSubpartitionDefinition(this);
}

void MySQLParser::SubpartitionDefinitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSubpartitionDefinition(this);
}


std::any MySQLParser::SubpartitionDefinitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSubpartitionDefinition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SubpartitionDefinitionContext* MySQLParser::subpartitionDefinition() {
  SubpartitionDefinitionContext *_localctx = _tracker.createInstance<SubpartitionDefinitionContext>(_ctx, getState());
  enterRule(_localctx, 1242, MySQLParser::RuleSubpartitionDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8890);
    match(MySQLParser::SUBPARTITION_SYMBOL);
    setState(8891);
    textOrIdentifier();
    setState(8895);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMENT_SYMBOL

    || _la == MySQLParser::DATA_SYMBOL || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INDEX_SYMBOL || ((((_la - 355) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 355)) & ((1ULL << (MySQLParser::MAX_ROWS_SYMBOL - 355))
      | (1ULL << (MySQLParser::MIN_ROWS_SYMBOL - 355))
      | (1ULL << (MySQLParser::NODEGROUP_SYMBOL - 355)))) != 0) || _la == MySQLParser::STORAGE_SYMBOL

    || _la == MySQLParser::TABLESPACE_SYMBOL) {
      setState(8892);
      partitionOption();
      setState(8897);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionValueItemListParenContext ------------------------------------------------------------------

MySQLParser::PartitionValueItemListParenContext::PartitionValueItemListParenContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PartitionValueItemListParenContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::PartitionValueItemContext *> MySQLParser::PartitionValueItemListParenContext::partitionValueItem() {
  return getRuleContexts<MySQLParser::PartitionValueItemContext>();
}

MySQLParser::PartitionValueItemContext* MySQLParser::PartitionValueItemListParenContext::partitionValueItem(size_t i) {
  return getRuleContext<MySQLParser::PartitionValueItemContext>(i);
}

tree::TerminalNode* MySQLParser::PartitionValueItemListParenContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::PartitionValueItemListParenContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::PartitionValueItemListParenContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::PartitionValueItemListParenContext::getRuleIndex() const {
  return MySQLParser::RulePartitionValueItemListParen;
}

void MySQLParser::PartitionValueItemListParenContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionValueItemListParen(this);
}

void MySQLParser::PartitionValueItemListParenContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionValueItemListParen(this);
}


std::any MySQLParser::PartitionValueItemListParenContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionValueItemListParen(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionValueItemListParenContext* MySQLParser::partitionValueItemListParen() {
  PartitionValueItemListParenContext *_localctx = _tracker.createInstance<PartitionValueItemListParenContext>(_ctx, getState());
  enterRule(_localctx, 1244, MySQLParser::RulePartitionValueItemListParen);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8898);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8899);
    partitionValueItem();
    setState(8904);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8900);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8901);
      partitionValueItem();
      setState(8906);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8907);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionValueItemContext ------------------------------------------------------------------

MySQLParser::PartitionValueItemContext::PartitionValueItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::BitExprContext* MySQLParser::PartitionValueItemContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::PartitionValueItemContext::MAXVALUE_SYMBOL() {
  return getToken(MySQLParser::MAXVALUE_SYMBOL, 0);
}


size_t MySQLParser::PartitionValueItemContext::getRuleIndex() const {
  return MySQLParser::RulePartitionValueItem;
}

void MySQLParser::PartitionValueItemContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPartitionValueItem(this);
}

void MySQLParser::PartitionValueItemContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPartitionValueItem(this);
}


std::any MySQLParser::PartitionValueItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPartitionValueItem(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PartitionValueItemContext* MySQLParser::partitionValueItem() {
  PartitionValueItemContext *_localctx = _tracker.createInstance<PartitionValueItemContext>(_ctx, getState());
  enterRule(_localctx, 1246, MySQLParser::RulePartitionValueItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8911);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1128, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8909);
      bitExpr(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8910);
      match(MySQLParser::MAXVALUE_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DefinerClauseContext ------------------------------------------------------------------

MySQLParser::DefinerClauseContext::DefinerClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DefinerClauseContext::DEFINER_SYMBOL() {
  return getToken(MySQLParser::DEFINER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DefinerClauseContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::UserContext* MySQLParser::DefinerClauseContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}


size_t MySQLParser::DefinerClauseContext::getRuleIndex() const {
  return MySQLParser::RuleDefinerClause;
}

void MySQLParser::DefinerClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDefinerClause(this);
}

void MySQLParser::DefinerClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDefinerClause(this);
}


std::any MySQLParser::DefinerClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDefinerClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DefinerClauseContext* MySQLParser::definerClause() {
  DefinerClauseContext *_localctx = _tracker.createInstance<DefinerClauseContext>(_ctx, getState());
  enterRule(_localctx, 1248, MySQLParser::RuleDefinerClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8913);
    match(MySQLParser::DEFINER_SYMBOL);
    setState(8914);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(8915);
    user();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IfExistsContext ------------------------------------------------------------------

MySQLParser::IfExistsContext::IfExistsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IfExistsContext::IF_SYMBOL() {
  return getToken(MySQLParser::IF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IfExistsContext::EXISTS_SYMBOL() {
  return getToken(MySQLParser::EXISTS_SYMBOL, 0);
}


size_t MySQLParser::IfExistsContext::getRuleIndex() const {
  return MySQLParser::RuleIfExists;
}

void MySQLParser::IfExistsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIfExists(this);
}

void MySQLParser::IfExistsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIfExists(this);
}


std::any MySQLParser::IfExistsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIfExists(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IfExistsContext* MySQLParser::ifExists() {
  IfExistsContext *_localctx = _tracker.createInstance<IfExistsContext>(_ctx, getState());
  enterRule(_localctx, 1250, MySQLParser::RuleIfExists);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8917);
    match(MySQLParser::IF_SYMBOL);
    setState(8918);
    match(MySQLParser::EXISTS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IfExistsIdentifierContext ------------------------------------------------------------------

MySQLParser::IfExistsIdentifierContext::IfExistsIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PersistedVariableIdentifierContext* MySQLParser::IfExistsIdentifierContext::persistedVariableIdentifier() {
  return getRuleContext<MySQLParser::PersistedVariableIdentifierContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::IfExistsIdentifierContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::IfExistsIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleIfExistsIdentifier;
}

void MySQLParser::IfExistsIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIfExistsIdentifier(this);
}

void MySQLParser::IfExistsIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIfExistsIdentifier(this);
}


std::any MySQLParser::IfExistsIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIfExistsIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IfExistsIdentifierContext* MySQLParser::ifExistsIdentifier() {
  IfExistsIdentifierContext *_localctx = _tracker.createInstance<IfExistsIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1252, MySQLParser::RuleIfExistsIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8921);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1129, _ctx)) {
    case 1: {
      setState(8920);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(8923);
    persistedVariableIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PersistedVariableIdentifierContext ------------------------------------------------------------------

MySQLParser::PersistedVariableIdentifierContext::PersistedVariableIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::PersistedVariableIdentifierContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::PersistedVariableIdentifierContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::PersistedVariableIdentifierContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}

MySQLParser::DotIdentifierContext* MySQLParser::PersistedVariableIdentifierContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::PersistedVariableIdentifierContext::getRuleIndex() const {
  return MySQLParser::RulePersistedVariableIdentifier;
}

void MySQLParser::PersistedVariableIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPersistedVariableIdentifier(this);
}

void MySQLParser::PersistedVariableIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPersistedVariableIdentifier(this);
}


std::any MySQLParser::PersistedVariableIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPersistedVariableIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PersistedVariableIdentifierContext* MySQLParser::persistedVariableIdentifier() {
  PersistedVariableIdentifierContext *_localctx = _tracker.createInstance<PersistedVariableIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1254, MySQLParser::RulePersistedVariableIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8932);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1131, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8925);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8926);

      if (!(serverVersion >= 80032)) throw FailedPredicateException(this, "serverVersion >= 80032");
      setState(8930);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1130, _ctx)) {
      case 1: {
        setState(8927);
        qualifiedIdentifier();
        break;
      }

      case 2: {
        setState(8928);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(8929);
        dotIdentifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IfNotExistsContext ------------------------------------------------------------------

MySQLParser::IfNotExistsContext::IfNotExistsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IfNotExistsContext::IF_SYMBOL() {
  return getToken(MySQLParser::IF_SYMBOL, 0);
}

MySQLParser::NotRuleContext* MySQLParser::IfNotExistsContext::notRule() {
  return getRuleContext<MySQLParser::NotRuleContext>(0);
}

tree::TerminalNode* MySQLParser::IfNotExistsContext::EXISTS_SYMBOL() {
  return getToken(MySQLParser::EXISTS_SYMBOL, 0);
}


size_t MySQLParser::IfNotExistsContext::getRuleIndex() const {
  return MySQLParser::RuleIfNotExists;
}

void MySQLParser::IfNotExistsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIfNotExists(this);
}

void MySQLParser::IfNotExistsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIfNotExists(this);
}


std::any MySQLParser::IfNotExistsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIfNotExists(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IfNotExistsContext* MySQLParser::ifNotExists() {
  IfNotExistsContext *_localctx = _tracker.createInstance<IfNotExistsContext>(_ctx, getState());
  enterRule(_localctx, 1256, MySQLParser::RuleIfNotExists);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8934);
    match(MySQLParser::IF_SYMBOL);
    setState(8935);
    notRule();
    setState(8936);
    match(MySQLParser::EXISTS_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IgnoreUnknownUserContext ------------------------------------------------------------------

MySQLParser::IgnoreUnknownUserContext::IgnoreUnknownUserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IgnoreUnknownUserContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IgnoreUnknownUserContext::UNKNOWN_SYMBOL() {
  return getToken(MySQLParser::UNKNOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IgnoreUnknownUserContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}


size_t MySQLParser::IgnoreUnknownUserContext::getRuleIndex() const {
  return MySQLParser::RuleIgnoreUnknownUser;
}

void MySQLParser::IgnoreUnknownUserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIgnoreUnknownUser(this);
}

void MySQLParser::IgnoreUnknownUserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIgnoreUnknownUser(this);
}


std::any MySQLParser::IgnoreUnknownUserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIgnoreUnknownUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IgnoreUnknownUserContext* MySQLParser::ignoreUnknownUser() {
  IgnoreUnknownUserContext *_localctx = _tracker.createInstance<IgnoreUnknownUserContext>(_ctx, getState());
  enterRule(_localctx, 1258, MySQLParser::RuleIgnoreUnknownUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8938);
    match(MySQLParser::IGNORE_SYMBOL);
    setState(8939);
    match(MySQLParser::UNKNOWN_SYMBOL);
    setState(8940);
    match(MySQLParser::USER_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProcedureParameterContext ------------------------------------------------------------------

MySQLParser::ProcedureParameterContext::ProcedureParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::FunctionParameterContext* MySQLParser::ProcedureParameterContext::functionParameter() {
  return getRuleContext<MySQLParser::FunctionParameterContext>(0);
}

tree::TerminalNode* MySQLParser::ProcedureParameterContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProcedureParameterContext::OUT_SYMBOL() {
  return getToken(MySQLParser::OUT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProcedureParameterContext::INOUT_SYMBOL() {
  return getToken(MySQLParser::INOUT_SYMBOL, 0);
}


size_t MySQLParser::ProcedureParameterContext::getRuleIndex() const {
  return MySQLParser::RuleProcedureParameter;
}

void MySQLParser::ProcedureParameterContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProcedureParameter(this);
}

void MySQLParser::ProcedureParameterContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProcedureParameter(this);
}


std::any MySQLParser::ProcedureParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitProcedureParameter(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ProcedureParameterContext* MySQLParser::procedureParameter() {
  ProcedureParameterContext *_localctx = _tracker.createInstance<ProcedureParameterContext>(_ctx, getState());
  enterRule(_localctx, 1260, MySQLParser::RuleProcedureParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8943);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1132, _ctx)) {
    case 1: {
      setState(8942);
      antlrcpp::downCast<ProcedureParameterContext *>(_localctx)->type = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::INOUT_SYMBOL

      || _la == MySQLParser::IN_SYMBOL || _la == MySQLParser::OUT_SYMBOL)) {
        antlrcpp::downCast<ProcedureParameterContext *>(_localctx)->type = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
    setState(8945);
    functionParameter();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionParameterContext ------------------------------------------------------------------

MySQLParser::FunctionParameterContext::FunctionParameterContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ParameterNameContext* MySQLParser::FunctionParameterContext::parameterName() {
  return getRuleContext<MySQLParser::ParameterNameContext>(0);
}

MySQLParser::TypeWithOptCollateContext* MySQLParser::FunctionParameterContext::typeWithOptCollate() {
  return getRuleContext<MySQLParser::TypeWithOptCollateContext>(0);
}


size_t MySQLParser::FunctionParameterContext::getRuleIndex() const {
  return MySQLParser::RuleFunctionParameter;
}

void MySQLParser::FunctionParameterContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFunctionParameter(this);
}

void MySQLParser::FunctionParameterContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFunctionParameter(this);
}


std::any MySQLParser::FunctionParameterContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFunctionParameter(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FunctionParameterContext* MySQLParser::functionParameter() {
  FunctionParameterContext *_localctx = _tracker.createInstance<FunctionParameterContext>(_ctx, getState());
  enterRule(_localctx, 1262, MySQLParser::RuleFunctionParameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8947);
    parameterName();
    setState(8948);
    typeWithOptCollate();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CollateContext ------------------------------------------------------------------

MySQLParser::CollateContext::CollateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::CollateContext::COLLATE_SYMBOL() {
  return getToken(MySQLParser::COLLATE_SYMBOL, 0);
}

MySQLParser::CollationNameContext* MySQLParser::CollateContext::collationName() {
  return getRuleContext<MySQLParser::CollationNameContext>(0);
}


size_t MySQLParser::CollateContext::getRuleIndex() const {
  return MySQLParser::RuleCollate;
}

void MySQLParser::CollateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCollate(this);
}

void MySQLParser::CollateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCollate(this);
}


std::any MySQLParser::CollateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCollate(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CollateContext* MySQLParser::collate() {
  CollateContext *_localctx = _tracker.createInstance<CollateContext>(_ctx, getState());
  enterRule(_localctx, 1264, MySQLParser::RuleCollate);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8950);
    match(MySQLParser::COLLATE_SYMBOL);
    setState(8951);
    collationName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeWithOptCollateContext ------------------------------------------------------------------

MySQLParser::TypeWithOptCollateContext::TypeWithOptCollateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::DataTypeContext* MySQLParser::TypeWithOptCollateContext::dataType() {
  return getRuleContext<MySQLParser::DataTypeContext>(0);
}

MySQLParser::CollateContext* MySQLParser::TypeWithOptCollateContext::collate() {
  return getRuleContext<MySQLParser::CollateContext>(0);
}


size_t MySQLParser::TypeWithOptCollateContext::getRuleIndex() const {
  return MySQLParser::RuleTypeWithOptCollate;
}

void MySQLParser::TypeWithOptCollateContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTypeWithOptCollate(this);
}

void MySQLParser::TypeWithOptCollateContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTypeWithOptCollate(this);
}


std::any MySQLParser::TypeWithOptCollateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTypeWithOptCollate(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TypeWithOptCollateContext* MySQLParser::typeWithOptCollate() {
  TypeWithOptCollateContext *_localctx = _tracker.createInstance<TypeWithOptCollateContext>(_ctx, getState());
  enterRule(_localctx, 1266, MySQLParser::RuleTypeWithOptCollate);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8953);
    dataType();
    setState(8955);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1133, _ctx)) {
    case 1: {
      setState(8954);
      collate();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SchemaIdentifierPairContext ------------------------------------------------------------------

MySQLParser::SchemaIdentifierPairContext::SchemaIdentifierPairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SchemaIdentifierPairContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::SchemaRefContext *> MySQLParser::SchemaIdentifierPairContext::schemaRef() {
  return getRuleContexts<MySQLParser::SchemaRefContext>();
}

MySQLParser::SchemaRefContext* MySQLParser::SchemaIdentifierPairContext::schemaRef(size_t i) {
  return getRuleContext<MySQLParser::SchemaRefContext>(i);
}

tree::TerminalNode* MySQLParser::SchemaIdentifierPairContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SchemaIdentifierPairContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::SchemaIdentifierPairContext::getRuleIndex() const {
  return MySQLParser::RuleSchemaIdentifierPair;
}

void MySQLParser::SchemaIdentifierPairContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSchemaIdentifierPair(this);
}

void MySQLParser::SchemaIdentifierPairContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSchemaIdentifierPair(this);
}


std::any MySQLParser::SchemaIdentifierPairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSchemaIdentifierPair(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SchemaIdentifierPairContext* MySQLParser::schemaIdentifierPair() {
  SchemaIdentifierPairContext *_localctx = _tracker.createInstance<SchemaIdentifierPairContext>(_ctx, getState());
  enterRule(_localctx, 1268, MySQLParser::RuleSchemaIdentifierPair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8957);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8958);
    schemaRef();
    setState(8959);
    match(MySQLParser::COMMA_SYMBOL);
    setState(8960);
    schemaRef();
    setState(8961);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewRefListContext ------------------------------------------------------------------

MySQLParser::ViewRefListContext::ViewRefListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::ViewRefContext *> MySQLParser::ViewRefListContext::viewRef() {
  return getRuleContexts<MySQLParser::ViewRefContext>();
}

MySQLParser::ViewRefContext* MySQLParser::ViewRefListContext::viewRef(size_t i) {
  return getRuleContext<MySQLParser::ViewRefContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::ViewRefListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ViewRefListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ViewRefListContext::getRuleIndex() const {
  return MySQLParser::RuleViewRefList;
}

void MySQLParser::ViewRefListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewRefList(this);
}

void MySQLParser::ViewRefListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewRefList(this);
}


std::any MySQLParser::ViewRefListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewRefList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewRefListContext* MySQLParser::viewRefList() {
  ViewRefListContext *_localctx = _tracker.createInstance<ViewRefListContext>(_ctx, getState());
  enterRule(_localctx, 1270, MySQLParser::RuleViewRefList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8963);
    viewRef();
    setState(8968);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8964);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8965);
      viewRef();
      setState(8970);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UpdateListContext ------------------------------------------------------------------

MySQLParser::UpdateListContext::UpdateListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::UpdateElementContext *> MySQLParser::UpdateListContext::updateElement() {
  return getRuleContexts<MySQLParser::UpdateElementContext>();
}

MySQLParser::UpdateElementContext* MySQLParser::UpdateListContext::updateElement(size_t i) {
  return getRuleContext<MySQLParser::UpdateElementContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::UpdateListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::UpdateListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::UpdateListContext::getRuleIndex() const {
  return MySQLParser::RuleUpdateList;
}

void MySQLParser::UpdateListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUpdateList(this);
}

void MySQLParser::UpdateListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUpdateList(this);
}


std::any MySQLParser::UpdateListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUpdateList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UpdateListContext* MySQLParser::updateList() {
  UpdateListContext *_localctx = _tracker.createInstance<UpdateListContext>(_ctx, getState());
  enterRule(_localctx, 1272, MySQLParser::RuleUpdateList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8971);
    updateElement();
    setState(8976);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1135, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(8972);
        match(MySQLParser::COMMA_SYMBOL);
        setState(8973);
        updateElement(); 
      }
      setState(8978);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1135, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UpdateElementContext ------------------------------------------------------------------

MySQLParser::UpdateElementContext::UpdateElementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ColumnRefContext* MySQLParser::UpdateElementContext::columnRef() {
  return getRuleContext<MySQLParser::ColumnRefContext>(0);
}

tree::TerminalNode* MySQLParser::UpdateElementContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

MySQLParser::ExprContext* MySQLParser::UpdateElementContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::UpdateElementContext::DEFAULT_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_SYMBOL, 0);
}


size_t MySQLParser::UpdateElementContext::getRuleIndex() const {
  return MySQLParser::RuleUpdateElement;
}

void MySQLParser::UpdateElementContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUpdateElement(this);
}

void MySQLParser::UpdateElementContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUpdateElement(this);
}


std::any MySQLParser::UpdateElementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUpdateElement(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UpdateElementContext* MySQLParser::updateElement() {
  UpdateElementContext *_localctx = _tracker.createInstance<UpdateElementContext>(_ctx, getState());
  enterRule(_localctx, 1274, MySQLParser::RuleUpdateElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8979);
    columnRef();
    setState(8980);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(8983);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1136, _ctx)) {
    case 1: {
      setState(8981);
      expr(0);
      break;
    }

    case 2: {
      setState(8982);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CharsetClauseContext ------------------------------------------------------------------

MySQLParser::CharsetClauseContext::CharsetClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::CharsetContext* MySQLParser::CharsetClauseContext::charset() {
  return getRuleContext<MySQLParser::CharsetContext>(0);
}

MySQLParser::CharsetNameContext* MySQLParser::CharsetClauseContext::charsetName() {
  return getRuleContext<MySQLParser::CharsetNameContext>(0);
}


size_t MySQLParser::CharsetClauseContext::getRuleIndex() const {
  return MySQLParser::RuleCharsetClause;
}

void MySQLParser::CharsetClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCharsetClause(this);
}

void MySQLParser::CharsetClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCharsetClause(this);
}


std::any MySQLParser::CharsetClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCharsetClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CharsetClauseContext* MySQLParser::charsetClause() {
  CharsetClauseContext *_localctx = _tracker.createInstance<CharsetClauseContext>(_ctx, getState());
  enterRule(_localctx, 1276, MySQLParser::RuleCharsetClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8985);
    charset();
    setState(8986);
    charsetName();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldsClauseContext ------------------------------------------------------------------

MySQLParser::FieldsClauseContext::FieldsClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FieldsClauseContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

std::vector<MySQLParser::FieldTermContext *> MySQLParser::FieldsClauseContext::fieldTerm() {
  return getRuleContexts<MySQLParser::FieldTermContext>();
}

MySQLParser::FieldTermContext* MySQLParser::FieldsClauseContext::fieldTerm(size_t i) {
  return getRuleContext<MySQLParser::FieldTermContext>(i);
}


size_t MySQLParser::FieldsClauseContext::getRuleIndex() const {
  return MySQLParser::RuleFieldsClause;
}

void MySQLParser::FieldsClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldsClause(this);
}

void MySQLParser::FieldsClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldsClause(this);
}


std::any MySQLParser::FieldsClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldsClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldsClauseContext* MySQLParser::fieldsClause() {
  FieldsClauseContext *_localctx = _tracker.createInstance<FieldsClauseContext>(_ctx, getState());
  enterRule(_localctx, 1278, MySQLParser::RuleFieldsClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8988);
    match(MySQLParser::COLUMNS_SYMBOL);
    setState(8990); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(8989);
              fieldTerm();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(8992); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1137, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldTermContext ------------------------------------------------------------------

MySQLParser::FieldTermContext::FieldTermContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::FieldTermContext::TERMINATED_SYMBOL() {
  return getToken(MySQLParser::TERMINATED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::FieldTermContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::ENCLOSED_SYMBOL() {
  return getToken(MySQLParser::ENCLOSED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::OPTIONALLY_SYMBOL() {
  return getToken(MySQLParser::OPTIONALLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::ESCAPED_SYMBOL() {
  return getToken(MySQLParser::ESCAPED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::NOT_SYMBOL() {
  return getToken(MySQLParser::NOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::FieldTermContext::EMPTY_SYMBOL() {
  return getToken(MySQLParser::EMPTY_SYMBOL, 0);
}


size_t MySQLParser::FieldTermContext::getRuleIndex() const {
  return MySQLParser::RuleFieldTerm;
}

void MySQLParser::FieldTermContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldTerm(this);
}

void MySQLParser::FieldTermContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldTerm(this);
}


std::any MySQLParser::FieldTermContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldTerm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldTermContext* MySQLParser::fieldTerm() {
  FieldTermContext *_localctx = _tracker.createInstance<FieldTermContext>(_ctx, getState());
  enterRule(_localctx, 1280, MySQLParser::RuleFieldTerm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9023);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1140, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8994);
      match(MySQLParser::TERMINATED_SYMBOL);
      setState(8995);
      match(MySQLParser::BY_SYMBOL);
      setState(8996);
      textString();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8998);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::OPTIONALLY_SYMBOL) {
        setState(8997);
        match(MySQLParser::OPTIONALLY_SYMBOL);
      }
      setState(9000);
      match(MySQLParser::ENCLOSED_SYMBOL);
      setState(9001);
      match(MySQLParser::BY_SYMBOL);
      setState(9002);
      textString();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9003);
      match(MySQLParser::ESCAPED_SYMBOL);
      setState(9004);
      match(MySQLParser::BY_SYMBOL);
      setState(9005);
      textString();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9006);

      if (!(serverVersion >= 80400)) throw FailedPredicateException(this, "serverVersion >= 80400");
      setState(9021);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::NOT_SYMBOL: {
          setState(9007);
          match(MySQLParser::NOT_SYMBOL);
          setState(9008);
          match(MySQLParser::ENCLOSED_SYMBOL);
          break;
        }

        case MySQLParser::DATE_SYMBOL: {
          setState(9009);
          match(MySQLParser::DATE_SYMBOL);
          setState(9010);
          match(MySQLParser::FORMAT_SYMBOL);
          setState(9011);
          textString();
          break;
        }

        case MySQLParser::TIME_SYMBOL: {
          setState(9012);
          match(MySQLParser::TIME_SYMBOL);
          setState(9013);
          match(MySQLParser::FORMAT_SYMBOL);
          setState(9014);
          textString();
          break;
        }

        case MySQLParser::NULL_SYMBOL: {
          setState(9015);
          match(MySQLParser::NULL_SYMBOL);
          setState(9016);
          match(MySQLParser::AS_SYMBOL);
          setState(9017);
          textString();
          break;
        }

        case MySQLParser::EMPTY_SYMBOL: {
          setState(9018);
          match(MySQLParser::EMPTY_SYMBOL);
          setState(9019);
          match(MySQLParser::AS_SYMBOL);
          setState(9020);
          textString();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LinesClauseContext ------------------------------------------------------------------

MySQLParser::LinesClauseContext::LinesClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LinesClauseContext::LINES_SYMBOL() {
  return getToken(MySQLParser::LINES_SYMBOL, 0);
}

std::vector<MySQLParser::LineTermContext *> MySQLParser::LinesClauseContext::lineTerm() {
  return getRuleContexts<MySQLParser::LineTermContext>();
}

MySQLParser::LineTermContext* MySQLParser::LinesClauseContext::lineTerm(size_t i) {
  return getRuleContext<MySQLParser::LineTermContext>(i);
}


size_t MySQLParser::LinesClauseContext::getRuleIndex() const {
  return MySQLParser::RuleLinesClause;
}

void MySQLParser::LinesClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLinesClause(this);
}

void MySQLParser::LinesClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLinesClause(this);
}


std::any MySQLParser::LinesClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLinesClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LinesClauseContext* MySQLParser::linesClause() {
  LinesClauseContext *_localctx = _tracker.createInstance<LinesClauseContext>(_ctx, getState());
  enterRule(_localctx, 1282, MySQLParser::RuleLinesClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9025);
    match(MySQLParser::LINES_SYMBOL);
    setState(9027); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(9026);
              lineTerm();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(9029); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1141, _ctx);
    } while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LineTermContext ------------------------------------------------------------------

MySQLParser::LineTermContext::LineTermContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LineTermContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::LineTermContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::LineTermContext::TERMINATED_SYMBOL() {
  return getToken(MySQLParser::TERMINATED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LineTermContext::STARTING_SYMBOL() {
  return getToken(MySQLParser::STARTING_SYMBOL, 0);
}


size_t MySQLParser::LineTermContext::getRuleIndex() const {
  return MySQLParser::RuleLineTerm;
}

void MySQLParser::LineTermContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLineTerm(this);
}

void MySQLParser::LineTermContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLineTerm(this);
}


std::any MySQLParser::LineTermContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLineTerm(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LineTermContext* MySQLParser::lineTerm() {
  LineTermContext *_localctx = _tracker.createInstance<LineTermContext>(_ctx, getState());
  enterRule(_localctx, 1284, MySQLParser::RuleLineTerm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9031);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::STARTING_SYMBOL

    || _la == MySQLParser::TERMINATED_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(9032);
    match(MySQLParser::BY_SYMBOL);
    setState(9033);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserListContext ------------------------------------------------------------------

MySQLParser::UserListContext::UserListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::UserContext *> MySQLParser::UserListContext::user() {
  return getRuleContexts<MySQLParser::UserContext>();
}

MySQLParser::UserContext* MySQLParser::UserListContext::user(size_t i) {
  return getRuleContext<MySQLParser::UserContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::UserListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::UserListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::UserListContext::getRuleIndex() const {
  return MySQLParser::RuleUserList;
}

void MySQLParser::UserListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserList(this);
}

void MySQLParser::UserListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserList(this);
}


std::any MySQLParser::UserListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserListContext* MySQLParser::userList() {
  UserListContext *_localctx = _tracker.createInstance<UserListContext>(_ctx, getState());
  enterRule(_localctx, 1286, MySQLParser::RuleUserList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9035);
    user();
    setState(9040);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1142, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9036);
        match(MySQLParser::COMMA_SYMBOL);
        setState(9037);
        user(); 
      }
      setState(9042);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1142, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUserListContext ------------------------------------------------------------------

MySQLParser::CreateUserListContext::CreateUserListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::CreateUserContext *> MySQLParser::CreateUserListContext::createUser() {
  return getRuleContexts<MySQLParser::CreateUserContext>();
}

MySQLParser::CreateUserContext* MySQLParser::CreateUserListContext::createUser(size_t i) {
  return getRuleContext<MySQLParser::CreateUserContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::CreateUserListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::CreateUserListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::CreateUserListContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUserList;
}

void MySQLParser::CreateUserListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUserList(this);
}

void MySQLParser::CreateUserListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUserList(this);
}


std::any MySQLParser::CreateUserListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUserList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUserListContext* MySQLParser::createUserList() {
  CreateUserListContext *_localctx = _tracker.createInstance<CreateUserListContext>(_ctx, getState());
  enterRule(_localctx, 1288, MySQLParser::RuleCreateUserList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9043);
    createUser();
    setState(9048);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1143, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9044);
        match(MySQLParser::COMMA_SYMBOL);
        setState(9045);
        createUser(); 
      }
      setState(9050);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1143, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUserContext ------------------------------------------------------------------

MySQLParser::CreateUserContext::CreateUserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserContext* MySQLParser::CreateUserContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

MySQLParser::IdentificationContext* MySQLParser::CreateUserContext::identification() {
  return getRuleContext<MySQLParser::IdentificationContext>(0);
}

MySQLParser::IdentifiedWithPluginContext* MySQLParser::CreateUserContext::identifiedWithPlugin() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginContext>(0);
}

MySQLParser::CreateUserWithMfaContext* MySQLParser::CreateUserContext::createUserWithMfa() {
  return getRuleContext<MySQLParser::CreateUserWithMfaContext>(0);
}

MySQLParser::InitialAuthContext* MySQLParser::CreateUserContext::initialAuth() {
  return getRuleContext<MySQLParser::InitialAuthContext>(0);
}


size_t MySQLParser::CreateUserContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUser;
}

void MySQLParser::CreateUserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUser(this);
}

void MySQLParser::CreateUserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUser(this);
}


std::any MySQLParser::CreateUserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUserContext* MySQLParser::createUser() {
  CreateUserContext *_localctx = _tracker.createInstance<CreateUserContext>(_ctx, getState());
  enterRule(_localctx, 1290, MySQLParser::RuleCreateUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9051);
    user();
    setState(9064);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1146, _ctx)) {
    case 1: {
      setState(9052);
      identification();
      setState(9055);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1144, _ctx)) {
      case 1: {
        setState(9053);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(9054);
        createUserWithMfa();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(9057);
      identifiedWithPlugin();
      setState(9060);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1145, _ctx)) {
      case 1: {
        setState(9058);

        if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
        setState(9059);
        initialAuth();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      setState(9062);

      if (!(serverVersion >= 80027)) throw FailedPredicateException(this, "serverVersion >= 80027");
      setState(9063);
      createUserWithMfa();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUserWithMfaContext ------------------------------------------------------------------

MySQLParser::CreateUserWithMfaContext::CreateUserWithMfaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<tree::TerminalNode *> MySQLParser::CreateUserWithMfaContext::AND_SYMBOL() {
  return getTokens(MySQLParser::AND_SYMBOL);
}

tree::TerminalNode* MySQLParser::CreateUserWithMfaContext::AND_SYMBOL(size_t i) {
  return getToken(MySQLParser::AND_SYMBOL, i);
}

std::vector<MySQLParser::IdentificationContext *> MySQLParser::CreateUserWithMfaContext::identification() {
  return getRuleContexts<MySQLParser::IdentificationContext>();
}

MySQLParser::IdentificationContext* MySQLParser::CreateUserWithMfaContext::identification(size_t i) {
  return getRuleContext<MySQLParser::IdentificationContext>(i);
}


size_t MySQLParser::CreateUserWithMfaContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUserWithMfa;
}

void MySQLParser::CreateUserWithMfaContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUserWithMfa(this);
}

void MySQLParser::CreateUserWithMfaContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUserWithMfa(this);
}


std::any MySQLParser::CreateUserWithMfaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUserWithMfa(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUserWithMfaContext* MySQLParser::createUserWithMfa() {
  CreateUserWithMfaContext *_localctx = _tracker.createInstance<CreateUserWithMfaContext>(_ctx, getState());
  enterRule(_localctx, 1292, MySQLParser::RuleCreateUserWithMfa);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9066);
    match(MySQLParser::AND_SYMBOL);
    setState(9067);
    identification();
    setState(9070);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1147, _ctx)) {
    case 1: {
      setState(9068);
      match(MySQLParser::AND_SYMBOL);
      setState(9069);
      identification();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentificationContext ------------------------------------------------------------------

MySQLParser::IdentificationContext::IdentificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifiedByPasswordContext* MySQLParser::IdentificationContext::identifiedByPassword() {
  return getRuleContext<MySQLParser::IdentifiedByPasswordContext>(0);
}

MySQLParser::IdentifiedByRandomPasswordContext* MySQLParser::IdentificationContext::identifiedByRandomPassword() {
  return getRuleContext<MySQLParser::IdentifiedByRandomPasswordContext>(0);
}

MySQLParser::IdentifiedWithPluginContext* MySQLParser::IdentificationContext::identifiedWithPlugin() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginContext>(0);
}

MySQLParser::IdentifiedWithPluginAsAuthContext* MySQLParser::IdentificationContext::identifiedWithPluginAsAuth() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginAsAuthContext>(0);
}

MySQLParser::IdentifiedWithPluginByPasswordContext* MySQLParser::IdentificationContext::identifiedWithPluginByPassword() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginByPasswordContext>(0);
}

MySQLParser::IdentifiedWithPluginByRandomPasswordContext* MySQLParser::IdentificationContext::identifiedWithPluginByRandomPassword() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginByRandomPasswordContext>(0);
}


size_t MySQLParser::IdentificationContext::getRuleIndex() const {
  return MySQLParser::RuleIdentification;
}

void MySQLParser::IdentificationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentification(this);
}

void MySQLParser::IdentificationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentification(this);
}


std::any MySQLParser::IdentificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentification(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentificationContext* MySQLParser::identification() {
  IdentificationContext *_localctx = _tracker.createInstance<IdentificationContext>(_ctx, getState());
  enterRule(_localctx, 1294, MySQLParser::RuleIdentification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9081);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1148, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9072);
      identifiedByPassword();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9073);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(9074);
      identifiedByRandomPassword();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9075);
      identifiedWithPlugin();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9076);
      identifiedWithPluginAsAuth();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(9077);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(9078);
      identifiedWithPluginByPassword();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(9079);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(9080);
      identifiedWithPluginByRandomPassword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifiedByPasswordContext ------------------------------------------------------------------

MySQLParser::IdentifiedByPasswordContext::IdentifiedByPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifiedByPasswordContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedByPasswordContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::IdentifiedByPasswordContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::IdentifiedByPasswordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}


size_t MySQLParser::IdentifiedByPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifiedByPassword;
}

void MySQLParser::IdentifiedByPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifiedByPassword(this);
}

void MySQLParser::IdentifiedByPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifiedByPassword(this);
}


std::any MySQLParser::IdentifiedByPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifiedByPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifiedByPasswordContext* MySQLParser::identifiedByPassword() {
  IdentifiedByPasswordContext *_localctx = _tracker.createInstance<IdentifiedByPasswordContext>(_ctx, getState());
  enterRule(_localctx, 1296, MySQLParser::RuleIdentifiedByPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9083);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(9084);
    match(MySQLParser::BY_SYMBOL);
    setState(9087);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1149, _ctx)) {
    case 1: {
      setState(9085);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(9086);
      match(MySQLParser::PASSWORD_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(9089);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifiedByRandomPasswordContext ------------------------------------------------------------------

MySQLParser::IdentifiedByRandomPasswordContext::IdentifiedByRandomPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifiedByRandomPasswordContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedByRandomPasswordContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedByRandomPasswordContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedByRandomPasswordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}


size_t MySQLParser::IdentifiedByRandomPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifiedByRandomPassword;
}

void MySQLParser::IdentifiedByRandomPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifiedByRandomPassword(this);
}

void MySQLParser::IdentifiedByRandomPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifiedByRandomPassword(this);
}


std::any MySQLParser::IdentifiedByRandomPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifiedByRandomPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifiedByRandomPasswordContext* MySQLParser::identifiedByRandomPassword() {
  IdentifiedByRandomPasswordContext *_localctx = _tracker.createInstance<IdentifiedByRandomPasswordContext>(_ctx, getState());
  enterRule(_localctx, 1298, MySQLParser::RuleIdentifiedByRandomPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9091);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(9092);
    match(MySQLParser::BY_SYMBOL);
    setState(9093);
    match(MySQLParser::RANDOM_SYMBOL);
    setState(9094);
    match(MySQLParser::PASSWORD_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifiedWithPluginContext ------------------------------------------------------------------

MySQLParser::IdentifiedWithPluginContext::IdentifiedWithPluginContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::IdentifiedWithPluginContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::IdentifiedWithPluginContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifiedWithPlugin;
}

void MySQLParser::IdentifiedWithPluginContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifiedWithPlugin(this);
}

void MySQLParser::IdentifiedWithPluginContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifiedWithPlugin(this);
}


std::any MySQLParser::IdentifiedWithPluginContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifiedWithPlugin(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifiedWithPluginContext* MySQLParser::identifiedWithPlugin() {
  IdentifiedWithPluginContext *_localctx = _tracker.createInstance<IdentifiedWithPluginContext>(_ctx, getState());
  enterRule(_localctx, 1300, MySQLParser::RuleIdentifiedWithPlugin);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9096);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(9097);
    match(MySQLParser::WITH_SYMBOL);
    setState(9098);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifiedWithPluginAsAuthContext ------------------------------------------------------------------

MySQLParser::IdentifiedWithPluginAsAuthContext::IdentifiedWithPluginAsAuthContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginAsAuthContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginAsAuthContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::IdentifiedWithPluginAsAuthContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginAsAuthContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::TextStringHashContext* MySQLParser::IdentifiedWithPluginAsAuthContext::textStringHash() {
  return getRuleContext<MySQLParser::TextStringHashContext>(0);
}


size_t MySQLParser::IdentifiedWithPluginAsAuthContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifiedWithPluginAsAuth;
}

void MySQLParser::IdentifiedWithPluginAsAuthContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifiedWithPluginAsAuth(this);
}

void MySQLParser::IdentifiedWithPluginAsAuthContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifiedWithPluginAsAuth(this);
}


std::any MySQLParser::IdentifiedWithPluginAsAuthContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifiedWithPluginAsAuth(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifiedWithPluginAsAuthContext* MySQLParser::identifiedWithPluginAsAuth() {
  IdentifiedWithPluginAsAuthContext *_localctx = _tracker.createInstance<IdentifiedWithPluginAsAuthContext>(_ctx, getState());
  enterRule(_localctx, 1302, MySQLParser::RuleIdentifiedWithPluginAsAuth);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9100);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(9101);
    match(MySQLParser::WITH_SYMBOL);
    setState(9102);
    textOrIdentifier();
    setState(9103);
    match(MySQLParser::AS_SYMBOL);
    setState(9104);
    textStringHash();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifiedWithPluginByPasswordContext ------------------------------------------------------------------

MySQLParser::IdentifiedWithPluginByPasswordContext::IdentifiedWithPluginByPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByPasswordContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByPasswordContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::IdentifiedWithPluginByPasswordContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByPasswordContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::IdentifiedWithPluginByPasswordContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::IdentifiedWithPluginByPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifiedWithPluginByPassword;
}

void MySQLParser::IdentifiedWithPluginByPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifiedWithPluginByPassword(this);
}

void MySQLParser::IdentifiedWithPluginByPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifiedWithPluginByPassword(this);
}


std::any MySQLParser::IdentifiedWithPluginByPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifiedWithPluginByPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifiedWithPluginByPasswordContext* MySQLParser::identifiedWithPluginByPassword() {
  IdentifiedWithPluginByPasswordContext *_localctx = _tracker.createInstance<IdentifiedWithPluginByPasswordContext>(_ctx, getState());
  enterRule(_localctx, 1304, MySQLParser::RuleIdentifiedWithPluginByPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9106);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(9107);
    match(MySQLParser::WITH_SYMBOL);
    setState(9108);
    textOrIdentifier();
    setState(9109);
    match(MySQLParser::BY_SYMBOL);
    setState(9110);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifiedWithPluginByRandomPasswordContext ------------------------------------------------------------------

MySQLParser::IdentifiedWithPluginByRandomPasswordContext::IdentifiedWithPluginByRandomPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByRandomPasswordContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByRandomPasswordContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::IdentifiedWithPluginByRandomPasswordContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByRandomPasswordContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByRandomPasswordContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifiedWithPluginByRandomPasswordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}


size_t MySQLParser::IdentifiedWithPluginByRandomPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifiedWithPluginByRandomPassword;
}

void MySQLParser::IdentifiedWithPluginByRandomPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifiedWithPluginByRandomPassword(this);
}

void MySQLParser::IdentifiedWithPluginByRandomPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifiedWithPluginByRandomPassword(this);
}


std::any MySQLParser::IdentifiedWithPluginByRandomPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifiedWithPluginByRandomPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifiedWithPluginByRandomPasswordContext* MySQLParser::identifiedWithPluginByRandomPassword() {
  IdentifiedWithPluginByRandomPasswordContext *_localctx = _tracker.createInstance<IdentifiedWithPluginByRandomPasswordContext>(_ctx, getState());
  enterRule(_localctx, 1306, MySQLParser::RuleIdentifiedWithPluginByRandomPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9112);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(9113);
    match(MySQLParser::WITH_SYMBOL);
    setState(9114);
    textOrIdentifier();
    setState(9115);
    match(MySQLParser::BY_SYMBOL);
    setState(9116);
    match(MySQLParser::RANDOM_SYMBOL);
    setState(9117);
    match(MySQLParser::PASSWORD_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InitialAuthContext ------------------------------------------------------------------

MySQLParser::InitialAuthContext::InitialAuthContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::InitialAuthContext::INITIAL_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InitialAuthContext::AUTHENTICATION_SYMBOL() {
  return getToken(MySQLParser::AUTHENTICATION_SYMBOL, 0);
}

MySQLParser::IdentifiedByRandomPasswordContext* MySQLParser::InitialAuthContext::identifiedByRandomPassword() {
  return getRuleContext<MySQLParser::IdentifiedByRandomPasswordContext>(0);
}

MySQLParser::IdentifiedWithPluginAsAuthContext* MySQLParser::InitialAuthContext::identifiedWithPluginAsAuth() {
  return getRuleContext<MySQLParser::IdentifiedWithPluginAsAuthContext>(0);
}

MySQLParser::IdentifiedByPasswordContext* MySQLParser::InitialAuthContext::identifiedByPassword() {
  return getRuleContext<MySQLParser::IdentifiedByPasswordContext>(0);
}


size_t MySQLParser::InitialAuthContext::getRuleIndex() const {
  return MySQLParser::RuleInitialAuth;
}

void MySQLParser::InitialAuthContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInitialAuth(this);
}

void MySQLParser::InitialAuthContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInitialAuth(this);
}


std::any MySQLParser::InitialAuthContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInitialAuth(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InitialAuthContext* MySQLParser::initialAuth() {
  InitialAuthContext *_localctx = _tracker.createInstance<InitialAuthContext>(_ctx, getState());
  enterRule(_localctx, 1308, MySQLParser::RuleInitialAuth);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9119);
    match(MySQLParser::INITIAL_SYMBOL);
    setState(9120);
    match(MySQLParser::AUTHENTICATION_SYMBOL);
    setState(9124);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1150, _ctx)) {
    case 1: {
      setState(9121);
      identifiedByRandomPassword();
      break;
    }

    case 2: {
      setState(9122);
      identifiedWithPluginAsAuth();
      break;
    }

    case 3: {
      setState(9123);
      identifiedByPassword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RetainCurrentPasswordContext ------------------------------------------------------------------

MySQLParser::RetainCurrentPasswordContext::RetainCurrentPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RetainCurrentPasswordContext::RETAIN_SYMBOL() {
  return getToken(MySQLParser::RETAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RetainCurrentPasswordContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RetainCurrentPasswordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}


size_t MySQLParser::RetainCurrentPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleRetainCurrentPassword;
}

void MySQLParser::RetainCurrentPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRetainCurrentPassword(this);
}

void MySQLParser::RetainCurrentPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRetainCurrentPassword(this);
}


std::any MySQLParser::RetainCurrentPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRetainCurrentPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::retainCurrentPassword() {
  RetainCurrentPasswordContext *_localctx = _tracker.createInstance<RetainCurrentPasswordContext>(_ctx, getState());
  enterRule(_localctx, 1310, MySQLParser::RuleRetainCurrentPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9126);
    match(MySQLParser::RETAIN_SYMBOL);
    setState(9127);
    match(MySQLParser::CURRENT_SYMBOL);
    setState(9128);
    match(MySQLParser::PASSWORD_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DiscardOldPasswordContext ------------------------------------------------------------------

MySQLParser::DiscardOldPasswordContext::DiscardOldPasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DiscardOldPasswordContext::DISCARD_SYMBOL() {
  return getToken(MySQLParser::DISCARD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DiscardOldPasswordContext::OLD_SYMBOL() {
  return getToken(MySQLParser::OLD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DiscardOldPasswordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}


size_t MySQLParser::DiscardOldPasswordContext::getRuleIndex() const {
  return MySQLParser::RuleDiscardOldPassword;
}

void MySQLParser::DiscardOldPasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDiscardOldPassword(this);
}

void MySQLParser::DiscardOldPasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDiscardOldPassword(this);
}


std::any MySQLParser::DiscardOldPasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDiscardOldPassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DiscardOldPasswordContext* MySQLParser::discardOldPassword() {
  DiscardOldPasswordContext *_localctx = _tracker.createInstance<DiscardOldPasswordContext>(_ctx, getState());
  enterRule(_localctx, 1312, MySQLParser::RuleDiscardOldPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9130);
    match(MySQLParser::DISCARD_SYMBOL);
    setState(9131);
    match(MySQLParser::OLD_SYMBOL);
    setState(9132);
    match(MySQLParser::PASSWORD_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserRegistrationContext ------------------------------------------------------------------

MySQLParser::UserRegistrationContext::UserRegistrationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::FactorContext* MySQLParser::UserRegistrationContext::factor() {
  return getRuleContext<MySQLParser::FactorContext>(0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::INITIATE_SYMBOL() {
  return getToken(MySQLParser::INITIATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::REGISTRATION_SYMBOL() {
  return getToken(MySQLParser::REGISTRATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::UNREGISTER_SYMBOL() {
  return getToken(MySQLParser::UNREGISTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::FINISH_SYMBOL() {
  return getToken(MySQLParser::FINISH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::SET_SYMBOL() {
  return getToken(MySQLParser::SET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::CHALLENGE_RESPONSE_SYMBOL() {
  return getToken(MySQLParser::CHALLENGE_RESPONSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserRegistrationContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::TextStringHashContext* MySQLParser::UserRegistrationContext::textStringHash() {
  return getRuleContext<MySQLParser::TextStringHashContext>(0);
}


size_t MySQLParser::UserRegistrationContext::getRuleIndex() const {
  return MySQLParser::RuleUserRegistration;
}

void MySQLParser::UserRegistrationContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserRegistration(this);
}

void MySQLParser::UserRegistrationContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserRegistration(this);
}


std::any MySQLParser::UserRegistrationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserRegistration(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserRegistrationContext* MySQLParser::userRegistration() {
  UserRegistrationContext *_localctx = _tracker.createInstance<UserRegistrationContext>(_ctx, getState());
  enterRule(_localctx, 1314, MySQLParser::RuleUserRegistration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9149);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1151, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9134);
      factor();
      setState(9135);
      match(MySQLParser::INITIATE_SYMBOL);
      setState(9136);
      match(MySQLParser::REGISTRATION_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9138);
      factor();
      setState(9139);
      match(MySQLParser::UNREGISTER_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9141);
      factor();
      setState(9142);
      match(MySQLParser::FINISH_SYMBOL);
      setState(9143);
      match(MySQLParser::REGISTRATION_SYMBOL);
      setState(9144);
      match(MySQLParser::SET_SYMBOL);
      setState(9145);
      match(MySQLParser::CHALLENGE_RESPONSE_SYMBOL);
      setState(9146);
      match(MySQLParser::AS_SYMBOL);
      setState(9147);
      textStringHash();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FactorContext ------------------------------------------------------------------

MySQLParser::FactorContext::FactorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::NumLiteralContext* MySQLParser::FactorContext::numLiteral() {
  return getRuleContext<MySQLParser::NumLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::FactorContext::FACTOR_SYMBOL() {
  return getToken(MySQLParser::FACTOR_SYMBOL, 0);
}


size_t MySQLParser::FactorContext::getRuleIndex() const {
  return MySQLParser::RuleFactor;
}

void MySQLParser::FactorContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFactor(this);
}

void MySQLParser::FactorContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFactor(this);
}


std::any MySQLParser::FactorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFactor(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FactorContext* MySQLParser::factor() {
  FactorContext *_localctx = _tracker.createInstance<FactorContext>(_ctx, getState());
  enterRule(_localctx, 1316, MySQLParser::RuleFactor);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9151);
    numLiteral();
    setState(9152);
    match(MySQLParser::FACTOR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ReplacePasswordContext ------------------------------------------------------------------

MySQLParser::ReplacePasswordContext::ReplacePasswordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ReplacePasswordContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::ReplacePasswordContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}


size_t MySQLParser::ReplacePasswordContext::getRuleIndex() const {
  return MySQLParser::RuleReplacePassword;
}

void MySQLParser::ReplacePasswordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReplacePassword(this);
}

void MySQLParser::ReplacePasswordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReplacePassword(this);
}


std::any MySQLParser::ReplacePasswordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReplacePassword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ReplacePasswordContext* MySQLParser::replacePassword() {
  ReplacePasswordContext *_localctx = _tracker.createInstance<ReplacePasswordContext>(_ctx, getState());
  enterRule(_localctx, 1318, MySQLParser::RuleReplacePassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9154);
    match(MySQLParser::REPLACE_SYMBOL);
    setState(9155);
    textString();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserIdentifierOrTextContext ------------------------------------------------------------------

MySQLParser::UserIdentifierOrTextContext::UserIdentifierOrTextContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TextOrIdentifierContext *> MySQLParser::UserIdentifierOrTextContext::textOrIdentifier() {
  return getRuleContexts<MySQLParser::TextOrIdentifierContext>();
}

MySQLParser::TextOrIdentifierContext* MySQLParser::UserIdentifierOrTextContext::textOrIdentifier(size_t i) {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(i);
}

tree::TerminalNode* MySQLParser::UserIdentifierOrTextContext::AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_SIGN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::UserIdentifierOrTextContext::SIMPLE_IDENTIFIER() {
  return getToken(MySQLParser::SIMPLE_IDENTIFIER, 0);
}


size_t MySQLParser::UserIdentifierOrTextContext::getRuleIndex() const {
  return MySQLParser::RuleUserIdentifierOrText;
}

void MySQLParser::UserIdentifierOrTextContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUserIdentifierOrText(this);
}

void MySQLParser::UserIdentifierOrTextContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUserIdentifierOrText(this);
}


std::any MySQLParser::UserIdentifierOrTextContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUserIdentifierOrText(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserIdentifierOrTextContext* MySQLParser::userIdentifierOrText() {
  UserIdentifierOrTextContext *_localctx = _tracker.createInstance<UserIdentifierOrTextContext>(_ctx, getState());
  enterRule(_localctx, 1320, MySQLParser::RuleUserIdentifierOrText);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9157);
    textOrIdentifier();
    setState(9163);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1153, _ctx)) {
    case 1: {
      setState(9158);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(9161);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1152, _ctx)) {
      case 1: {
        setState(9159);
        textOrIdentifier();
        break;
      }

      case 2: {
        setState(9160);
        match(MySQLParser::SIMPLE_IDENTIFIER);
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UserContext ------------------------------------------------------------------

MySQLParser::UserContext::UserContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserIdentifierOrTextContext* MySQLParser::UserContext::userIdentifierOrText() {
  return getRuleContext<MySQLParser::UserIdentifierOrTextContext>(0);
}

tree::TerminalNode* MySQLParser::UserContext::CURRENT_USER_SYMBOL() {
  return getToken(MySQLParser::CURRENT_USER_SYMBOL, 0);
}

MySQLParser::ParenthesesContext* MySQLParser::UserContext::parentheses() {
  return getRuleContext<MySQLParser::ParenthesesContext>(0);
}


size_t MySQLParser::UserContext::getRuleIndex() const {
  return MySQLParser::RuleUser;
}

void MySQLParser::UserContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUser(this);
}

void MySQLParser::UserContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUser(this);
}


std::any MySQLParser::UserContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUser(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UserContext* MySQLParser::user() {
  UserContext *_localctx = _tracker.createInstance<UserContext>(_ctx, getState());
  enterRule(_localctx, 1322, MySQLParser::RuleUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9170);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1155, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9165);
      userIdentifierOrText();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9166);
      match(MySQLParser::CURRENT_USER_SYMBOL);
      setState(9168);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1154, _ctx)) {
      case 1: {
        setState(9167);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LikeClauseContext ------------------------------------------------------------------

MySQLParser::LikeClauseContext::LikeClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::LikeClauseContext::LIKE_SYMBOL() {
  return getToken(MySQLParser::LIKE_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::LikeClauseContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::LikeClauseContext::getRuleIndex() const {
  return MySQLParser::RuleLikeClause;
}

void MySQLParser::LikeClauseContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLikeClause(this);
}

void MySQLParser::LikeClauseContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLikeClause(this);
}


std::any MySQLParser::LikeClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLikeClause(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LikeClauseContext* MySQLParser::likeClause() {
  LikeClauseContext *_localctx = _tracker.createInstance<LikeClauseContext>(_ctx, getState());
  enterRule(_localctx, 1324, MySQLParser::RuleLikeClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9172);
    match(MySQLParser::LIKE_SYMBOL);
    setState(9173);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LikeOrWhereContext ------------------------------------------------------------------

MySQLParser::LikeOrWhereContext::LikeOrWhereContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LikeClauseContext* MySQLParser::LikeOrWhereContext::likeClause() {
  return getRuleContext<MySQLParser::LikeClauseContext>(0);
}

MySQLParser::WhereClauseContext* MySQLParser::LikeOrWhereContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}


size_t MySQLParser::LikeOrWhereContext::getRuleIndex() const {
  return MySQLParser::RuleLikeOrWhere;
}

void MySQLParser::LikeOrWhereContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLikeOrWhere(this);
}

void MySQLParser::LikeOrWhereContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLikeOrWhere(this);
}


std::any MySQLParser::LikeOrWhereContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLikeOrWhere(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LikeOrWhereContext* MySQLParser::likeOrWhere() {
  LikeOrWhereContext *_localctx = _tracker.createInstance<LikeOrWhereContext>(_ctx, getState());
  enterRule(_localctx, 1326, MySQLParser::RuleLikeOrWhere);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9177);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::LIKE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(9175);
        likeClause();
        break;
      }

      case MySQLParser::WHERE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(9176);
        whereClause();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OnlineOptionContext ------------------------------------------------------------------

MySQLParser::OnlineOptionContext::OnlineOptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OnlineOptionContext::ONLINE_SYMBOL() {
  return getToken(MySQLParser::ONLINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OnlineOptionContext::OFFLINE_SYMBOL() {
  return getToken(MySQLParser::OFFLINE_SYMBOL, 0);
}


size_t MySQLParser::OnlineOptionContext::getRuleIndex() const {
  return MySQLParser::RuleOnlineOption;
}

void MySQLParser::OnlineOptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOnlineOption(this);
}

void MySQLParser::OnlineOptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOnlineOption(this);
}


std::any MySQLParser::OnlineOptionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOnlineOption(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OnlineOptionContext* MySQLParser::onlineOption() {
  OnlineOptionContext *_localctx = _tracker.createInstance<OnlineOptionContext>(_ctx, getState());
  enterRule(_localctx, 1328, MySQLParser::RuleOnlineOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9179);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::OFFLINE_SYMBOL

    || _la == MySQLParser::ONLINE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NoWriteToBinLogContext ------------------------------------------------------------------

MySQLParser::NoWriteToBinLogContext::NoWriteToBinLogContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NoWriteToBinLogContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NoWriteToBinLogContext::NO_WRITE_TO_BINLOG_SYMBOL() {
  return getToken(MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL, 0);
}


size_t MySQLParser::NoWriteToBinLogContext::getRuleIndex() const {
  return MySQLParser::RuleNoWriteToBinLog;
}

void MySQLParser::NoWriteToBinLogContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNoWriteToBinLog(this);
}

void MySQLParser::NoWriteToBinLogContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNoWriteToBinLog(this);
}


std::any MySQLParser::NoWriteToBinLogContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNoWriteToBinLog(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NoWriteToBinLogContext* MySQLParser::noWriteToBinLog() {
  NoWriteToBinLogContext *_localctx = _tracker.createInstance<NoWriteToBinLogContext>(_ctx, getState());
  enterRule(_localctx, 1330, MySQLParser::RuleNoWriteToBinLog);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9181);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UsePartitionContext ------------------------------------------------------------------

MySQLParser::UsePartitionContext::UsePartitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UsePartitionContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

MySQLParser::IdentifierListWithParenthesesContext* MySQLParser::UsePartitionContext::identifierListWithParentheses() {
  return getRuleContext<MySQLParser::IdentifierListWithParenthesesContext>(0);
}


size_t MySQLParser::UsePartitionContext::getRuleIndex() const {
  return MySQLParser::RuleUsePartition;
}

void MySQLParser::UsePartitionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUsePartition(this);
}

void MySQLParser::UsePartitionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUsePartition(this);
}


std::any MySQLParser::UsePartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUsePartition(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UsePartitionContext* MySQLParser::usePartition() {
  UsePartitionContext *_localctx = _tracker.createInstance<UsePartitionContext>(_ctx, getState());
  enterRule(_localctx, 1332, MySQLParser::RuleUsePartition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9183);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(9184);
    identifierListWithParentheses();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FieldIdentifierContext ------------------------------------------------------------------

MySQLParser::FieldIdentifierContext::FieldIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::DotIdentifierContext* MySQLParser::FieldIdentifierContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::FieldIdentifierContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::FieldIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleFieldIdentifier;
}

void MySQLParser::FieldIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFieldIdentifier(this);
}

void MySQLParser::FieldIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFieldIdentifier(this);
}


std::any MySQLParser::FieldIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFieldIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FieldIdentifierContext* MySQLParser::fieldIdentifier() {
  FieldIdentifierContext *_localctx = _tracker.createInstance<FieldIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1334, MySQLParser::RuleFieldIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9191);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1158, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9186);
      dotIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9187);
      qualifiedIdentifier();
      setState(9189);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1157, _ctx)) {
      case 1: {
        setState(9188);
        dotIdentifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnNameContext ------------------------------------------------------------------

MySQLParser::ColumnNameContext::ColumnNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::ColumnNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::FieldIdentifierContext* MySQLParser::ColumnNameContext::fieldIdentifier() {
  return getRuleContext<MySQLParser::FieldIdentifierContext>(0);
}


size_t MySQLParser::ColumnNameContext::getRuleIndex() const {
  return MySQLParser::RuleColumnName;
}

void MySQLParser::ColumnNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnName(this);
}

void MySQLParser::ColumnNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnName(this);
}


std::any MySQLParser::ColumnNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnNameContext* MySQLParser::columnName() {
  ColumnNameContext *_localctx = _tracker.createInstance<ColumnNameContext>(_ctx, getState());
  enterRule(_localctx, 1336, MySQLParser::RuleColumnName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9197);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1159, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9193);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9194);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9195);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(9196);
      fieldIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnInternalRefContext ------------------------------------------------------------------

MySQLParser::ColumnInternalRefContext::ColumnInternalRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::ColumnInternalRefContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::ColumnInternalRefContext::getRuleIndex() const {
  return MySQLParser::RuleColumnInternalRef;
}

void MySQLParser::ColumnInternalRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnInternalRef(this);
}

void MySQLParser::ColumnInternalRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnInternalRef(this);
}


std::any MySQLParser::ColumnInternalRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnInternalRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnInternalRefContext* MySQLParser::columnInternalRef() {
  ColumnInternalRefContext *_localctx = _tracker.createInstance<ColumnInternalRefContext>(_ctx, getState());
  enterRule(_localctx, 1338, MySQLParser::RuleColumnInternalRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9199);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnInternalRefListContext ------------------------------------------------------------------

MySQLParser::ColumnInternalRefListContext::ColumnInternalRefListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ColumnInternalRefListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::ColumnInternalRefContext *> MySQLParser::ColumnInternalRefListContext::columnInternalRef() {
  return getRuleContexts<MySQLParser::ColumnInternalRefContext>();
}

MySQLParser::ColumnInternalRefContext* MySQLParser::ColumnInternalRefListContext::columnInternalRef(size_t i) {
  return getRuleContext<MySQLParser::ColumnInternalRefContext>(i);
}

tree::TerminalNode* MySQLParser::ColumnInternalRefListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::ColumnInternalRefListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::ColumnInternalRefListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::ColumnInternalRefListContext::getRuleIndex() const {
  return MySQLParser::RuleColumnInternalRefList;
}

void MySQLParser::ColumnInternalRefListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnInternalRefList(this);
}

void MySQLParser::ColumnInternalRefListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnInternalRefList(this);
}


std::any MySQLParser::ColumnInternalRefListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnInternalRefList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnInternalRefListContext* MySQLParser::columnInternalRefList() {
  ColumnInternalRefListContext *_localctx = _tracker.createInstance<ColumnInternalRefListContext>(_ctx, getState());
  enterRule(_localctx, 1340, MySQLParser::RuleColumnInternalRefList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9201);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(9202);
    columnInternalRef();
    setState(9207);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(9203);
      match(MySQLParser::COMMA_SYMBOL);
      setState(9204);
      columnInternalRef();
      setState(9209);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(9210);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColumnRefContext ------------------------------------------------------------------

MySQLParser::ColumnRefContext::ColumnRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::FieldIdentifierContext* MySQLParser::ColumnRefContext::fieldIdentifier() {
  return getRuleContext<MySQLParser::FieldIdentifierContext>(0);
}


size_t MySQLParser::ColumnRefContext::getRuleIndex() const {
  return MySQLParser::RuleColumnRef;
}

void MySQLParser::ColumnRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterColumnRef(this);
}

void MySQLParser::ColumnRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitColumnRef(this);
}


std::any MySQLParser::ColumnRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitColumnRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ColumnRefContext* MySQLParser::columnRef() {
  ColumnRefContext *_localctx = _tracker.createInstance<ColumnRefContext>(_ctx, getState());
  enterRule(_localctx, 1342, MySQLParser::RuleColumnRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9212);
    fieldIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertIdentifierContext ------------------------------------------------------------------

MySQLParser::InsertIdentifierContext::InsertIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::ColumnRefContext* MySQLParser::InsertIdentifierContext::columnRef() {
  return getRuleContext<MySQLParser::ColumnRefContext>(0);
}

MySQLParser::TableWildContext* MySQLParser::InsertIdentifierContext::tableWild() {
  return getRuleContext<MySQLParser::TableWildContext>(0);
}


size_t MySQLParser::InsertIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleInsertIdentifier;
}

void MySQLParser::InsertIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInsertIdentifier(this);
}

void MySQLParser::InsertIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInsertIdentifier(this);
}


std::any MySQLParser::InsertIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInsertIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::InsertIdentifierContext* MySQLParser::insertIdentifier() {
  InsertIdentifierContext *_localctx = _tracker.createInstance<InsertIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1344, MySQLParser::RuleInsertIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9216);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1161, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9214);
      columnRef();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9215);
      tableWild();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexNameContext ------------------------------------------------------------------

MySQLParser::IndexNameContext::IndexNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::IndexNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::IndexNameContext::getRuleIndex() const {
  return MySQLParser::RuleIndexName;
}

void MySQLParser::IndexNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexName(this);
}

void MySQLParser::IndexNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexName(this);
}


std::any MySQLParser::IndexNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexNameContext* MySQLParser::indexName() {
  IndexNameContext *_localctx = _tracker.createInstance<IndexNameContext>(_ctx, getState());
  enterRule(_localctx, 1346, MySQLParser::RuleIndexName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9218);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IndexRefContext ------------------------------------------------------------------

MySQLParser::IndexRefContext::IndexRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::FieldIdentifierContext* MySQLParser::IndexRefContext::fieldIdentifier() {
  return getRuleContext<MySQLParser::FieldIdentifierContext>(0);
}


size_t MySQLParser::IndexRefContext::getRuleIndex() const {
  return MySQLParser::RuleIndexRef;
}

void MySQLParser::IndexRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIndexRef(this);
}

void MySQLParser::IndexRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIndexRef(this);
}


std::any MySQLParser::IndexRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIndexRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IndexRefContext* MySQLParser::indexRef() {
  IndexRefContext *_localctx = _tracker.createInstance<IndexRefContext>(_ctx, getState());
  enterRule(_localctx, 1348, MySQLParser::RuleIndexRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9220);
    fieldIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableWildContext ------------------------------------------------------------------

MySQLParser::TableWildContext::TableWildContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::IdentifierContext *> MySQLParser::TableWildContext::identifier() {
  return getRuleContexts<MySQLParser::IdentifierContext>();
}

MySQLParser::IdentifierContext* MySQLParser::TableWildContext::identifier(size_t i) {
  return getRuleContext<MySQLParser::IdentifierContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TableWildContext::DOT_SYMBOL() {
  return getTokens(MySQLParser::DOT_SYMBOL);
}

tree::TerminalNode* MySQLParser::TableWildContext::DOT_SYMBOL(size_t i) {
  return getToken(MySQLParser::DOT_SYMBOL, i);
}

tree::TerminalNode* MySQLParser::TableWildContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}


size_t MySQLParser::TableWildContext::getRuleIndex() const {
  return MySQLParser::RuleTableWild;
}

void MySQLParser::TableWildContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableWild(this);
}

void MySQLParser::TableWildContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableWild(this);
}


std::any MySQLParser::TableWildContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableWild(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableWildContext* MySQLParser::tableWild() {
  TableWildContext *_localctx = _tracker.createInstance<TableWildContext>(_ctx, getState());
  enterRule(_localctx, 1350, MySQLParser::RuleTableWild);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9222);
    identifier();
    setState(9223);
    match(MySQLParser::DOT_SYMBOL);
    setState(9227);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1162, _ctx)) {
    case 1: {
      setState(9224);
      identifier();
      setState(9225);
      match(MySQLParser::DOT_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(9229);
    match(MySQLParser::MULT_OPERATOR);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SchemaNameContext ------------------------------------------------------------------

MySQLParser::SchemaNameContext::SchemaNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::SchemaNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::SchemaNameContext::getRuleIndex() const {
  return MySQLParser::RuleSchemaName;
}

void MySQLParser::SchemaNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSchemaName(this);
}

void MySQLParser::SchemaNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSchemaName(this);
}


std::any MySQLParser::SchemaNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSchemaName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SchemaNameContext* MySQLParser::schemaName() {
  SchemaNameContext *_localctx = _tracker.createInstance<SchemaNameContext>(_ctx, getState());
  enterRule(_localctx, 1352, MySQLParser::RuleSchemaName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9231);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SchemaRefContext ------------------------------------------------------------------

MySQLParser::SchemaRefContext::SchemaRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::SchemaRefContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::SchemaRefContext::getRuleIndex() const {
  return MySQLParser::RuleSchemaRef;
}

void MySQLParser::SchemaRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSchemaRef(this);
}

void MySQLParser::SchemaRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSchemaRef(this);
}


std::any MySQLParser::SchemaRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSchemaRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SchemaRefContext* MySQLParser::schemaRef() {
  SchemaRefContext *_localctx = _tracker.createInstance<SchemaRefContext>(_ctx, getState());
  enterRule(_localctx, 1354, MySQLParser::RuleSchemaRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9233);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProcedureNameContext ------------------------------------------------------------------

MySQLParser::ProcedureNameContext::ProcedureNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::ProcedureNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::ProcedureNameContext::getRuleIndex() const {
  return MySQLParser::RuleProcedureName;
}

void MySQLParser::ProcedureNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProcedureName(this);
}

void MySQLParser::ProcedureNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProcedureName(this);
}


std::any MySQLParser::ProcedureNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitProcedureName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ProcedureNameContext* MySQLParser::procedureName() {
  ProcedureNameContext *_localctx = _tracker.createInstance<ProcedureNameContext>(_ctx, getState());
  enterRule(_localctx, 1356, MySQLParser::RuleProcedureName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9235);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProcedureRefContext ------------------------------------------------------------------

MySQLParser::ProcedureRefContext::ProcedureRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::ProcedureRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::ProcedureRefContext::getRuleIndex() const {
  return MySQLParser::RuleProcedureRef;
}

void MySQLParser::ProcedureRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProcedureRef(this);
}

void MySQLParser::ProcedureRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProcedureRef(this);
}


std::any MySQLParser::ProcedureRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitProcedureRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ProcedureRefContext* MySQLParser::procedureRef() {
  ProcedureRefContext *_localctx = _tracker.createInstance<ProcedureRefContext>(_ctx, getState());
  enterRule(_localctx, 1358, MySQLParser::RuleProcedureRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9237);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionNameContext ------------------------------------------------------------------

MySQLParser::FunctionNameContext::FunctionNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::FunctionNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::FunctionNameContext::getRuleIndex() const {
  return MySQLParser::RuleFunctionName;
}

void MySQLParser::FunctionNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFunctionName(this);
}

void MySQLParser::FunctionNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFunctionName(this);
}


std::any MySQLParser::FunctionNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFunctionName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FunctionNameContext* MySQLParser::functionName() {
  FunctionNameContext *_localctx = _tracker.createInstance<FunctionNameContext>(_ctx, getState());
  enterRule(_localctx, 1360, MySQLParser::RuleFunctionName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9239);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionRefContext ------------------------------------------------------------------

MySQLParser::FunctionRefContext::FunctionRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::FunctionRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::FunctionRefContext::getRuleIndex() const {
  return MySQLParser::RuleFunctionRef;
}

void MySQLParser::FunctionRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFunctionRef(this);
}

void MySQLParser::FunctionRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFunctionRef(this);
}


std::any MySQLParser::FunctionRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFunctionRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FunctionRefContext* MySQLParser::functionRef() {
  FunctionRefContext *_localctx = _tracker.createInstance<FunctionRefContext>(_ctx, getState());
  enterRule(_localctx, 1362, MySQLParser::RuleFunctionRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9241);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TriggerNameContext ------------------------------------------------------------------

MySQLParser::TriggerNameContext::TriggerNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::TriggerNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::TriggerNameContext::getRuleIndex() const {
  return MySQLParser::RuleTriggerName;
}

void MySQLParser::TriggerNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTriggerName(this);
}

void MySQLParser::TriggerNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTriggerName(this);
}


std::any MySQLParser::TriggerNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTriggerName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TriggerNameContext* MySQLParser::triggerName() {
  TriggerNameContext *_localctx = _tracker.createInstance<TriggerNameContext>(_ctx, getState());
  enterRule(_localctx, 1364, MySQLParser::RuleTriggerName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9243);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TriggerRefContext ------------------------------------------------------------------

MySQLParser::TriggerRefContext::TriggerRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::TriggerRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::TriggerRefContext::getRuleIndex() const {
  return MySQLParser::RuleTriggerRef;
}

void MySQLParser::TriggerRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTriggerRef(this);
}

void MySQLParser::TriggerRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTriggerRef(this);
}


std::any MySQLParser::TriggerRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTriggerRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TriggerRefContext* MySQLParser::triggerRef() {
  TriggerRefContext *_localctx = _tracker.createInstance<TriggerRefContext>(_ctx, getState());
  enterRule(_localctx, 1366, MySQLParser::RuleTriggerRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9245);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewNameContext ------------------------------------------------------------------

MySQLParser::ViewNameContext::ViewNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::ViewNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::ViewNameContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::ViewNameContext::getRuleIndex() const {
  return MySQLParser::RuleViewName;
}

void MySQLParser::ViewNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewName(this);
}

void MySQLParser::ViewNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewName(this);
}


std::any MySQLParser::ViewNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewNameContext* MySQLParser::viewName() {
  ViewNameContext *_localctx = _tracker.createInstance<ViewNameContext>(_ctx, getState());
  enterRule(_localctx, 1368, MySQLParser::RuleViewName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9249);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1163, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9247);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9248);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewRefContext ------------------------------------------------------------------

MySQLParser::ViewRefContext::ViewRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::ViewRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::ViewRefContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::ViewRefContext::getRuleIndex() const {
  return MySQLParser::RuleViewRef;
}

void MySQLParser::ViewRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterViewRef(this);
}

void MySQLParser::ViewRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitViewRef(this);
}


std::any MySQLParser::ViewRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitViewRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ViewRefContext* MySQLParser::viewRef() {
  ViewRefContext *_localctx = _tracker.createInstance<ViewRefContext>(_ctx, getState());
  enterRule(_localctx, 1370, MySQLParser::RuleViewRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9253);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1164, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9251);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9252);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablespaceNameContext ------------------------------------------------------------------

MySQLParser::TablespaceNameContext::TablespaceNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::TablespaceNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::TablespaceNameContext::getRuleIndex() const {
  return MySQLParser::RuleTablespaceName;
}

void MySQLParser::TablespaceNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTablespaceName(this);
}

void MySQLParser::TablespaceNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTablespaceName(this);
}


std::any MySQLParser::TablespaceNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTablespaceName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TablespaceNameContext* MySQLParser::tablespaceName() {
  TablespaceNameContext *_localctx = _tracker.createInstance<TablespaceNameContext>(_ctx, getState());
  enterRule(_localctx, 1372, MySQLParser::RuleTablespaceName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9255);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablespaceRefContext ------------------------------------------------------------------

MySQLParser::TablespaceRefContext::TablespaceRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::TablespaceRefContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::TablespaceRefContext::getRuleIndex() const {
  return MySQLParser::RuleTablespaceRef;
}

void MySQLParser::TablespaceRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTablespaceRef(this);
}

void MySQLParser::TablespaceRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTablespaceRef(this);
}


std::any MySQLParser::TablespaceRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTablespaceRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TablespaceRefContext* MySQLParser::tablespaceRef() {
  TablespaceRefContext *_localctx = _tracker.createInstance<TablespaceRefContext>(_ctx, getState());
  enterRule(_localctx, 1374, MySQLParser::RuleTablespaceRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9257);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogfileGroupNameContext ------------------------------------------------------------------

MySQLParser::LogfileGroupNameContext::LogfileGroupNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::LogfileGroupNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::LogfileGroupNameContext::getRuleIndex() const {
  return MySQLParser::RuleLogfileGroupName;
}

void MySQLParser::LogfileGroupNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLogfileGroupName(this);
}

void MySQLParser::LogfileGroupNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLogfileGroupName(this);
}


std::any MySQLParser::LogfileGroupNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLogfileGroupName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LogfileGroupNameContext* MySQLParser::logfileGroupName() {
  LogfileGroupNameContext *_localctx = _tracker.createInstance<LogfileGroupNameContext>(_ctx, getState());
  enterRule(_localctx, 1376, MySQLParser::RuleLogfileGroupName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9259);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LogfileGroupRefContext ------------------------------------------------------------------

MySQLParser::LogfileGroupRefContext::LogfileGroupRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::LogfileGroupRefContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::LogfileGroupRefContext::getRuleIndex() const {
  return MySQLParser::RuleLogfileGroupRef;
}

void MySQLParser::LogfileGroupRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLogfileGroupRef(this);
}

void MySQLParser::LogfileGroupRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLogfileGroupRef(this);
}


std::any MySQLParser::LogfileGroupRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLogfileGroupRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LogfileGroupRefContext* MySQLParser::logfileGroupRef() {
  LogfileGroupRefContext *_localctx = _tracker.createInstance<LogfileGroupRefContext>(_ctx, getState());
  enterRule(_localctx, 1378, MySQLParser::RuleLogfileGroupRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9261);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EventNameContext ------------------------------------------------------------------

MySQLParser::EventNameContext::EventNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::EventNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::EventNameContext::getRuleIndex() const {
  return MySQLParser::RuleEventName;
}

void MySQLParser::EventNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEventName(this);
}

void MySQLParser::EventNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEventName(this);
}


std::any MySQLParser::EventNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitEventName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::EventNameContext* MySQLParser::eventName() {
  EventNameContext *_localctx = _tracker.createInstance<EventNameContext>(_ctx, getState());
  enterRule(_localctx, 1380, MySQLParser::RuleEventName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9263);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EventRefContext ------------------------------------------------------------------

MySQLParser::EventRefContext::EventRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::EventRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::EventRefContext::getRuleIndex() const {
  return MySQLParser::RuleEventRef;
}

void MySQLParser::EventRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEventRef(this);
}

void MySQLParser::EventRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEventRef(this);
}


std::any MySQLParser::EventRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitEventRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::EventRefContext* MySQLParser::eventRef() {
  EventRefContext *_localctx = _tracker.createInstance<EventRefContext>(_ctx, getState());
  enterRule(_localctx, 1382, MySQLParser::RuleEventRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9265);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UdfNameContext ------------------------------------------------------------------

MySQLParser::UdfNameContext::UdfNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::UdfNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::UdfNameContext::getRuleIndex() const {
  return MySQLParser::RuleUdfName;
}

void MySQLParser::UdfNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUdfName(this);
}

void MySQLParser::UdfNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUdfName(this);
}


std::any MySQLParser::UdfNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUdfName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UdfNameContext* MySQLParser::udfName() {
  UdfNameContext *_localctx = _tracker.createInstance<UdfNameContext>(_ctx, getState());
  enterRule(_localctx, 1384, MySQLParser::RuleUdfName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9267);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ServerNameContext ------------------------------------------------------------------

MySQLParser::ServerNameContext::ServerNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::ServerNameContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::ServerNameContext::getRuleIndex() const {
  return MySQLParser::RuleServerName;
}

void MySQLParser::ServerNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterServerName(this);
}

void MySQLParser::ServerNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitServerName(this);
}


std::any MySQLParser::ServerNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitServerName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ServerNameContext* MySQLParser::serverName() {
  ServerNameContext *_localctx = _tracker.createInstance<ServerNameContext>(_ctx, getState());
  enterRule(_localctx, 1386, MySQLParser::RuleServerName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9269);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ServerRefContext ------------------------------------------------------------------

MySQLParser::ServerRefContext::ServerRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::ServerRefContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::ServerRefContext::getRuleIndex() const {
  return MySQLParser::RuleServerRef;
}

void MySQLParser::ServerRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterServerRef(this);
}

void MySQLParser::ServerRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitServerRef(this);
}


std::any MySQLParser::ServerRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitServerRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ServerRefContext* MySQLParser::serverRef() {
  ServerRefContext *_localctx = _tracker.createInstance<ServerRefContext>(_ctx, getState());
  enterRule(_localctx, 1388, MySQLParser::RuleServerRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9271);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EngineRefContext ------------------------------------------------------------------

MySQLParser::EngineRefContext::EngineRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextOrIdentifierContext* MySQLParser::EngineRefContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}


size_t MySQLParser::EngineRefContext::getRuleIndex() const {
  return MySQLParser::RuleEngineRef;
}

void MySQLParser::EngineRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEngineRef(this);
}

void MySQLParser::EngineRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEngineRef(this);
}


std::any MySQLParser::EngineRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitEngineRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::EngineRefContext* MySQLParser::engineRef() {
  EngineRefContext *_localctx = _tracker.createInstance<EngineRefContext>(_ctx, getState());
  enterRule(_localctx, 1390, MySQLParser::RuleEngineRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9273);
    textOrIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableNameContext ------------------------------------------------------------------

MySQLParser::TableNameContext::TableNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::TableNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::TableNameContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::TableNameContext::getRuleIndex() const {
  return MySQLParser::RuleTableName;
}

void MySQLParser::TableNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableName(this);
}

void MySQLParser::TableNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableName(this);
}


std::any MySQLParser::TableNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableNameContext* MySQLParser::tableName() {
  TableNameContext *_localctx = _tracker.createInstance<TableNameContext>(_ctx, getState());
  enterRule(_localctx, 1392, MySQLParser::RuleTableName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9277);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1165, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9275);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9276);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FilterTableRefContext ------------------------------------------------------------------

MySQLParser::FilterTableRefContext::FilterTableRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SchemaRefContext* MySQLParser::FilterTableRefContext::schemaRef() {
  return getRuleContext<MySQLParser::SchemaRefContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::FilterTableRefContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::FilterTableRefContext::getRuleIndex() const {
  return MySQLParser::RuleFilterTableRef;
}

void MySQLParser::FilterTableRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFilterTableRef(this);
}

void MySQLParser::FilterTableRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFilterTableRef(this);
}


std::any MySQLParser::FilterTableRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFilterTableRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FilterTableRefContext* MySQLParser::filterTableRef() {
  FilterTableRefContext *_localctx = _tracker.createInstance<FilterTableRefContext>(_ctx, getState());
  enterRule(_localctx, 1394, MySQLParser::RuleFilterTableRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9279);
    schemaRef();
    setState(9280);
    dotIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableRefWithWildcardContext ------------------------------------------------------------------

MySQLParser::TableRefWithWildcardContext::TableRefWithWildcardContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::TableRefWithWildcardContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::TableRefWithWildcardContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TableRefWithWildcardContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

MySQLParser::DotIdentifierContext* MySQLParser::TableRefWithWildcardContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::TableRefWithWildcardContext::getRuleIndex() const {
  return MySQLParser::RuleTableRefWithWildcard;
}

void MySQLParser::TableRefWithWildcardContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableRefWithWildcard(this);
}

void MySQLParser::TableRefWithWildcardContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableRefWithWildcard(this);
}


std::any MySQLParser::TableRefWithWildcardContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableRefWithWildcard(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableRefWithWildcardContext* MySQLParser::tableRefWithWildcard() {
  TableRefWithWildcardContext *_localctx = _tracker.createInstance<TableRefWithWildcardContext>(_ctx, getState());
  enterRule(_localctx, 1396, MySQLParser::RuleTableRefWithWildcard);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9282);
    identifier();
    setState(9290);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1167, _ctx)) {
    case 1: {
      setState(9283);
      match(MySQLParser::DOT_SYMBOL);
      setState(9284);
      match(MySQLParser::MULT_OPERATOR);
      break;
    }

    case 2: {
      setState(9285);
      dotIdentifier();
      setState(9288);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1166, _ctx)) {
      case 1: {
        setState(9286);
        match(MySQLParser::DOT_SYMBOL);
        setState(9287);
        match(MySQLParser::MULT_OPERATOR);
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableRefContext ------------------------------------------------------------------

MySQLParser::TableRefContext::TableRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::TableRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::TableRefContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::TableRefContext::getRuleIndex() const {
  return MySQLParser::RuleTableRef;
}

void MySQLParser::TableRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableRef(this);
}

void MySQLParser::TableRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableRef(this);
}


std::any MySQLParser::TableRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableRefContext* MySQLParser::tableRef() {
  TableRefContext *_localctx = _tracker.createInstance<TableRefContext>(_ctx, getState());
  enterRule(_localctx, 1398, MySQLParser::RuleTableRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9294);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1168, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9292);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9293);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableRefListContext ------------------------------------------------------------------

MySQLParser::TableRefListContext::TableRefListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TableRefContext *> MySQLParser::TableRefListContext::tableRef() {
  return getRuleContexts<MySQLParser::TableRefContext>();
}

MySQLParser::TableRefContext* MySQLParser::TableRefListContext::tableRef(size_t i) {
  return getRuleContext<MySQLParser::TableRefContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TableRefListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TableRefListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TableRefListContext::getRuleIndex() const {
  return MySQLParser::RuleTableRefList;
}

void MySQLParser::TableRefListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableRefList(this);
}

void MySQLParser::TableRefListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableRefList(this);
}


std::any MySQLParser::TableRefListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableRefList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableRefListContext* MySQLParser::tableRefList() {
  TableRefListContext *_localctx = _tracker.createInstance<TableRefListContext>(_ctx, getState());
  enterRule(_localctx, 1400, MySQLParser::RuleTableRefList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9296);
    tableRef();
    setState(9301);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1169, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9297);
        match(MySQLParser::COMMA_SYMBOL);
        setState(9298);
        tableRef(); 
      }
      setState(9303);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1169, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableAliasRefListContext ------------------------------------------------------------------

MySQLParser::TableAliasRefListContext::TableAliasRefListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TableRefWithWildcardContext *> MySQLParser::TableAliasRefListContext::tableRefWithWildcard() {
  return getRuleContexts<MySQLParser::TableRefWithWildcardContext>();
}

MySQLParser::TableRefWithWildcardContext* MySQLParser::TableAliasRefListContext::tableRefWithWildcard(size_t i) {
  return getRuleContext<MySQLParser::TableRefWithWildcardContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TableAliasRefListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TableAliasRefListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TableAliasRefListContext::getRuleIndex() const {
  return MySQLParser::RuleTableAliasRefList;
}

void MySQLParser::TableAliasRefListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTableAliasRefList(this);
}

void MySQLParser::TableAliasRefListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTableAliasRefList(this);
}


std::any MySQLParser::TableAliasRefListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTableAliasRefList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TableAliasRefListContext* MySQLParser::tableAliasRefList() {
  TableAliasRefListContext *_localctx = _tracker.createInstance<TableAliasRefListContext>(_ctx, getState());
  enterRule(_localctx, 1402, MySQLParser::RuleTableAliasRefList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9304);
    tableRefWithWildcard();
    setState(9309);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1170, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9305);
        match(MySQLParser::COMMA_SYMBOL);
        setState(9306);
        tableRefWithWildcard(); 
      }
      setState(9311);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1170, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParameterNameContext ------------------------------------------------------------------

MySQLParser::ParameterNameContext::ParameterNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::ParameterNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::ParameterNameContext::getRuleIndex() const {
  return MySQLParser::RuleParameterName;
}

void MySQLParser::ParameterNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterParameterName(this);
}

void MySQLParser::ParameterNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitParameterName(this);
}


std::any MySQLParser::ParameterNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitParameterName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ParameterNameContext* MySQLParser::parameterName() {
  ParameterNameContext *_localctx = _tracker.createInstance<ParameterNameContext>(_ctx, getState());
  enterRule(_localctx, 1404, MySQLParser::RuleParameterName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9312);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabelIdentifierContext ------------------------------------------------------------------

MySQLParser::LabelIdentifierContext::LabelIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PureIdentifierContext* MySQLParser::LabelIdentifierContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}

MySQLParser::LabelKeywordContext* MySQLParser::LabelIdentifierContext::labelKeyword() {
  return getRuleContext<MySQLParser::LabelKeywordContext>(0);
}


size_t MySQLParser::LabelIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleLabelIdentifier;
}

void MySQLParser::LabelIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabelIdentifier(this);
}

void MySQLParser::LabelIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabelIdentifier(this);
}


std::any MySQLParser::LabelIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLabelIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LabelIdentifierContext* MySQLParser::labelIdentifier() {
  LabelIdentifierContext *_localctx = _tracker.createInstance<LabelIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1406, MySQLParser::RuleLabelIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9316);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1171, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9314);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9315);
      labelKeyword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabelRefContext ------------------------------------------------------------------

MySQLParser::LabelRefContext::LabelRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LabelIdentifierContext* MySQLParser::LabelRefContext::labelIdentifier() {
  return getRuleContext<MySQLParser::LabelIdentifierContext>(0);
}


size_t MySQLParser::LabelRefContext::getRuleIndex() const {
  return MySQLParser::RuleLabelRef;
}

void MySQLParser::LabelRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabelRef(this);
}

void MySQLParser::LabelRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabelRef(this);
}


std::any MySQLParser::LabelRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLabelRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LabelRefContext* MySQLParser::labelRef() {
  LabelRefContext *_localctx = _tracker.createInstance<LabelRefContext>(_ctx, getState());
  enterRule(_localctx, 1408, MySQLParser::RuleLabelRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9318);
    labelIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleIdentifierContext ------------------------------------------------------------------

MySQLParser::RoleIdentifierContext::RoleIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PureIdentifierContext* MySQLParser::RoleIdentifierContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}

MySQLParser::RoleKeywordContext* MySQLParser::RoleIdentifierContext::roleKeyword() {
  return getRuleContext<MySQLParser::RoleKeywordContext>(0);
}


size_t MySQLParser::RoleIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleRoleIdentifier;
}

void MySQLParser::RoleIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleIdentifier(this);
}

void MySQLParser::RoleIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleIdentifier(this);
}


std::any MySQLParser::RoleIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleIdentifierContext* MySQLParser::roleIdentifier() {
  RoleIdentifierContext *_localctx = _tracker.createInstance<RoleIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1410, MySQLParser::RuleRoleIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9322);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1172, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9320);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9321);
      roleKeyword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PluginRefContext ------------------------------------------------------------------

MySQLParser::PluginRefContext::PluginRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::PluginRefContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::PluginRefContext::getRuleIndex() const {
  return MySQLParser::RulePluginRef;
}

void MySQLParser::PluginRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPluginRef(this);
}

void MySQLParser::PluginRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPluginRef(this);
}


std::any MySQLParser::PluginRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPluginRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PluginRefContext* MySQLParser::pluginRef() {
  PluginRefContext *_localctx = _tracker.createInstance<PluginRefContext>(_ctx, getState());
  enterRule(_localctx, 1412, MySQLParser::RulePluginRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9324);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ComponentRefContext ------------------------------------------------------------------

MySQLParser::ComponentRefContext::ComponentRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringLiteralContext* MySQLParser::ComponentRefContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::ComponentRefContext::getRuleIndex() const {
  return MySQLParser::RuleComponentRef;
}

void MySQLParser::ComponentRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterComponentRef(this);
}

void MySQLParser::ComponentRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitComponentRef(this);
}


std::any MySQLParser::ComponentRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitComponentRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ComponentRefContext* MySQLParser::componentRef() {
  ComponentRefContext *_localctx = _tracker.createInstance<ComponentRefContext>(_ctx, getState());
  enterRule(_localctx, 1414, MySQLParser::RuleComponentRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9326);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ResourceGroupRefContext ------------------------------------------------------------------

MySQLParser::ResourceGroupRefContext::ResourceGroupRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::ResourceGroupRefContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::ResourceGroupRefContext::getRuleIndex() const {
  return MySQLParser::RuleResourceGroupRef;
}

void MySQLParser::ResourceGroupRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterResourceGroupRef(this);
}

void MySQLParser::ResourceGroupRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitResourceGroupRef(this);
}


std::any MySQLParser::ResourceGroupRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitResourceGroupRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ResourceGroupRefContext* MySQLParser::resourceGroupRef() {
  ResourceGroupRefContext *_localctx = _tracker.createInstance<ResourceGroupRefContext>(_ctx, getState());
  enterRule(_localctx, 1416, MySQLParser::RuleResourceGroupRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9328);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowNameContext ------------------------------------------------------------------

MySQLParser::WindowNameContext::WindowNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::WindowNameContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::WindowNameContext::getRuleIndex() const {
  return MySQLParser::RuleWindowName;
}

void MySQLParser::WindowNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterWindowName(this);
}

void MySQLParser::WindowNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitWindowName(this);
}


std::any MySQLParser::WindowNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitWindowName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::WindowNameContext* MySQLParser::windowName() {
  WindowNameContext *_localctx = _tracker.createInstance<WindowNameContext>(_ctx, getState());
  enterRule(_localctx, 1418, MySQLParser::RuleWindowName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9330);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LibraryNameContext ------------------------------------------------------------------

MySQLParser::LibraryNameContext::LibraryNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::LibraryNameContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::LibraryNameContext::getRuleIndex() const {
  return MySQLParser::RuleLibraryName;
}

void MySQLParser::LibraryNameContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLibraryName(this);
}

void MySQLParser::LibraryNameContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLibraryName(this);
}


std::any MySQLParser::LibraryNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLibraryName(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LibraryNameContext* MySQLParser::libraryName() {
  LibraryNameContext *_localctx = _tracker.createInstance<LibraryNameContext>(_ctx, getState());
  enterRule(_localctx, 1420, MySQLParser::RuleLibraryName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9332);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LibraryRefContext ------------------------------------------------------------------

MySQLParser::LibraryRefContext::LibraryRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::LibraryRefContext::qualifiedIdentifier() {
  return getRuleContext<MySQLParser::QualifiedIdentifierContext>(0);
}


size_t MySQLParser::LibraryRefContext::getRuleIndex() const {
  return MySQLParser::RuleLibraryRef;
}

void MySQLParser::LibraryRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLibraryRef(this);
}

void MySQLParser::LibraryRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLibraryRef(this);
}


std::any MySQLParser::LibraryRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLibraryRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LibraryRefContext* MySQLParser::libraryRef() {
  LibraryRefContext *_localctx = _tracker.createInstance<LibraryRefContext>(_ctx, getState());
  enterRule(_localctx, 1422, MySQLParser::RuleLibraryRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9334);
    qualifiedIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PureIdentifierContext ------------------------------------------------------------------

MySQLParser::PureIdentifierContext::PureIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PureIdentifierContext::IDENTIFIER() {
  return getToken(MySQLParser::IDENTIFIER, 0);
}

tree::TerminalNode* MySQLParser::PureIdentifierContext::BACK_TICK_QUOTED_ID() {
  return getToken(MySQLParser::BACK_TICK_QUOTED_ID, 0);
}

tree::TerminalNode* MySQLParser::PureIdentifierContext::DOUBLE_QUOTED_TEXT() {
  return getToken(MySQLParser::DOUBLE_QUOTED_TEXT, 0);
}


size_t MySQLParser::PureIdentifierContext::getRuleIndex() const {
  return MySQLParser::RulePureIdentifier;
}

void MySQLParser::PureIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPureIdentifier(this);
}

void MySQLParser::PureIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPureIdentifier(this);
}


std::any MySQLParser::PureIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPureIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PureIdentifierContext* MySQLParser::pureIdentifier() {
  PureIdentifierContext *_localctx = _tracker.createInstance<PureIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1424, MySQLParser::RulePureIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9339);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1173, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9336);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::IDENTIFIER

      || _la == MySQLParser::BACK_TICK_QUOTED_ID)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9337);

      if (!(isSqlModeActive(AnsiQuotes))) throw FailedPredicateException(this, "isSqlModeActive(AnsiQuotes)");
      setState(9338);
      match(MySQLParser::DOUBLE_QUOTED_TEXT);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierContext ------------------------------------------------------------------

MySQLParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PureIdentifierContext* MySQLParser::IdentifierContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}

MySQLParser::IdentifierKeywordContext* MySQLParser::IdentifierContext::identifierKeyword() {
  return getRuleContext<MySQLParser::IdentifierKeywordContext>(0);
}


size_t MySQLParser::IdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifier;
}

void MySQLParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifier(this);
}

void MySQLParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifier(this);
}


std::any MySQLParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierContext* MySQLParser::identifier() {
  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1426, MySQLParser::RuleIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9343);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1174, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9341);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9342);
      identifierKeyword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierListContext ------------------------------------------------------------------

MySQLParser::IdentifierListContext::IdentifierListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::IdentifierContext *> MySQLParser::IdentifierListContext::identifier() {
  return getRuleContexts<MySQLParser::IdentifierContext>();
}

MySQLParser::IdentifierContext* MySQLParser::IdentifierListContext::identifier(size_t i) {
  return getRuleContext<MySQLParser::IdentifierContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::IdentifierListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::IdentifierListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::IdentifierListContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierList;
}

void MySQLParser::IdentifierListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierList(this);
}

void MySQLParser::IdentifierListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierList(this);
}


std::any MySQLParser::IdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierListContext* MySQLParser::identifierList() {
  IdentifierListContext *_localctx = _tracker.createInstance<IdentifierListContext>(_ctx, getState());
  enterRule(_localctx, 1428, MySQLParser::RuleIdentifierList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9345);
    identifier();
    setState(9350);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1175, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9346);
        match(MySQLParser::COMMA_SYMBOL);
        setState(9347);
        identifier(); 
      }
      setState(9352);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1175, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierListWithParenthesesContext ------------------------------------------------------------------

MySQLParser::IdentifierListWithParenthesesContext::IdentifierListWithParenthesesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifierListWithParenthesesContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

MySQLParser::IdentifierListContext* MySQLParser::IdentifierListWithParenthesesContext::identifierList() {
  return getRuleContext<MySQLParser::IdentifierListContext>(0);
}

tree::TerminalNode* MySQLParser::IdentifierListWithParenthesesContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::IdentifierListWithParenthesesContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierListWithParentheses;
}

void MySQLParser::IdentifierListWithParenthesesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierListWithParentheses(this);
}

void MySQLParser::IdentifierListWithParenthesesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierListWithParentheses(this);
}


std::any MySQLParser::IdentifierListWithParenthesesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierListWithParentheses(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierListWithParenthesesContext* MySQLParser::identifierListWithParentheses() {
  IdentifierListWithParenthesesContext *_localctx = _tracker.createInstance<IdentifierListWithParenthesesContext>(_ctx, getState());
  enterRule(_localctx, 1430, MySQLParser::RuleIdentifierListWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9353);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(9354);
    identifierList();
    setState(9355);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QualifiedIdentifierContext ------------------------------------------------------------------

MySQLParser::QualifiedIdentifierContext::QualifiedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::QualifiedIdentifierContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::QualifiedIdentifierContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::QualifiedIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleQualifiedIdentifier;
}

void MySQLParser::QualifiedIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterQualifiedIdentifier(this);
}

void MySQLParser::QualifiedIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitQualifiedIdentifier(this);
}


std::any MySQLParser::QualifiedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitQualifiedIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::QualifiedIdentifierContext* MySQLParser::qualifiedIdentifier() {
  QualifiedIdentifierContext *_localctx = _tracker.createInstance<QualifiedIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1432, MySQLParser::RuleQualifiedIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9357);
    identifier();
    setState(9359);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1176, _ctx)) {
    case 1: {
      setState(9358);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SimpleIdentifierContext ------------------------------------------------------------------

MySQLParser::SimpleIdentifierContext::SimpleIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::SimpleIdentifierContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

std::vector<MySQLParser::DotIdentifierContext *> MySQLParser::SimpleIdentifierContext::dotIdentifier() {
  return getRuleContexts<MySQLParser::DotIdentifierContext>();
}

MySQLParser::DotIdentifierContext* MySQLParser::SimpleIdentifierContext::dotIdentifier(size_t i) {
  return getRuleContext<MySQLParser::DotIdentifierContext>(i);
}


size_t MySQLParser::SimpleIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleSimpleIdentifier;
}

void MySQLParser::SimpleIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSimpleIdentifier(this);
}

void MySQLParser::SimpleIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSimpleIdentifier(this);
}


std::any MySQLParser::SimpleIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SimpleIdentifierContext* MySQLParser::simpleIdentifier() {
  SimpleIdentifierContext *_localctx = _tracker.createInstance<SimpleIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1434, MySQLParser::RuleSimpleIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9372);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1179, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9361);
      identifier();
      setState(9366);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DOT_SYMBOL) {
        setState(9362);
        dotIdentifier();
        setState(9364);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::DOT_SYMBOL) {
          setState(9363);
          dotIdentifier();
        }
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9368);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(9369);
      dotIdentifier();
      setState(9370);
      dotIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DotIdentifierContext ------------------------------------------------------------------

MySQLParser::DotIdentifierContext::DotIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::DotIdentifierContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_SYMBOL, 0);
}

MySQLParser::IdentifierContext* MySQLParser::DotIdentifierContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}


size_t MySQLParser::DotIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleDotIdentifier;
}

void MySQLParser::DotIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDotIdentifier(this);
}

void MySQLParser::DotIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDotIdentifier(this);
}


std::any MySQLParser::DotIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitDotIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::DotIdentifierContext* MySQLParser::dotIdentifier() {
  DotIdentifierContext *_localctx = _tracker.createInstance<DotIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1436, MySQLParser::RuleDotIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9374);
    match(MySQLParser::DOT_SYMBOL);
    setState(9375);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Ulong_numberContext ------------------------------------------------------------------

MySQLParser::Ulong_numberContext::Ulong_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::Ulong_numberContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulong_numberContext::HEX_NUMBER() {
  return getToken(MySQLParser::HEX_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulong_numberContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulong_numberContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulong_numberContext::DECIMAL_NUMBER() {
  return getToken(MySQLParser::DECIMAL_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulong_numberContext::FLOAT_NUMBER() {
  return getToken(MySQLParser::FLOAT_NUMBER, 0);
}


size_t MySQLParser::Ulong_numberContext::getRuleIndex() const {
  return MySQLParser::RuleUlong_number;
}

void MySQLParser::Ulong_numberContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUlong_number(this);
}

void MySQLParser::Ulong_numberContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUlong_number(this);
}


std::any MySQLParser::Ulong_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUlong_number(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::Ulong_numberContext* MySQLParser::ulong_number() {
  Ulong_numberContext *_localctx = _tracker.createInstance<Ulong_numberContext>(_ctx, getState());
  enterRule(_localctx, 1438, MySQLParser::RuleUlong_number);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9377);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
      | (1ULL << MySQLParser::LONG_NUMBER)
      | (1ULL << MySQLParser::ULONGLONG_NUMBER)
      | (1ULL << MySQLParser::HEX_NUMBER)
      | (1ULL << MySQLParser::DECIMAL_NUMBER)
      | (1ULL << MySQLParser::FLOAT_NUMBER))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Real_ulong_numberContext ------------------------------------------------------------------

MySQLParser::Real_ulong_numberContext::Real_ulong_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::Real_ulong_numberContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Real_ulong_numberContext::HEX_NUMBER() {
  return getToken(MySQLParser::HEX_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Real_ulong_numberContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Real_ulong_numberContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}


size_t MySQLParser::Real_ulong_numberContext::getRuleIndex() const {
  return MySQLParser::RuleReal_ulong_number;
}

void MySQLParser::Real_ulong_numberContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReal_ulong_number(this);
}

void MySQLParser::Real_ulong_numberContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReal_ulong_number(this);
}


std::any MySQLParser::Real_ulong_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReal_ulong_number(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::Real_ulong_numberContext* MySQLParser::real_ulong_number() {
  Real_ulong_numberContext *_localctx = _tracker.createInstance<Real_ulong_numberContext>(_ctx, getState());
  enterRule(_localctx, 1440, MySQLParser::RuleReal_ulong_number);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9379);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
      | (1ULL << MySQLParser::LONG_NUMBER)
      | (1ULL << MySQLParser::ULONGLONG_NUMBER)
      | (1ULL << MySQLParser::HEX_NUMBER))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- UlonglongNumberContext ------------------------------------------------------------------

MySQLParser::UlonglongNumberContext::UlonglongNumberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::UlonglongNumberContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::UlonglongNumberContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::UlonglongNumberContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::UlonglongNumberContext::DECIMAL_NUMBER() {
  return getToken(MySQLParser::DECIMAL_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::UlonglongNumberContext::FLOAT_NUMBER() {
  return getToken(MySQLParser::FLOAT_NUMBER, 0);
}


size_t MySQLParser::UlonglongNumberContext::getRuleIndex() const {
  return MySQLParser::RuleUlonglongNumber;
}

void MySQLParser::UlonglongNumberContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUlonglongNumber(this);
}

void MySQLParser::UlonglongNumberContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUlonglongNumber(this);
}


std::any MySQLParser::UlonglongNumberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUlonglongNumber(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::UlonglongNumberContext* MySQLParser::ulonglongNumber() {
  UlonglongNumberContext *_localctx = _tracker.createInstance<UlonglongNumberContext>(_ctx, getState());
  enterRule(_localctx, 1442, MySQLParser::RuleUlonglongNumber);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9381);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
      | (1ULL << MySQLParser::LONG_NUMBER)
      | (1ULL << MySQLParser::ULONGLONG_NUMBER)
      | (1ULL << MySQLParser::DECIMAL_NUMBER)
      | (1ULL << MySQLParser::FLOAT_NUMBER))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Real_ulonglong_numberContext ------------------------------------------------------------------

MySQLParser::Real_ulonglong_numberContext::Real_ulonglong_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::Real_ulonglong_numberContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Real_ulonglong_numberContext::HEX_NUMBER() {
  return getToken(MySQLParser::HEX_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Real_ulonglong_numberContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Real_ulonglong_numberContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}


size_t MySQLParser::Real_ulonglong_numberContext::getRuleIndex() const {
  return MySQLParser::RuleReal_ulonglong_number;
}

void MySQLParser::Real_ulonglong_numberContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterReal_ulonglong_number(this);
}

void MySQLParser::Real_ulonglong_numberContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitReal_ulonglong_number(this);
}


std::any MySQLParser::Real_ulonglong_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitReal_ulonglong_number(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::real_ulonglong_number() {
  Real_ulonglong_numberContext *_localctx = _tracker.createInstance<Real_ulonglong_numberContext>(_ctx, getState());
  enterRule(_localctx, 1444, MySQLParser::RuleReal_ulonglong_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9388);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1180, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9383);
      match(MySQLParser::INT_NUMBER);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9384);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(9385);
      match(MySQLParser::HEX_NUMBER);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9386);
      match(MySQLParser::ULONGLONG_NUMBER);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9387);
      match(MySQLParser::LONG_NUMBER);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SignedLiteralContext ------------------------------------------------------------------

MySQLParser::SignedLiteralContext::SignedLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LiteralContext* MySQLParser::SignedLiteralContext::literal() {
  return getRuleContext<MySQLParser::LiteralContext>(0);
}

tree::TerminalNode* MySQLParser::SignedLiteralContext::PLUS_OPERATOR() {
  return getToken(MySQLParser::PLUS_OPERATOR, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::SignedLiteralContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::SignedLiteralContext::MINUS_OPERATOR() {
  return getToken(MySQLParser::MINUS_OPERATOR, 0);
}


size_t MySQLParser::SignedLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleSignedLiteral;
}

void MySQLParser::SignedLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSignedLiteral(this);
}

void MySQLParser::SignedLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSignedLiteral(this);
}


std::any MySQLParser::SignedLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSignedLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SignedLiteralContext* MySQLParser::signedLiteral() {
  SignedLiteralContext *_localctx = _tracker.createInstance<SignedLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1446, MySQLParser::RuleSignedLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9395);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1181, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9390);
      literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9391);
      match(MySQLParser::PLUS_OPERATOR);
      setState(9392);
      ulong_number();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9393);
      match(MySQLParser::MINUS_OPERATOR);
      setState(9394);
      ulong_number();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SignedLiteralOrNullContext ------------------------------------------------------------------

MySQLParser::SignedLiteralOrNullContext::SignedLiteralOrNullContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::SignedLiteralContext* MySQLParser::SignedLiteralOrNullContext::signedLiteral() {
  return getRuleContext<MySQLParser::SignedLiteralContext>(0);
}

MySQLParser::NullAsLiteralContext* MySQLParser::SignedLiteralOrNullContext::nullAsLiteral() {
  return getRuleContext<MySQLParser::NullAsLiteralContext>(0);
}


size_t MySQLParser::SignedLiteralOrNullContext::getRuleIndex() const {
  return MySQLParser::RuleSignedLiteralOrNull;
}

void MySQLParser::SignedLiteralOrNullContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSignedLiteralOrNull(this);
}

void MySQLParser::SignedLiteralOrNullContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSignedLiteralOrNull(this);
}


std::any MySQLParser::SignedLiteralOrNullContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSignedLiteralOrNull(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SignedLiteralOrNullContext* MySQLParser::signedLiteralOrNull() {
  SignedLiteralOrNullContext *_localctx = _tracker.createInstance<SignedLiteralOrNullContext>(_ctx, getState());
  enterRule(_localctx, 1448, MySQLParser::RuleSignedLiteralOrNull);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9400);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1182, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9397);
      signedLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9398);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(9399);
      nullAsLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LiteralContext ------------------------------------------------------------------

MySQLParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextLiteralContext* MySQLParser::LiteralContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(0);
}

MySQLParser::NumLiteralContext* MySQLParser::LiteralContext::numLiteral() {
  return getRuleContext<MySQLParser::NumLiteralContext>(0);
}

MySQLParser::TemporalLiteralContext* MySQLParser::LiteralContext::temporalLiteral() {
  return getRuleContext<MySQLParser::TemporalLiteralContext>(0);
}

MySQLParser::NullLiteralContext* MySQLParser::LiteralContext::nullLiteral() {
  return getRuleContext<MySQLParser::NullLiteralContext>(0);
}

MySQLParser::BoolLiteralContext* MySQLParser::LiteralContext::boolLiteral() {
  return getRuleContext<MySQLParser::BoolLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::LiteralContext::HEX_NUMBER() {
  return getToken(MySQLParser::HEX_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::LiteralContext::BIN_NUMBER() {
  return getToken(MySQLParser::BIN_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::LiteralContext::UNDERSCORE_CHARSET() {
  return getToken(MySQLParser::UNDERSCORE_CHARSET, 0);
}


size_t MySQLParser::LiteralContext::getRuleIndex() const {
  return MySQLParser::RuleLiteral;
}

void MySQLParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLiteral(this);
}

void MySQLParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLiteral(this);
}


std::any MySQLParser::LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LiteralContext* MySQLParser::literal() {
  LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());
  enterRule(_localctx, 1450, MySQLParser::RuleLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9411);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1184, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9402);
      textLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9403);
      numLiteral();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9404);
      temporalLiteral();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9405);
      nullLiteral();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(9406);
      boolLiteral();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(9408);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::UNDERSCORE_CHARSET) {
        setState(9407);
        match(MySQLParser::UNDERSCORE_CHARSET);
      }
      setState(9410);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::HEX_NUMBER

      || _la == MySQLParser::BIN_NUMBER)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LiteralOrNullContext ------------------------------------------------------------------

MySQLParser::LiteralOrNullContext::LiteralOrNullContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LiteralContext* MySQLParser::LiteralOrNullContext::literal() {
  return getRuleContext<MySQLParser::LiteralContext>(0);
}

MySQLParser::NullAsLiteralContext* MySQLParser::LiteralOrNullContext::nullAsLiteral() {
  return getRuleContext<MySQLParser::NullAsLiteralContext>(0);
}


size_t MySQLParser::LiteralOrNullContext::getRuleIndex() const {
  return MySQLParser::RuleLiteralOrNull;
}

void MySQLParser::LiteralOrNullContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLiteralOrNull(this);
}

void MySQLParser::LiteralOrNullContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLiteralOrNull(this);
}


std::any MySQLParser::LiteralOrNullContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLiteralOrNull(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LiteralOrNullContext* MySQLParser::literalOrNull() {
  LiteralOrNullContext *_localctx = _tracker.createInstance<LiteralOrNullContext>(_ctx, getState());
  enterRule(_localctx, 1452, MySQLParser::RuleLiteralOrNull);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9416);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1185, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9413);
      literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9414);

      if (!(serverVersion >= 80024)) throw FailedPredicateException(this, "serverVersion >= 80024");
      setState(9415);
      nullAsLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NullAsLiteralContext ------------------------------------------------------------------

MySQLParser::NullAsLiteralContext::NullAsLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NullAsLiteralContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}


size_t MySQLParser::NullAsLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleNullAsLiteral;
}

void MySQLParser::NullAsLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNullAsLiteral(this);
}

void MySQLParser::NullAsLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNullAsLiteral(this);
}


std::any MySQLParser::NullAsLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNullAsLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NullAsLiteralContext* MySQLParser::nullAsLiteral() {
  NullAsLiteralContext *_localctx = _tracker.createInstance<NullAsLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1454, MySQLParser::RuleNullAsLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9418);
    match(MySQLParser::NULL_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StringListContext ------------------------------------------------------------------

MySQLParser::StringListContext::StringListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::StringListContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<MySQLParser::TextStringContext *> MySQLParser::StringListContext::textString() {
  return getRuleContexts<MySQLParser::TextStringContext>();
}

MySQLParser::TextStringContext* MySQLParser::StringListContext::textString(size_t i) {
  return getRuleContext<MySQLParser::TextStringContext>(i);
}

tree::TerminalNode* MySQLParser::StringListContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::StringListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::StringListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::StringListContext::getRuleIndex() const {
  return MySQLParser::RuleStringList;
}

void MySQLParser::StringListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStringList(this);
}

void MySQLParser::StringListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStringList(this);
}


std::any MySQLParser::StringListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStringList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StringListContext* MySQLParser::stringList() {
  StringListContext *_localctx = _tracker.createInstance<StringListContext>(_ctx, getState());
  enterRule(_localctx, 1456, MySQLParser::RuleStringList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9420);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(9421);
    textString();
    setState(9426);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(9422);
      match(MySQLParser::COMMA_SYMBOL);
      setState(9423);
      textString();
      setState(9428);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(9429);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextStringLiteralContext ------------------------------------------------------------------

MySQLParser::TextStringLiteralContext::TextStringLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TextStringLiteralContext::SINGLE_QUOTED_TEXT() {
  return getToken(MySQLParser::SINGLE_QUOTED_TEXT, 0);
}

tree::TerminalNode* MySQLParser::TextStringLiteralContext::DOUBLE_QUOTED_TEXT() {
  return getToken(MySQLParser::DOUBLE_QUOTED_TEXT, 0);
}


size_t MySQLParser::TextStringLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleTextStringLiteral;
}

void MySQLParser::TextStringLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextStringLiteral(this);
}

void MySQLParser::TextStringLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextStringLiteral(this);
}


std::any MySQLParser::TextStringLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextStringLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextStringLiteralContext* MySQLParser::textStringLiteral() {
  TextStringLiteralContext *_localctx = _tracker.createInstance<TextStringLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1458, MySQLParser::RuleTextStringLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9434);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1187, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9431);
      antlrcpp::downCast<TextStringLiteralContext *>(_localctx)->value = match(MySQLParser::SINGLE_QUOTED_TEXT);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9432);

      if (!(!isSqlModeActive(AnsiQuotes))) throw FailedPredicateException(this, "!isSqlModeActive(AnsiQuotes)");
      setState(9433);
      antlrcpp::downCast<TextStringLiteralContext *>(_localctx)->value = match(MySQLParser::DOUBLE_QUOTED_TEXT);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextStringContext ------------------------------------------------------------------

MySQLParser::TextStringContext::TextStringContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringLiteralContext* MySQLParser::TextStringContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::TextStringContext::HEX_NUMBER() {
  return getToken(MySQLParser::HEX_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::TextStringContext::BIN_NUMBER() {
  return getToken(MySQLParser::BIN_NUMBER, 0);
}


size_t MySQLParser::TextStringContext::getRuleIndex() const {
  return MySQLParser::RuleTextString;
}

void MySQLParser::TextStringContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextString(this);
}

void MySQLParser::TextStringContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextString(this);
}


std::any MySQLParser::TextStringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextString(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextStringContext* MySQLParser::textString() {
  TextStringContext *_localctx = _tracker.createInstance<TextStringContext>(_ctx, getState());
  enterRule(_localctx, 1460, MySQLParser::RuleTextString);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9439);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1188, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9436);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9437);
      match(MySQLParser::HEX_NUMBER);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9438);
      match(MySQLParser::BIN_NUMBER);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextStringHashContext ------------------------------------------------------------------

MySQLParser::TextStringHashContext::TextStringHashContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringLiteralContext* MySQLParser::TextStringHashContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::TextStringHashContext::HEX_NUMBER() {
  return getToken(MySQLParser::HEX_NUMBER, 0);
}


size_t MySQLParser::TextStringHashContext::getRuleIndex() const {
  return MySQLParser::RuleTextStringHash;
}

void MySQLParser::TextStringHashContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextStringHash(this);
}

void MySQLParser::TextStringHashContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextStringHash(this);
}


std::any MySQLParser::TextStringHashContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextStringHash(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextStringHashContext* MySQLParser::textStringHash() {
  TextStringHashContext *_localctx = _tracker.createInstance<TextStringHashContext>(_ctx, getState());
  enterRule(_localctx, 1462, MySQLParser::RuleTextStringHash);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9444);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1189, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9441);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9442);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(9443);
      match(MySQLParser::HEX_NUMBER);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextLiteralContext ------------------------------------------------------------------

MySQLParser::TextLiteralContext::TextLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TextStringLiteralContext *> MySQLParser::TextLiteralContext::textStringLiteral() {
  return getRuleContexts<MySQLParser::TextStringLiteralContext>();
}

MySQLParser::TextStringLiteralContext* MySQLParser::TextLiteralContext::textStringLiteral(size_t i) {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(i);
}

tree::TerminalNode* MySQLParser::TextLiteralContext::NCHAR_TEXT() {
  return getToken(MySQLParser::NCHAR_TEXT, 0);
}

tree::TerminalNode* MySQLParser::TextLiteralContext::UNDERSCORE_CHARSET() {
  return getToken(MySQLParser::UNDERSCORE_CHARSET, 0);
}


size_t MySQLParser::TextLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleTextLiteral;
}

void MySQLParser::TextLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextLiteral(this);
}

void MySQLParser::TextLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextLiteral(this);
}


std::any MySQLParser::TextLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextLiteralContext* MySQLParser::textLiteral() {
  TextLiteralContext *_localctx = _tracker.createInstance<TextLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1464, MySQLParser::RuleTextLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9451);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1191, _ctx)) {
    case 1: {
      setState(9447);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1190, _ctx)) {
      case 1: {
        setState(9446);
        match(MySQLParser::UNDERSCORE_CHARSET);
        break;
      }

      default:
        break;
      }
      setState(9449);
      textStringLiteral();
      break;
    }

    case 2: {
      setState(9450);
      match(MySQLParser::NCHAR_TEXT);
      break;
    }

    default:
      break;
    }
    setState(9456);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1192, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9453);
        textStringLiteral(); 
      }
      setState(9458);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1192, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextStringNoLinebreakContext ------------------------------------------------------------------

MySQLParser::TextStringNoLinebreakContext::TextStringNoLinebreakContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringLiteralContext* MySQLParser::TextStringNoLinebreakContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::TextStringNoLinebreakContext::getRuleIndex() const {
  return MySQLParser::RuleTextStringNoLinebreak;
}

void MySQLParser::TextStringNoLinebreakContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextStringNoLinebreak(this);
}

void MySQLParser::TextStringNoLinebreakContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextStringNoLinebreak(this);
}


std::any MySQLParser::TextStringNoLinebreakContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextStringNoLinebreak(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextStringNoLinebreakContext* MySQLParser::textStringNoLinebreak() {
  TextStringNoLinebreakContext *_localctx = _tracker.createInstance<TextStringNoLinebreakContext>(_ctx, getState());
  enterRule(_localctx, 1466, MySQLParser::RuleTextStringNoLinebreak);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9459);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextStringLiteralListContext ------------------------------------------------------------------

MySQLParser::TextStringLiteralListContext::TextStringLiteralListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<MySQLParser::TextStringLiteralContext *> MySQLParser::TextStringLiteralListContext::textStringLiteral() {
  return getRuleContexts<MySQLParser::TextStringLiteralContext>();
}

MySQLParser::TextStringLiteralContext* MySQLParser::TextStringLiteralListContext::textStringLiteral(size_t i) {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(i);
}

std::vector<tree::TerminalNode *> MySQLParser::TextStringLiteralListContext::COMMA_SYMBOL() {
  return getTokens(MySQLParser::COMMA_SYMBOL);
}

tree::TerminalNode* MySQLParser::TextStringLiteralListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, i);
}


size_t MySQLParser::TextStringLiteralListContext::getRuleIndex() const {
  return MySQLParser::RuleTextStringLiteralList;
}

void MySQLParser::TextStringLiteralListContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextStringLiteralList(this);
}

void MySQLParser::TextStringLiteralListContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextStringLiteralList(this);
}


std::any MySQLParser::TextStringLiteralListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextStringLiteralList(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextStringLiteralListContext* MySQLParser::textStringLiteralList() {
  TextStringLiteralListContext *_localctx = _tracker.createInstance<TextStringLiteralListContext>(_ctx, getState());
  enterRule(_localctx, 1468, MySQLParser::RuleTextStringLiteralList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(9461);
    textStringLiteral();
    setState(9466);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1193, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(9462);
        match(MySQLParser::COMMA_SYMBOL);
        setState(9463);
        textStringLiteral(); 
      }
      setState(9468);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1193, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NumLiteralContext ------------------------------------------------------------------

MySQLParser::NumLiteralContext::NumLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::Int64LiteralContext* MySQLParser::NumLiteralContext::int64Literal() {
  return getRuleContext<MySQLParser::Int64LiteralContext>(0);
}

tree::TerminalNode* MySQLParser::NumLiteralContext::DECIMAL_NUMBER() {
  return getToken(MySQLParser::DECIMAL_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::NumLiteralContext::FLOAT_NUMBER() {
  return getToken(MySQLParser::FLOAT_NUMBER, 0);
}


size_t MySQLParser::NumLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleNumLiteral;
}

void MySQLParser::NumLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNumLiteral(this);
}

void MySQLParser::NumLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNumLiteral(this);
}


std::any MySQLParser::NumLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNumLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NumLiteralContext* MySQLParser::numLiteral() {
  NumLiteralContext *_localctx = _tracker.createInstance<NumLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1470, MySQLParser::RuleNumLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9472);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(9469);
        int64Literal();
        break;
      }

      case MySQLParser::DECIMAL_NUMBER: {
        enterOuterAlt(_localctx, 2);
        setState(9470);
        match(MySQLParser::DECIMAL_NUMBER);
        break;
      }

      case MySQLParser::FLOAT_NUMBER: {
        enterOuterAlt(_localctx, 3);
        setState(9471);
        match(MySQLParser::FLOAT_NUMBER);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BoolLiteralContext ------------------------------------------------------------------

MySQLParser::BoolLiteralContext::BoolLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::BoolLiteralContext::TRUE_SYMBOL() {
  return getToken(MySQLParser::TRUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::BoolLiteralContext::FALSE_SYMBOL() {
  return getToken(MySQLParser::FALSE_SYMBOL, 0);
}


size_t MySQLParser::BoolLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleBoolLiteral;
}

void MySQLParser::BoolLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterBoolLiteral(this);
}

void MySQLParser::BoolLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitBoolLiteral(this);
}


std::any MySQLParser::BoolLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitBoolLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::BoolLiteralContext* MySQLParser::boolLiteral() {
  BoolLiteralContext *_localctx = _tracker.createInstance<BoolLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1472, MySQLParser::RuleBoolLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9474);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::FALSE_SYMBOL || _la == MySQLParser::TRUE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NullLiteralContext ------------------------------------------------------------------

MySQLParser::NullLiteralContext::NullLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NullLiteralContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::NullLiteralContext::NULL2_SYMBOL() {
  return getToken(MySQLParser::NULL2_SYMBOL, 0);
}


size_t MySQLParser::NullLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleNullLiteral;
}

void MySQLParser::NullLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterNullLiteral(this);
}

void MySQLParser::NullLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitNullLiteral(this);
}


std::any MySQLParser::NullLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitNullLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::NullLiteralContext* MySQLParser::nullLiteral() {
  NullLiteralContext *_localctx = _tracker.createInstance<NullLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1474, MySQLParser::RuleNullLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9476);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NULL2_SYMBOL || _la == MySQLParser::NULL_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Int64LiteralContext ------------------------------------------------------------------

MySQLParser::Int64LiteralContext::Int64LiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::Int64LiteralContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Int64LiteralContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Int64LiteralContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}


size_t MySQLParser::Int64LiteralContext::getRuleIndex() const {
  return MySQLParser::RuleInt64Literal;
}

void MySQLParser::Int64LiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterInt64Literal(this);
}

void MySQLParser::Int64LiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitInt64Literal(this);
}


std::any MySQLParser::Int64LiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitInt64Literal(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::Int64LiteralContext* MySQLParser::int64Literal() {
  Int64LiteralContext *_localctx = _tracker.createInstance<Int64LiteralContext>(_ctx, getState());
  enterRule(_localctx, 1476, MySQLParser::RuleInt64Literal);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9478);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << MySQLParser::INT_NUMBER)
      | (1ULL << MySQLParser::LONG_NUMBER)
      | (1ULL << MySQLParser::ULONGLONG_NUMBER))) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TemporalLiteralContext ------------------------------------------------------------------

MySQLParser::TemporalLiteralContext::TemporalLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::TemporalLiteralContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TemporalLiteralContext::SINGLE_QUOTED_TEXT() {
  return getToken(MySQLParser::SINGLE_QUOTED_TEXT, 0);
}

tree::TerminalNode* MySQLParser::TemporalLiteralContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TemporalLiteralContext::TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_SYMBOL, 0);
}


size_t MySQLParser::TemporalLiteralContext::getRuleIndex() const {
  return MySQLParser::RuleTemporalLiteral;
}

void MySQLParser::TemporalLiteralContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTemporalLiteral(this);
}

void MySQLParser::TemporalLiteralContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTemporalLiteral(this);
}


std::any MySQLParser::TemporalLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTemporalLiteral(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TemporalLiteralContext* MySQLParser::temporalLiteral() {
  TemporalLiteralContext *_localctx = _tracker.createInstance<TemporalLiteralContext>(_ctx, getState());
  enterRule(_localctx, 1478, MySQLParser::RuleTemporalLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9486);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::DATE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(9480);
        match(MySQLParser::DATE_SYMBOL);
        setState(9481);
        match(MySQLParser::SINGLE_QUOTED_TEXT);
        break;
      }

      case MySQLParser::TIME_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(9482);
        match(MySQLParser::TIME_SYMBOL);
        setState(9483);
        match(MySQLParser::SINGLE_QUOTED_TEXT);
        break;
      }

      case MySQLParser::TIMESTAMP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(9484);
        match(MySQLParser::TIMESTAMP_SYMBOL);
        setState(9485);
        match(MySQLParser::SINGLE_QUOTED_TEXT);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FloatOptionsContext ------------------------------------------------------------------

MySQLParser::FloatOptionsContext::FloatOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::FieldLengthContext* MySQLParser::FloatOptionsContext::fieldLength() {
  return getRuleContext<MySQLParser::FieldLengthContext>(0);
}

MySQLParser::PrecisionContext* MySQLParser::FloatOptionsContext::precision() {
  return getRuleContext<MySQLParser::PrecisionContext>(0);
}


size_t MySQLParser::FloatOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleFloatOptions;
}

void MySQLParser::FloatOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterFloatOptions(this);
}

void MySQLParser::FloatOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitFloatOptions(this);
}


std::any MySQLParser::FloatOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitFloatOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::FloatOptionsContext* MySQLParser::floatOptions() {
  FloatOptionsContext *_localctx = _tracker.createInstance<FloatOptionsContext>(_ctx, getState());
  enterRule(_localctx, 1480, MySQLParser::RuleFloatOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9490);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1196, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9488);
      fieldLength();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9489);
      precision();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StandardFloatOptionsContext ------------------------------------------------------------------

MySQLParser::StandardFloatOptionsContext::StandardFloatOptionsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PrecisionContext* MySQLParser::StandardFloatOptionsContext::precision() {
  return getRuleContext<MySQLParser::PrecisionContext>(0);
}


size_t MySQLParser::StandardFloatOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleStandardFloatOptions;
}

void MySQLParser::StandardFloatOptionsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterStandardFloatOptions(this);
}

void MySQLParser::StandardFloatOptionsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitStandardFloatOptions(this);
}


std::any MySQLParser::StandardFloatOptionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitStandardFloatOptions(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::StandardFloatOptionsContext* MySQLParser::standardFloatOptions() {
  StandardFloatOptionsContext *_localctx = _tracker.createInstance<StandardFloatOptionsContext>(_ctx, getState());
  enterRule(_localctx, 1482, MySQLParser::RuleStandardFloatOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9492);
    precision();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrecisionContext ------------------------------------------------------------------

MySQLParser::PrecisionContext::PrecisionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::PrecisionContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

std::vector<tree::TerminalNode *> MySQLParser::PrecisionContext::INT_NUMBER() {
  return getTokens(MySQLParser::INT_NUMBER);
}

tree::TerminalNode* MySQLParser::PrecisionContext::INT_NUMBER(size_t i) {
  return getToken(MySQLParser::INT_NUMBER, i);
}

tree::TerminalNode* MySQLParser::PrecisionContext::COMMA_SYMBOL() {
  return getToken(MySQLParser::COMMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::PrecisionContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::PrecisionContext::getRuleIndex() const {
  return MySQLParser::RulePrecision;
}

void MySQLParser::PrecisionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrecision(this);
}

void MySQLParser::PrecisionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrecision(this);
}


std::any MySQLParser::PrecisionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitPrecision(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::PrecisionContext* MySQLParser::precision() {
  PrecisionContext *_localctx = _tracker.createInstance<PrecisionContext>(_ctx, getState());
  enterRule(_localctx, 1484, MySQLParser::RulePrecision);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9494);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(9495);
    match(MySQLParser::INT_NUMBER);
    setState(9496);
    match(MySQLParser::COMMA_SYMBOL);
    setState(9497);
    match(MySQLParser::INT_NUMBER);
    setState(9498);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TextOrIdentifierContext ------------------------------------------------------------------

MySQLParser::TextOrIdentifierContext::TextOrIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierContext* MySQLParser::TextOrIdentifierContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::TextOrIdentifierContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::TextOrIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleTextOrIdentifier;
}

void MySQLParser::TextOrIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterTextOrIdentifier(this);
}

void MySQLParser::TextOrIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitTextOrIdentifier(this);
}


std::any MySQLParser::TextOrIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitTextOrIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::textOrIdentifier() {
  TextOrIdentifierContext *_localctx = _tracker.createInstance<TextOrIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1486, MySQLParser::RuleTextOrIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9502);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1197, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9500);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9501);
      textStringLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LValueIdentifierContext ------------------------------------------------------------------

MySQLParser::LValueIdentifierContext::LValueIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::PureIdentifierContext* MySQLParser::LValueIdentifierContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}

MySQLParser::LValueKeywordContext* MySQLParser::LValueIdentifierContext::lValueKeyword() {
  return getRuleContext<MySQLParser::LValueKeywordContext>(0);
}


size_t MySQLParser::LValueIdentifierContext::getRuleIndex() const {
  return MySQLParser::RuleLValueIdentifier;
}

void MySQLParser::LValueIdentifierContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLValueIdentifier(this);
}

void MySQLParser::LValueIdentifierContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLValueIdentifier(this);
}


std::any MySQLParser::LValueIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLValueIdentifier(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LValueIdentifierContext* MySQLParser::lValueIdentifier() {
  LValueIdentifierContext *_localctx = _tracker.createInstance<LValueIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 1488, MySQLParser::RuleLValueIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9506);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1198, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9504);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9505);
      lValueKeyword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleIdentifierOrTextContext ------------------------------------------------------------------

MySQLParser::RoleIdentifierOrTextContext::RoleIdentifierOrTextContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoleIdentifierContext* MySQLParser::RoleIdentifierOrTextContext::roleIdentifier() {
  return getRuleContext<MySQLParser::RoleIdentifierContext>(0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::RoleIdentifierOrTextContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::RoleIdentifierOrTextContext::getRuleIndex() const {
  return MySQLParser::RuleRoleIdentifierOrText;
}

void MySQLParser::RoleIdentifierOrTextContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleIdentifierOrText(this);
}

void MySQLParser::RoleIdentifierOrTextContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleIdentifierOrText(this);
}


std::any MySQLParser::RoleIdentifierOrTextContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleIdentifierOrText(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleIdentifierOrTextContext* MySQLParser::roleIdentifierOrText() {
  RoleIdentifierOrTextContext *_localctx = _tracker.createInstance<RoleIdentifierOrTextContext>(_ctx, getState());
  enterRule(_localctx, 1490, MySQLParser::RuleRoleIdentifierOrText);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9510);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1199, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9508);
      roleIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9509);
      textStringLiteral();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SizeNumberContext ------------------------------------------------------------------

MySQLParser::SizeNumberContext::SizeNumberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::Real_ulonglong_numberContext* MySQLParser::SizeNumberContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}

MySQLParser::PureIdentifierContext* MySQLParser::SizeNumberContext::pureIdentifier() {
  return getRuleContext<MySQLParser::PureIdentifierContext>(0);
}


size_t MySQLParser::SizeNumberContext::getRuleIndex() const {
  return MySQLParser::RuleSizeNumber;
}

void MySQLParser::SizeNumberContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSizeNumber(this);
}

void MySQLParser::SizeNumberContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSizeNumber(this);
}


std::any MySQLParser::SizeNumberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSizeNumber(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SizeNumberContext* MySQLParser::sizeNumber() {
  SizeNumberContext *_localctx = _tracker.createInstance<SizeNumberContext>(_ctx, getState());
  enterRule(_localctx, 1492, MySQLParser::RuleSizeNumber);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9514);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1200, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9512);
      real_ulonglong_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9513);
      pureIdentifier();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ParenthesesContext ------------------------------------------------------------------

MySQLParser::ParenthesesContext::ParenthesesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::ParenthesesContext::OPEN_PAR_SYMBOL() {
  return getToken(MySQLParser::OPEN_PAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ParenthesesContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 0);
}


size_t MySQLParser::ParenthesesContext::getRuleIndex() const {
  return MySQLParser::RuleParentheses;
}

void MySQLParser::ParenthesesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterParentheses(this);
}

void MySQLParser::ParenthesesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitParentheses(this);
}


std::any MySQLParser::ParenthesesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitParentheses(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::ParenthesesContext* MySQLParser::parentheses() {
  ParenthesesContext *_localctx = _tracker.createInstance<ParenthesesContext>(_ctx, getState());
  enterRule(_localctx, 1494, MySQLParser::RuleParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9516);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(9517);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EqualContext ------------------------------------------------------------------

MySQLParser::EqualContext::EqualContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::EqualContext::EQUAL_OPERATOR() {
  return getToken(MySQLParser::EQUAL_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::EqualContext::ASSIGN_OPERATOR() {
  return getToken(MySQLParser::ASSIGN_OPERATOR, 0);
}


size_t MySQLParser::EqualContext::getRuleIndex() const {
  return MySQLParser::RuleEqual;
}

void MySQLParser::EqualContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEqual(this);
}

void MySQLParser::EqualContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEqual(this);
}


std::any MySQLParser::EqualContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitEqual(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::EqualContext* MySQLParser::equal() {
  EqualContext *_localctx = _tracker.createInstance<EqualContext>(_ctx, getState());
  enterRule(_localctx, 1496, MySQLParser::RuleEqual);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9519);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::EQUAL_OPERATOR

    || _la == MySQLParser::ASSIGN_OPERATOR)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OptionTypeContext ------------------------------------------------------------------

MySQLParser::OptionTypeContext::OptionTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::OptionTypeContext::PERSIST_SYMBOL() {
  return getToken(MySQLParser::PERSIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OptionTypeContext::PERSIST_ONLY_SYMBOL() {
  return getToken(MySQLParser::PERSIST_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OptionTypeContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OptionTypeContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::OptionTypeContext::SESSION_SYMBOL() {
  return getToken(MySQLParser::SESSION_SYMBOL, 0);
}


size_t MySQLParser::OptionTypeContext::getRuleIndex() const {
  return MySQLParser::RuleOptionType;
}

void MySQLParser::OptionTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterOptionType(this);
}

void MySQLParser::OptionTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitOptionType(this);
}


std::any MySQLParser::OptionTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitOptionType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::OptionTypeContext* MySQLParser::optionType() {
  OptionTypeContext *_localctx = _tracker.createInstance<OptionTypeContext>(_ctx, getState());
  enterRule(_localctx, 1498, MySQLParser::RuleOptionType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9528);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1201, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9521);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9522);
      match(MySQLParser::PERSIST_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9523);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9524);
      match(MySQLParser::PERSIST_ONLY_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9525);
      match(MySQLParser::GLOBAL_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9526);
      match(MySQLParser::LOCAL_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(9527);
      match(MySQLParser::SESSION_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RvalueSystemVariableTypeContext ------------------------------------------------------------------

MySQLParser::RvalueSystemVariableTypeContext::RvalueSystemVariableTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RvalueSystemVariableTypeContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RvalueSystemVariableTypeContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RvalueSystemVariableTypeContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RvalueSystemVariableTypeContext::SESSION_SYMBOL() {
  return getToken(MySQLParser::SESSION_SYMBOL, 0);
}


size_t MySQLParser::RvalueSystemVariableTypeContext::getRuleIndex() const {
  return MySQLParser::RuleRvalueSystemVariableType;
}

void MySQLParser::RvalueSystemVariableTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRvalueSystemVariableType(this);
}

void MySQLParser::RvalueSystemVariableTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRvalueSystemVariableType(this);
}


std::any MySQLParser::RvalueSystemVariableTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRvalueSystemVariableType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RvalueSystemVariableTypeContext* MySQLParser::rvalueSystemVariableType() {
  RvalueSystemVariableTypeContext *_localctx = _tracker.createInstance<RvalueSystemVariableTypeContext>(_ctx, getState());
  enterRule(_localctx, 1500, MySQLParser::RuleRvalueSystemVariableType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9536);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::GLOBAL_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(9530);
        match(MySQLParser::GLOBAL_SYMBOL);
        setState(9531);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::LOCAL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(9532);
        match(MySQLParser::LOCAL_SYMBOL);
        setState(9533);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::SESSION_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(9534);
        match(MySQLParser::SESSION_SYMBOL);
        setState(9535);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SetVarIdentTypeContext ------------------------------------------------------------------

MySQLParser::SetVarIdentTypeContext::SetVarIdentTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::PERSIST_SYMBOL() {
  return getToken(MySQLParser::PERSIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::PERSIST_ONLY_SYMBOL() {
  return getToken(MySQLParser::PERSIST_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::SESSION_SYMBOL() {
  return getToken(MySQLParser::SESSION_SYMBOL, 0);
}


size_t MySQLParser::SetVarIdentTypeContext::getRuleIndex() const {
  return MySQLParser::RuleSetVarIdentType;
}

void MySQLParser::SetVarIdentTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSetVarIdentType(this);
}

void MySQLParser::SetVarIdentTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSetVarIdentType(this);
}


std::any MySQLParser::SetVarIdentTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSetVarIdentType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::SetVarIdentTypeContext* MySQLParser::setVarIdentType() {
  SetVarIdentTypeContext *_localctx = _tracker.createInstance<SetVarIdentTypeContext>(_ctx, getState());
  enterRule(_localctx, 1502, MySQLParser::RuleSetVarIdentType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9545);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1203, _ctx)) {
    case 1: {
      setState(9538);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9539);
      match(MySQLParser::PERSIST_SYMBOL);
      break;
    }

    case 2: {
      setState(9540);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9541);
      match(MySQLParser::PERSIST_ONLY_SYMBOL);
      break;
    }

    case 3: {
      setState(9542);
      match(MySQLParser::GLOBAL_SYMBOL);
      break;
    }

    case 4: {
      setState(9543);
      match(MySQLParser::LOCAL_SYMBOL);
      break;
    }

    case 5: {
      setState(9544);
      match(MySQLParser::SESSION_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(9547);
    match(MySQLParser::DOT_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JsonAttributeContext ------------------------------------------------------------------

MySQLParser::JsonAttributeContext::JsonAttributeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::TextStringLiteralContext* MySQLParser::JsonAttributeContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::JsonAttributeContext::getRuleIndex() const {
  return MySQLParser::RuleJsonAttribute;
}

void MySQLParser::JsonAttributeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterJsonAttribute(this);
}

void MySQLParser::JsonAttributeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitJsonAttribute(this);
}


std::any MySQLParser::JsonAttributeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitJsonAttribute(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::JsonAttributeContext* MySQLParser::jsonAttribute() {
  JsonAttributeContext *_localctx = _tracker.createInstance<JsonAttributeContext>(_ctx, getState());
  enterRule(_localctx, 1504, MySQLParser::RuleJsonAttribute);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9549);
    textStringLiteral();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierKeywordContext ------------------------------------------------------------------

MySQLParser::IdentifierKeywordContext::IdentifierKeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::LabelKeywordContext* MySQLParser::IdentifierKeywordContext::labelKeyword() {
  return getRuleContext<MySQLParser::LabelKeywordContext>(0);
}

MySQLParser::RoleOrIdentifierKeywordContext* MySQLParser::IdentifierKeywordContext::roleOrIdentifierKeyword() {
  return getRuleContext<MySQLParser::RoleOrIdentifierKeywordContext>(0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordContext::EXECUTE_SYMBOL() {
  return getToken(MySQLParser::EXECUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordContext::SHUTDOWN_SYMBOL() {
  return getToken(MySQLParser::SHUTDOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordContext::RESTART_SYMBOL() {
  return getToken(MySQLParser::RESTART_SYMBOL, 0);
}

MySQLParser::IdentifierKeywordsUnambiguousContext* MySQLParser::IdentifierKeywordContext::identifierKeywordsUnambiguous() {
  return getRuleContext<MySQLParser::IdentifierKeywordsUnambiguousContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext* MySQLParser::IdentifierKeywordContext::identifierKeywordsAmbiguous1RolesAndLabels() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext* MySQLParser::IdentifierKeywordContext::identifierKeywordsAmbiguous2Labels() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous3RolesContext* MySQLParser::IdentifierKeywordContext::identifierKeywordsAmbiguous3Roles() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous3RolesContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext* MySQLParser::IdentifierKeywordContext::identifierKeywordsAmbiguous4SystemVariables() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext>(0);
}


size_t MySQLParser::IdentifierKeywordContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierKeyword;
}

void MySQLParser::IdentifierKeywordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierKeyword(this);
}

void MySQLParser::IdentifierKeywordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierKeyword(this);
}


std::any MySQLParser::IdentifierKeywordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierKeyword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierKeywordContext* MySQLParser::identifierKeyword() {
  IdentifierKeywordContext *_localctx = _tracker.createInstance<IdentifierKeywordContext>(_ctx, getState());
  enterRule(_localctx, 1506, MySQLParser::RuleIdentifierKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9568);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1206, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9551);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(9559);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1204, _ctx)) {
      case 1: {
        setState(9552);
        labelKeyword();
        break;
      }

      case 2: {
        setState(9553);
        roleOrIdentifierKeyword();
        break;
      }

      case 3: {
        setState(9554);
        match(MySQLParser::EXECUTE_SYMBOL);
        break;
      }

      case 4: {
        setState(9555);

        if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
        setState(9556);
        match(MySQLParser::SHUTDOWN_SYMBOL);
        break;
      }

      case 5: {
        setState(9557);

        if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
        setState(9558);
        match(MySQLParser::RESTART_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9566);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1205, _ctx)) {
      case 1: {
        setState(9561);
        identifierKeywordsUnambiguous();
        break;
      }

      case 2: {
        setState(9562);
        identifierKeywordsAmbiguous1RolesAndLabels();
        break;
      }

      case 3: {
        setState(9563);
        identifierKeywordsAmbiguous2Labels();
        break;
      }

      case 4: {
        setState(9564);
        identifierKeywordsAmbiguous3Roles();
        break;
      }

      case 5: {
        setState(9565);
        identifierKeywordsAmbiguous4SystemVariables();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierKeywordsAmbiguous1RolesAndLabelsContext ------------------------------------------------------------------

MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::IdentifierKeywordsAmbiguous1RolesAndLabelsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::EXECUTE_SYMBOL() {
  return getToken(MySQLParser::EXECUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::RESTART_SYMBOL() {
  return getToken(MySQLParser::RESTART_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::SHUTDOWN_SYMBOL() {
  return getToken(MySQLParser::SHUTDOWN_SYMBOL, 0);
}


size_t MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierKeywordsAmbiguous1RolesAndLabels;
}

void MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierKeywordsAmbiguous1RolesAndLabels(this);
}

void MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierKeywordsAmbiguous1RolesAndLabels(this);
}


std::any MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierKeywordsAmbiguous1RolesAndLabels(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext* MySQLParser::identifierKeywordsAmbiguous1RolesAndLabels() {
  IdentifierKeywordsAmbiguous1RolesAndLabelsContext *_localctx = _tracker.createInstance<IdentifierKeywordsAmbiguous1RolesAndLabelsContext>(_ctx, getState());
  enterRule(_localctx, 1508, MySQLParser::RuleIdentifierKeywordsAmbiguous1RolesAndLabels);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9570);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::EXECUTE_SYMBOL || _la == MySQLParser::SHUTDOWN_SYMBOL || _la == MySQLParser::RESTART_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierKeywordsAmbiguous2LabelsContext ------------------------------------------------------------------

MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::IdentifierKeywordsAmbiguous2LabelsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::ASCII_SYMBOL() {
  return getToken(MySQLParser::ASCII_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::BEGIN_SYMBOL() {
  return getToken(MySQLParser::BEGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::BYTE_SYMBOL() {
  return getToken(MySQLParser::BYTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::CACHE_SYMBOL() {
  return getToken(MySQLParser::CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::CHARSET_SYMBOL() {
  return getToken(MySQLParser::CHARSET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::CLONE_SYMBOL() {
  return getToken(MySQLParser::CLONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::COMMIT_SYMBOL() {
  return getToken(MySQLParser::COMMIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::CONTAINS_SYMBOL() {
  return getToken(MySQLParser::CONTAINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::DEALLOCATE_SYMBOL() {
  return getToken(MySQLParser::DEALLOCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::DO_SYMBOL() {
  return getToken(MySQLParser::DO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::FLUSH_SYMBOL() {
  return getToken(MySQLParser::FLUSH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::FOLLOWS_SYMBOL() {
  return getToken(MySQLParser::FOLLOWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::HANDLER_SYMBOL() {
  return getToken(MySQLParser::HANDLER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::HELP_SYMBOL() {
  return getToken(MySQLParser::HELP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::IMPORT_SYMBOL() {
  return getToken(MySQLParser::IMPORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::INSTALL_SYMBOL() {
  return getToken(MySQLParser::INSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::LANGUAGE_SYMBOL() {
  return getToken(MySQLParser::LANGUAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::PRECEDES_SYMBOL() {
  return getToken(MySQLParser::PRECEDES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::PREPARE_SYMBOL() {
  return getToken(MySQLParser::PREPARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::REPAIR_SYMBOL() {
  return getToken(MySQLParser::REPAIR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::RESET_SYMBOL() {
  return getToken(MySQLParser::RESET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::ROLLBACK_SYMBOL() {
  return getToken(MySQLParser::ROLLBACK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::SAVEPOINT_SYMBOL() {
  return getToken(MySQLParser::SAVEPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::SIGNED_SYMBOL() {
  return getToken(MySQLParser::SIGNED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::STOP_SYMBOL() {
  return getToken(MySQLParser::STOP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::TRUNCATE_SYMBOL() {
  return getToken(MySQLParser::TRUNCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::UNICODE_SYMBOL() {
  return getToken(MySQLParser::UNICODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::UNINSTALL_SYMBOL() {
  return getToken(MySQLParser::UNINSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::XA_SYMBOL() {
  return getToken(MySQLParser::XA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::BINLOG_SYMBOL() {
  return getToken(MySQLParser::BINLOG_SYMBOL, 0);
}


size_t MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierKeywordsAmbiguous2Labels;
}

void MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierKeywordsAmbiguous2Labels(this);
}

void MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierKeywordsAmbiguous2Labels(this);
}


std::any MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierKeywordsAmbiguous2Labels(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext* MySQLParser::identifierKeywordsAmbiguous2Labels() {
  IdentifierKeywordsAmbiguous2LabelsContext *_localctx = _tracker.createInstance<IdentifierKeywordsAmbiguous2LabelsContext>(_ctx, getState());
  enterRule(_localctx, 1510, MySQLParser::RuleIdentifierKeywordsAmbiguous2Labels);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9609);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1207, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9572);
      match(MySQLParser::ASCII_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9573);
      match(MySQLParser::BEGIN_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9574);
      match(MySQLParser::BYTE_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9575);
      match(MySQLParser::CACHE_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(9576);
      match(MySQLParser::CHARSET_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(9577);
      match(MySQLParser::CHECKSUM_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(9578);
      match(MySQLParser::CLONE_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(9579);
      match(MySQLParser::COMMENT_SYMBOL);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(9580);
      match(MySQLParser::COMMIT_SYMBOL);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(9581);
      match(MySQLParser::CONTAINS_SYMBOL);
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(9582);
      match(MySQLParser::DEALLOCATE_SYMBOL);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(9583);
      match(MySQLParser::DO_SYMBOL);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(9584);
      match(MySQLParser::END_SYMBOL);
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(9585);
      match(MySQLParser::FLUSH_SYMBOL);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(9586);
      match(MySQLParser::FOLLOWS_SYMBOL);
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(9587);
      match(MySQLParser::HANDLER_SYMBOL);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(9588);
      match(MySQLParser::HELP_SYMBOL);
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(9589);
      match(MySQLParser::IMPORT_SYMBOL);
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(9590);
      match(MySQLParser::INSTALL_SYMBOL);
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(9591);
      match(MySQLParser::LANGUAGE_SYMBOL);
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(9592);
      match(MySQLParser::NO_SYMBOL);
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(9593);
      match(MySQLParser::PRECEDES_SYMBOL);
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(9594);
      match(MySQLParser::PREPARE_SYMBOL);
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(9595);
      match(MySQLParser::REPAIR_SYMBOL);
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(9596);
      match(MySQLParser::RESET_SYMBOL);
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(9597);
      match(MySQLParser::ROLLBACK_SYMBOL);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(9598);
      match(MySQLParser::SAVEPOINT_SYMBOL);
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(9599);
      match(MySQLParser::SIGNED_SYMBOL);
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(9600);
      match(MySQLParser::SLAVE_SYMBOL);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(9601);
      match(MySQLParser::START_SYMBOL);
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(9602);
      match(MySQLParser::STOP_SYMBOL);
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(9603);
      match(MySQLParser::TRUNCATE_SYMBOL);
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(9604);
      match(MySQLParser::UNICODE_SYMBOL);
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(9605);
      match(MySQLParser::UNINSTALL_SYMBOL);
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(9606);
      match(MySQLParser::XA_SYMBOL);
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(9607);

      if (!(serverVersion >= 90200)) throw FailedPredicateException(this, "serverVersion >= 90200");
      setState(9608);
      match(MySQLParser::BINLOG_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LabelKeywordContext ------------------------------------------------------------------

MySQLParser::LabelKeywordContext::LabelKeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoleOrLabelKeywordContext* MySQLParser::LabelKeywordContext::roleOrLabelKeyword() {
  return getRuleContext<MySQLParser::RoleOrLabelKeywordContext>(0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::FILE_SYMBOL() {
  return getToken(MySQLParser::FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::PROCESS_SYMBOL() {
  return getToken(MySQLParser::PROCESS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::RELOAD_SYMBOL() {
  return getToken(MySQLParser::RELOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::RESOURCE_SYMBOL() {
  return getToken(MySQLParser::RESOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LabelKeywordContext::SUPER_SYMBOL() {
  return getToken(MySQLParser::SUPER_SYMBOL, 0);
}

MySQLParser::IdentifierKeywordsUnambiguousContext* MySQLParser::LabelKeywordContext::identifierKeywordsUnambiguous() {
  return getRuleContext<MySQLParser::IdentifierKeywordsUnambiguousContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous3RolesContext* MySQLParser::LabelKeywordContext::identifierKeywordsAmbiguous3Roles() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous3RolesContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext* MySQLParser::LabelKeywordContext::identifierKeywordsAmbiguous4SystemVariables() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext>(0);
}


size_t MySQLParser::LabelKeywordContext::getRuleIndex() const {
  return MySQLParser::RuleLabelKeyword;
}

void MySQLParser::LabelKeywordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLabelKeyword(this);
}

void MySQLParser::LabelKeywordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLabelKeyword(this);
}


std::any MySQLParser::LabelKeywordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLabelKeyword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LabelKeywordContext* MySQLParser::labelKeyword() {
  LabelKeywordContext *_localctx = _tracker.createInstance<LabelKeywordContext>(_ctx, getState());
  enterRule(_localctx, 1512, MySQLParser::RuleLabelKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9629);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1210, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9611);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(9622);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1208, _ctx)) {
      case 1: {
        setState(9612);
        roleOrLabelKeyword();
        break;
      }

      case 2: {
        setState(9613);
        match(MySQLParser::EVENT_SYMBOL);
        break;
      }

      case 3: {
        setState(9614);
        match(MySQLParser::FILE_SYMBOL);
        break;
      }

      case 4: {
        setState(9615);
        match(MySQLParser::NONE_SYMBOL);
        break;
      }

      case 5: {
        setState(9616);
        match(MySQLParser::PROCESS_SYMBOL);
        break;
      }

      case 6: {
        setState(9617);
        match(MySQLParser::PROXY_SYMBOL);
        break;
      }

      case 7: {
        setState(9618);
        match(MySQLParser::RELOAD_SYMBOL);
        break;
      }

      case 8: {
        setState(9619);
        match(MySQLParser::REPLICATION_SYMBOL);
        break;
      }

      case 9: {
        setState(9620);
        match(MySQLParser::RESOURCE_SYMBOL);
        break;
      }

      case 10: {
        setState(9621);
        match(MySQLParser::SUPER_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9627);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1209, _ctx)) {
      case 1: {
        setState(9624);
        identifierKeywordsUnambiguous();
        break;
      }

      case 2: {
        setState(9625);
        identifierKeywordsAmbiguous3Roles();
        break;
      }

      case 3: {
        setState(9626);
        identifierKeywordsAmbiguous4SystemVariables();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierKeywordsAmbiguous3RolesContext ------------------------------------------------------------------

MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::IdentifierKeywordsAmbiguous3RolesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::EVENT_SYMBOL() {
  return getToken(MySQLParser::EVENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::FILE_SYMBOL() {
  return getToken(MySQLParser::FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::PROCESS_SYMBOL() {
  return getToken(MySQLParser::PROCESS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::RELOAD_SYMBOL() {
  return getToken(MySQLParser::RELOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::RESOURCE_SYMBOL() {
  return getToken(MySQLParser::RESOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::SUPER_SYMBOL() {
  return getToken(MySQLParser::SUPER_SYMBOL, 0);
}


size_t MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierKeywordsAmbiguous3Roles;
}

void MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierKeywordsAmbiguous3Roles(this);
}

void MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierKeywordsAmbiguous3Roles(this);
}


std::any MySQLParser::IdentifierKeywordsAmbiguous3RolesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierKeywordsAmbiguous3Roles(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierKeywordsAmbiguous3RolesContext* MySQLParser::identifierKeywordsAmbiguous3Roles() {
  IdentifierKeywordsAmbiguous3RolesContext *_localctx = _tracker.createInstance<IdentifierKeywordsAmbiguous3RolesContext>(_ctx, getState());
  enterRule(_localctx, 1514, MySQLParser::RuleIdentifierKeywordsAmbiguous3Roles);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9631);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::EVENT_SYMBOL

    || _la == MySQLParser::FILE_SYMBOL || ((((_la - 399) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 399)) & ((1ULL << (MySQLParser::NONE_SYMBOL - 399))
      | (1ULL << (MySQLParser::PROCESS_SYMBOL - 399))
      | (1ULL << (MySQLParser::PROXY_SYMBOL - 399)))) != 0) || _la == MySQLParser::RELOAD_SYMBOL

    || _la == MySQLParser::REPLICATION_SYMBOL || _la == MySQLParser::SUPER_SYMBOL || _la == MySQLParser::RESOURCE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierKeywordsUnambiguousContext ------------------------------------------------------------------

MySQLParser::IdentifierKeywordsUnambiguousContext::IdentifierKeywordsUnambiguousContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ACTION_SYMBOL() {
  return getToken(MySQLParser::ACTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ACCOUNT_SYMBOL() {
  return getToken(MySQLParser::ACCOUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ACTIVE_SYMBOL() {
  return getToken(MySQLParser::ACTIVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ADDDATE_SYMBOL() {
  return getToken(MySQLParser::ADDDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ADMIN_SYMBOL() {
  return getToken(MySQLParser::ADMIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AFTER_SYMBOL() {
  return getToken(MySQLParser::AFTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AGAINST_SYMBOL() {
  return getToken(MySQLParser::AGAINST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AGGREGATE_SYMBOL() {
  return getToken(MySQLParser::AGGREGATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ALWAYS_SYMBOL() {
  return getToken(MySQLParser::ALWAYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ANY_SYMBOL() {
  return getToken(MySQLParser::ANY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AT_SYMBOL() {
  return getToken(MySQLParser::AT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::ATTRIBUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AUTHENTICATION_SYMBOL() {
  return getToken(MySQLParser::AUTHENTICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AUTOEXTEND_SIZE_SYMBOL() {
  return getToken(MySQLParser::AUTOEXTEND_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AUTO_INCREMENT_SYMBOL() {
  return getToken(MySQLParser::AUTO_INCREMENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AVG_ROW_LENGTH_SYMBOL() {
  return getToken(MySQLParser::AVG_ROW_LENGTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AVG_SYMBOL() {
  return getToken(MySQLParser::AVG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BACKUP_SYMBOL() {
  return getToken(MySQLParser::BACKUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BINLOG_SYMBOL() {
  return getToken(MySQLParser::BINLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BIT_SYMBOL() {
  return getToken(MySQLParser::BIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BLOCK_SYMBOL() {
  return getToken(MySQLParser::BLOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BOOLEAN_SYMBOL() {
  return getToken(MySQLParser::BOOLEAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BOOL_SYMBOL() {
  return getToken(MySQLParser::BOOL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BTREE_SYMBOL() {
  return getToken(MySQLParser::BTREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BUCKETS_SYMBOL() {
  return getToken(MySQLParser::BUCKETS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CASCADED_SYMBOL() {
  return getToken(MySQLParser::CASCADED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CATALOG_NAME_SYMBOL() {
  return getToken(MySQLParser::CATALOG_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CHAIN_SYMBOL() {
  return getToken(MySQLParser::CHAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CHALLENGE_RESPONSE_SYMBOL() {
  return getToken(MySQLParser::CHALLENGE_RESPONSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CHANGED_SYMBOL() {
  return getToken(MySQLParser::CHANGED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CHANNEL_SYMBOL() {
  return getToken(MySQLParser::CHANNEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CIPHER_SYMBOL() {
  return getToken(MySQLParser::CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CLASS_ORIGIN_SYMBOL() {
  return getToken(MySQLParser::CLASS_ORIGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CLIENT_SYMBOL() {
  return getToken(MySQLParser::CLIENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CLOSE_SYMBOL() {
  return getToken(MySQLParser::CLOSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COALESCE_SYMBOL() {
  return getToken(MySQLParser::COALESCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CODE_SYMBOL() {
  return getToken(MySQLParser::CODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COLLATION_SYMBOL() {
  return getToken(MySQLParser::COLLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COLUMN_FORMAT_SYMBOL() {
  return getToken(MySQLParser::COLUMN_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COLUMN_NAME_SYMBOL() {
  return getToken(MySQLParser::COLUMN_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COMMITTED_SYMBOL() {
  return getToken(MySQLParser::COMMITTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COMPACT_SYMBOL() {
  return getToken(MySQLParser::COMPACT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COMPLETION_SYMBOL() {
  return getToken(MySQLParser::COMPLETION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COMPONENT_SYMBOL() {
  return getToken(MySQLParser::COMPONENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COMPRESSED_SYMBOL() {
  return getToken(MySQLParser::COMPRESSED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::COMPRESSION_SYMBOL() {
  return getToken(MySQLParser::COMPRESSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONCURRENT_SYMBOL() {
  return getToken(MySQLParser::CONCURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONNECTION_SYMBOL() {
  return getToken(MySQLParser::CONNECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONSISTENT_SYMBOL() {
  return getToken(MySQLParser::CONSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONSTRAINT_CATALOG_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_CATALOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONSTRAINT_NAME_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONSTRAINT_SCHEMA_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_SCHEMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CONTEXT_SYMBOL() {
  return getToken(MySQLParser::CONTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CPU_SYMBOL() {
  return getToken(MySQLParser::CPU_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::CURSOR_NAME_SYMBOL() {
  return getToken(MySQLParser::CURSOR_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DATAFILE_SYMBOL() {
  return getToken(MySQLParser::DATAFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DATETIME_SYMBOL() {
  return getToken(MySQLParser::DATETIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DAY_SYMBOL() {
  return getToken(MySQLParser::DAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DEFAULT_AUTH_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_AUTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DEFINER_SYMBOL() {
  return getToken(MySQLParser::DEFINER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DEFINITION_SYMBOL() {
  return getToken(MySQLParser::DEFINITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DELAY_KEY_WRITE_SYMBOL() {
  return getToken(MySQLParser::DELAY_KEY_WRITE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DESCRIPTION_SYMBOL() {
  return getToken(MySQLParser::DESCRIPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DIAGNOSTICS_SYMBOL() {
  return getToken(MySQLParser::DIAGNOSTICS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DISCARD_SYMBOL() {
  return getToken(MySQLParser::DISCARD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DISK_SYMBOL() {
  return getToken(MySQLParser::DISK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DUMPFILE_SYMBOL() {
  return getToken(MySQLParser::DUMPFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DUPLICATE_SYMBOL() {
  return getToken(MySQLParser::DUPLICATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::DYNAMIC_SYMBOL() {
  return getToken(MySQLParser::DYNAMIC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENCRYPTION_SYMBOL() {
  return getToken(MySQLParser::ENCRYPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENDS_SYMBOL() {
  return getToken(MySQLParser::ENDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENFORCED_SYMBOL() {
  return getToken(MySQLParser::ENFORCED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENGINES_SYMBOL() {
  return getToken(MySQLParser::ENGINES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ENUM_SYMBOL() {
  return getToken(MySQLParser::ENUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ERRORS_SYMBOL() {
  return getToken(MySQLParser::ERRORS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ESCAPE_SYMBOL() {
  return getToken(MySQLParser::ESCAPE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EVENTS_SYMBOL() {
  return getToken(MySQLParser::EVENTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EVERY_SYMBOL() {
  return getToken(MySQLParser::EVERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXCHANGE_SYMBOL() {
  return getToken(MySQLParser::EXCHANGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXCLUDE_SYMBOL() {
  return getToken(MySQLParser::EXCLUDE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXPANSION_SYMBOL() {
  return getToken(MySQLParser::EXPANSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXPIRE_SYMBOL() {
  return getToken(MySQLParser::EXPIRE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXPORT_SYMBOL() {
  return getToken(MySQLParser::EXPORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::EXTENT_SIZE_SYMBOL() {
  return getToken(MySQLParser::EXTENT_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FACTOR_SYMBOL() {
  return getToken(MySQLParser::FACTOR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FAST_SYMBOL() {
  return getToken(MySQLParser::FAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FAULTS_SYMBOL() {
  return getToken(MySQLParser::FAULTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FILE_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::FILE_BLOCK_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FILTER_SYMBOL() {
  return getToken(MySQLParser::FILTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FINISH_SYMBOL() {
  return getToken(MySQLParser::FINISH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FIRST_SYMBOL() {
  return getToken(MySQLParser::FIRST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FIXED_SYMBOL() {
  return getToken(MySQLParser::FIXED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FOLLOWING_SYMBOL() {
  return getToken(MySQLParser::FOLLOWING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FOUND_SYMBOL() {
  return getToken(MySQLParser::FOUND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GENERAL_SYMBOL() {
  return getToken(MySQLParser::GENERAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GEOMETRYCOLLECTION_SYMBOL() {
  return getToken(MySQLParser::GEOMETRYCOLLECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GEOMETRY_SYMBOL() {
  return getToken(MySQLParser::GEOMETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GET_FORMAT_SYMBOL() {
  return getToken(MySQLParser::GET_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GET_MASTER_PUBLIC_KEY_SYMBOL() {
  return getToken(MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GET_SOURCE_PUBLIC_KEY_SYMBOL() {
  return getToken(MySQLParser::GET_SOURCE_PUBLIC_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GRANTS_SYMBOL() {
  return getToken(MySQLParser::GRANTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GROUP_REPLICATION_SYMBOL() {
  return getToken(MySQLParser::GROUP_REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GTID_ONLY_SYMBOL() {
  return getToken(MySQLParser::GTID_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::HASH_SYMBOL() {
  return getToken(MySQLParser::HASH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::HISTOGRAM_SYMBOL() {
  return getToken(MySQLParser::HISTOGRAM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::HISTORY_SYMBOL() {
  return getToken(MySQLParser::HISTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::HOSTS_SYMBOL() {
  return getToken(MySQLParser::HOSTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::HOST_SYMBOL() {
  return getToken(MySQLParser::HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::HOUR_SYMBOL() {
  return getToken(MySQLParser::HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::IGNORE_SERVER_IDS_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SERVER_IDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INACTIVE_SYMBOL() {
  return getToken(MySQLParser::INACTIVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INDEXES_SYMBOL() {
  return getToken(MySQLParser::INDEXES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INITIAL_SIZE_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INITIAL_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INITIATE_SYMBOL() {
  return getToken(MySQLParser::INITIATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INSERT_METHOD_SYMBOL() {
  return getToken(MySQLParser::INSERT_METHOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INSTANCE_SYMBOL() {
  return getToken(MySQLParser::INSTANCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INVISIBLE_SYMBOL() {
  return getToken(MySQLParser::INVISIBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::INVOKER_SYMBOL() {
  return getToken(MySQLParser::INVOKER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::IO_SYMBOL() {
  return getToken(MySQLParser::IO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::IPC_SYMBOL() {
  return getToken(MySQLParser::IPC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ISOLATION_SYMBOL() {
  return getToken(MySQLParser::ISOLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ISSUER_SYMBOL() {
  return getToken(MySQLParser::ISSUER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::JSON_SYMBOL() {
  return getToken(MySQLParser::JSON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::JSON_VALUE_SYMBOL() {
  return getToken(MySQLParser::JSON_VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::KEY_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::KEY_BLOCK_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::KEYRING_SYMBOL() {
  return getToken(MySQLParser::KEYRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LAST_SYMBOL() {
  return getToken(MySQLParser::LAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LEAVES_SYMBOL() {
  return getToken(MySQLParser::LEAVES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LESS_SYMBOL() {
  return getToken(MySQLParser::LESS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LEVEL_SYMBOL() {
  return getToken(MySQLParser::LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LINESTRING_SYMBOL() {
  return getToken(MySQLParser::LINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LIST_SYMBOL() {
  return getToken(MySQLParser::LIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LOCKED_SYMBOL() {
  return getToken(MySQLParser::LOCKED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LOCKS_SYMBOL() {
  return getToken(MySQLParser::LOCKS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LOGFILE_SYMBOL() {
  return getToken(MySQLParser::LOGFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_AUTO_POSITION_SYMBOL() {
  return getToken(MySQLParser::MASTER_AUTO_POSITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_COMPRESSION_ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_CONNECT_RETRY_SYMBOL() {
  return getToken(MySQLParser::MASTER_CONNECT_RETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_DELAY_SYMBOL() {
  return getToken(MySQLParser::MASTER_DELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_HEARTBEAT_PERIOD_SYMBOL() {
  return getToken(MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_HOST_SYMBOL() {
  return getToken(MySQLParser::MASTER_HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NETWORK_NAMESPACE_SYMBOL() {
  return getToken(MySQLParser::NETWORK_NAMESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_POS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::MASTER_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_PORT_SYMBOL() {
  return getToken(MySQLParser::MASTER_PORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_PUBLIC_KEY_PATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_RETRY_COUNT_SYMBOL() {
  return getToken(MySQLParser::MASTER_RETRY_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SERVER_ID_SYMBOL() {
  return getToken(MySQLParser::MASTER_SERVER_ID_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_CAPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CAPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_CA_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_CERT_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_CIPHER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_CRLPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRLPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_CRL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_KEY_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SSL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_TLS_CIPHERSUITES_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_TLS_VERSION_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_VERSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_USER_SYMBOL() {
  return getToken(MySQLParser::MASTER_USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL() {
  return getToken(MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MAX_CONNECTIONS_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MAX_QUERIES_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MAX_ROWS_SYMBOL() {
  return getToken(MySQLParser::MAX_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MAX_SIZE_SYMBOL() {
  return getToken(MySQLParser::MAX_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MAX_UPDATES_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MAX_USER_CONNECTIONS_SYMBOL() {
  return getToken(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MEDIUM_SYMBOL() {
  return getToken(MySQLParser::MEDIUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MERGE_SYMBOL() {
  return getToken(MySQLParser::MERGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MESSAGE_TEXT_SYMBOL() {
  return getToken(MySQLParser::MESSAGE_TEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MIGRATE_SYMBOL() {
  return getToken(MySQLParser::MIGRATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MINUTE_SYMBOL() {
  return getToken(MySQLParser::MINUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MIN_ROWS_SYMBOL() {
  return getToken(MySQLParser::MIN_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MODE_SYMBOL() {
  return getToken(MySQLParser::MODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MODIFY_SYMBOL() {
  return getToken(MySQLParser::MODIFY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MONTH_SYMBOL() {
  return getToken(MySQLParser::MONTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MULTILINESTRING_SYMBOL() {
  return getToken(MySQLParser::MULTILINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MULTIPOINT_SYMBOL() {
  return getToken(MySQLParser::MULTIPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MULTIPOLYGON_SYMBOL() {
  return getToken(MySQLParser::MULTIPOLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MUTEX_SYMBOL() {
  return getToken(MySQLParser::MUTEX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MYSQL_ERRNO_SYMBOL() {
  return getToken(MySQLParser::MYSQL_ERRNO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NAMES_SYMBOL() {
  return getToken(MySQLParser::NAMES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NAME_SYMBOL() {
  return getToken(MySQLParser::NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NATIONAL_SYMBOL() {
  return getToken(MySQLParser::NATIONAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NCHAR_SYMBOL() {
  return getToken(MySQLParser::NCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NDBCLUSTER_SYMBOL() {
  return getToken(MySQLParser::NDBCLUSTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NESTED_SYMBOL() {
  return getToken(MySQLParser::NESTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NEVER_SYMBOL() {
  return getToken(MySQLParser::NEVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NEW_SYMBOL() {
  return getToken(MySQLParser::NEW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NEXT_SYMBOL() {
  return getToken(MySQLParser::NEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NODEGROUP_SYMBOL() {
  return getToken(MySQLParser::NODEGROUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NOWAIT_SYMBOL() {
  return getToken(MySQLParser::NOWAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NO_WAIT_SYMBOL() {
  return getToken(MySQLParser::NO_WAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NULLS_SYMBOL() {
  return getToken(MySQLParser::NULLS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NUMBER_SYMBOL() {
  return getToken(MySQLParser::NUMBER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::NVARCHAR_SYMBOL() {
  return getToken(MySQLParser::NVARCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OFFSET_SYMBOL() {
  return getToken(MySQLParser::OFFSET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OJ_SYMBOL() {
  return getToken(MySQLParser::OJ_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OLD_SYMBOL() {
  return getToken(MySQLParser::OLD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ONE_SYMBOL() {
  return getToken(MySQLParser::ONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ONLY_SYMBOL() {
  return getToken(MySQLParser::ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OPEN_SYMBOL() {
  return getToken(MySQLParser::OPEN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OPTIONAL_SYMBOL() {
  return getToken(MySQLParser::OPTIONAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OPTIONS_SYMBOL() {
  return getToken(MySQLParser::OPTIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ORDINALITY_SYMBOL() {
  return getToken(MySQLParser::ORDINALITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ORGANIZATION_SYMBOL() {
  return getToken(MySQLParser::ORGANIZATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OTHERS_SYMBOL() {
  return getToken(MySQLParser::OTHERS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OWNER_SYMBOL() {
  return getToken(MySQLParser::OWNER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PACK_KEYS_SYMBOL() {
  return getToken(MySQLParser::PACK_KEYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PAGE_SYMBOL() {
  return getToken(MySQLParser::PAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PARSER_SYMBOL() {
  return getToken(MySQLParser::PARSER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PARTIAL_SYMBOL() {
  return getToken(MySQLParser::PARTIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PARTITIONING_SYMBOL() {
  return getToken(MySQLParser::PARTITIONING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PARTITIONS_SYMBOL() {
  return getToken(MySQLParser::PARTITIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PATH_SYMBOL() {
  return getToken(MySQLParser::PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PHASE_SYMBOL() {
  return getToken(MySQLParser::PHASE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PLUGINS_SYMBOL() {
  return getToken(MySQLParser::PLUGINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PLUGIN_DIR_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_DIR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PLUGIN_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::POINT_SYMBOL() {
  return getToken(MySQLParser::POINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::POLYGON_SYMBOL() {
  return getToken(MySQLParser::POLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PORT_SYMBOL() {
  return getToken(MySQLParser::PORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PRECEDING_SYMBOL() {
  return getToken(MySQLParser::PRECEDING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PRESERVE_SYMBOL() {
  return getToken(MySQLParser::PRESERVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PREV_SYMBOL() {
  return getToken(MySQLParser::PREV_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PRIVILEGE_CHECKS_USER_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PROCESSLIST_SYMBOL() {
  return getToken(MySQLParser::PROCESSLIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PROFILES_SYMBOL() {
  return getToken(MySQLParser::PROFILES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PROFILE_SYMBOL() {
  return getToken(MySQLParser::PROFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::QUARTER_SYMBOL() {
  return getToken(MySQLParser::QUARTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::QUICK_SYMBOL() {
  return getToken(MySQLParser::QUICK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::READ_ONLY_SYMBOL() {
  return getToken(MySQLParser::READ_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REBUILD_SYMBOL() {
  return getToken(MySQLParser::REBUILD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RECOVER_SYMBOL() {
  return getToken(MySQLParser::RECOVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REDO_BUFFER_SIZE_SYMBOL() {
  return getToken(MySQLParser::REDO_BUFFER_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REDUNDANT_SYMBOL() {
  return getToken(MySQLParser::REDUNDANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REFERENCE_SYMBOL() {
  return getToken(MySQLParser::REFERENCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REGISTRATION_SYMBOL() {
  return getToken(MySQLParser::REGISTRATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RELAY_SYMBOL() {
  return getToken(MySQLParser::RELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RELAYLOG_SYMBOL() {
  return getToken(MySQLParser::RELAYLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RELAY_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RELAY_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_POS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RELAY_THREAD_SYMBOL() {
  return getToken(MySQLParser::RELAY_THREAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REMOVE_SYMBOL() {
  return getToken(MySQLParser::REMOVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL() {
  return getToken(MySQLParser::ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REORGANIZE_SYMBOL() {
  return getToken(MySQLParser::REORGANIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPEATABLE_SYMBOL() {
  return getToken(MySQLParser::REPEATABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICAS_SYMBOL() {
  return getToken(MySQLParser::REPLICAS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_DO_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_DO_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_DO_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_DO_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_IGNORE_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_IGNORE_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_IGNORE_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_REWRITE_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_REWRITE_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_WILD_DO_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICATE_WILD_IGNORE_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPLICA_SYMBOL() {
  return getToken(MySQLParser::REPLICA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::USER_RESOURCES_SYMBOL() {
  return getToken(MySQLParser::USER_RESOURCES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RESPECT_SYMBOL() {
  return getToken(MySQLParser::RESPECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RESTORE_SYMBOL() {
  return getToken(MySQLParser::RESTORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RESUME_SYMBOL() {
  return getToken(MySQLParser::RESUME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RETAIN_SYMBOL() {
  return getToken(MySQLParser::RETAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RETURNED_SQLSTATE_SYMBOL() {
  return getToken(MySQLParser::RETURNED_SQLSTATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RETURNING_SYMBOL() {
  return getToken(MySQLParser::RETURNING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RETURNS_SYMBOL() {
  return getToken(MySQLParser::RETURNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REUSE_SYMBOL() {
  return getToken(MySQLParser::REUSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REVERSE_SYMBOL() {
  return getToken(MySQLParser::REVERSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ROLLUP_SYMBOL() {
  return getToken(MySQLParser::ROLLUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ROTATE_SYMBOL() {
  return getToken(MySQLParser::ROTATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ROUTINE_SYMBOL() {
  return getToken(MySQLParser::ROUTINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ROW_COUNT_SYMBOL() {
  return getToken(MySQLParser::ROW_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ROW_FORMAT_SYMBOL() {
  return getToken(MySQLParser::ROW_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RTREE_SYMBOL() {
  return getToken(MySQLParser::RTREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SCHEDULE_SYMBOL() {
  return getToken(MySQLParser::SCHEDULE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SCHEMA_NAME_SYMBOL() {
  return getToken(MySQLParser::SCHEMA_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECONDARY_ENGINE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECONDARY_LOAD_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_LOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECONDARY_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECONDARY_UNLOAD_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_UNLOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECOND_SYMBOL() {
  return getToken(MySQLParser::SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SECURITY_SYMBOL() {
  return getToken(MySQLParser::SECURITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SERIALIZABLE_SYMBOL() {
  return getToken(MySQLParser::SERIALIZABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SERIAL_SYMBOL() {
  return getToken(MySQLParser::SERIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SERVER_SYMBOL() {
  return getToken(MySQLParser::SERVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SHARE_SYMBOL() {
  return getToken(MySQLParser::SHARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SIMPLE_SYMBOL() {
  return getToken(MySQLParser::SIMPLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SKIP_SYMBOL() {
  return getToken(MySQLParser::SKIP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SLOW_SYMBOL() {
  return getToken(MySQLParser::SLOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SNAPSHOT_SYMBOL() {
  return getToken(MySQLParser::SNAPSHOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOCKET_SYMBOL() {
  return getToken(MySQLParser::SOCKET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SONAME_SYMBOL() {
  return getToken(MySQLParser::SONAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOUNDS_SYMBOL() {
  return getToken(MySQLParser::SOUNDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_AUTO_POSITION_SYMBOL() {
  return getToken(MySQLParser::SOURCE_AUTO_POSITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_BIND_SYMBOL() {
  return getToken(MySQLParser::SOURCE_BIND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_COMPRESSION_ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::SOURCE_COMPRESSION_ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL() {
  return getToken(MySQLParser::SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_CONNECT_RETRY_SYMBOL() {
  return getToken(MySQLParser::SOURCE_CONNECT_RETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_DELAY_SYMBOL() {
  return getToken(MySQLParser::SOURCE_DELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_HEARTBEAT_PERIOD_SYMBOL() {
  return getToken(MySQLParser::SOURCE_HEARTBEAT_PERIOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_HOST_SYMBOL() {
  return getToken(MySQLParser::SOURCE_HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::SOURCE_LOG_POS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::SOURCE_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_PORT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_PORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_PUBLIC_KEY_PATH_SYMBOL() {
  return getToken(MySQLParser::SOURCE_PUBLIC_KEY_PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_RETRY_COUNT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_RETRY_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_CAPATH_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CAPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_CA_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_CERT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_CIPHER_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_CRLPATH_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CRLPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_CRL_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_CRL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_KEY_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_TLS_CIPHERSUITES_SYMBOL() {
  return getToken(MySQLParser::SOURCE_TLS_CIPHERSUITES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_TLS_VERSION_SYMBOL() {
  return getToken(MySQLParser::SOURCE_TLS_VERSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_USER_SYMBOL() {
  return getToken(MySQLParser::SOURCE_USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL() {
  return getToken(MySQLParser::SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SQL_AFTER_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SQL_AFTER_MTS_GAPS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SQL_BEFORE_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_BEFORE_GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SQL_BUFFER_RESULT_SYMBOL() {
  return getToken(MySQLParser::SQL_BUFFER_RESULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SQL_NO_CACHE_SYMBOL() {
  return getToken(MySQLParser::SQL_NO_CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SQL_THREAD_SYMBOL() {
  return getToken(MySQLParser::SQL_THREAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SRID_SYMBOL() {
  return getToken(MySQLParser::SRID_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STACKED_SYMBOL() {
  return getToken(MySQLParser::STACKED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STARTS_SYMBOL() {
  return getToken(MySQLParser::STARTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STATS_AUTO_RECALC_SYMBOL() {
  return getToken(MySQLParser::STATS_AUTO_RECALC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STATS_PERSISTENT_SYMBOL() {
  return getToken(MySQLParser::STATS_PERSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STATS_SAMPLE_PAGES_SYMBOL() {
  return getToken(MySQLParser::STATS_SAMPLE_PAGES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STRING_SYMBOL() {
  return getToken(MySQLParser::STRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ST_COLLECT_SYMBOL() {
  return getToken(MySQLParser::ST_COLLECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SUBCLASS_ORIGIN_SYMBOL() {
  return getToken(MySQLParser::SUBCLASS_ORIGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SUBDATE_SYMBOL() {
  return getToken(MySQLParser::SUBDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SUBJECT_SYMBOL() {
  return getToken(MySQLParser::SUBJECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SUBPARTITIONS_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SUBPARTITION_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SUSPEND_SYMBOL() {
  return getToken(MySQLParser::SUSPEND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SWAPS_SYMBOL() {
  return getToken(MySQLParser::SWAPS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::SWITCHES_SYMBOL() {
  return getToken(MySQLParser::SWITCHES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TABLE_CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::TABLE_CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TABLE_NAME_SYMBOL() {
  return getToken(MySQLParser::TABLE_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TEMPORARY_SYMBOL() {
  return getToken(MySQLParser::TEMPORARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TEMPTABLE_SYMBOL() {
  return getToken(MySQLParser::TEMPTABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TEXT_SYMBOL() {
  return getToken(MySQLParser::TEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::THAN_SYMBOL() {
  return getToken(MySQLParser::THAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::THREAD_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::THREAD_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TIES_SYMBOL() {
  return getToken(MySQLParser::TIES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TIMESTAMPADD_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMPADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TIMESTAMPDIFF_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMPDIFF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TLS_SYMBOL() {
  return getToken(MySQLParser::TLS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TRANSACTION_SYMBOL() {
  return getToken(MySQLParser::TRANSACTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TRIGGERS_SYMBOL() {
  return getToken(MySQLParser::TRIGGERS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TYPES_SYMBOL() {
  return getToken(MySQLParser::TYPES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TYPE_SYMBOL() {
  return getToken(MySQLParser::TYPE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNBOUNDED_SYMBOL() {
  return getToken(MySQLParser::UNBOUNDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNCOMMITTED_SYMBOL() {
  return getToken(MySQLParser::UNCOMMITTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNDEFINED_SYMBOL() {
  return getToken(MySQLParser::UNDEFINED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNDOFILE_SYMBOL() {
  return getToken(MySQLParser::UNDOFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNDO_BUFFER_SIZE_SYMBOL() {
  return getToken(MySQLParser::UNDO_BUFFER_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNKNOWN_SYMBOL() {
  return getToken(MySQLParser::UNKNOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNREGISTER_SYMBOL() {
  return getToken(MySQLParser::UNREGISTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UNTIL_SYMBOL() {
  return getToken(MySQLParser::UNTIL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::UPGRADE_SYMBOL() {
  return getToken(MySQLParser::UPGRADE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::USE_FRM_SYMBOL() {
  return getToken(MySQLParser::USE_FRM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VALIDATION_SYMBOL() {
  return getToken(MySQLParser::VALIDATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VALUE_SYMBOL() {
  return getToken(MySQLParser::VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VARIABLES_SYMBOL() {
  return getToken(MySQLParser::VARIABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VCPU_SYMBOL() {
  return getToken(MySQLParser::VCPU_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VISIBLE_SYMBOL() {
  return getToken(MySQLParser::VISIBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WAIT_SYMBOL() {
  return getToken(MySQLParser::WAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WARNINGS_SYMBOL() {
  return getToken(MySQLParser::WARNINGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WEEK_SYMBOL() {
  return getToken(MySQLParser::WEEK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WEIGHT_STRING_SYMBOL() {
  return getToken(MySQLParser::WEIGHT_STRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WITHOUT_SYMBOL() {
  return getToken(MySQLParser::WITHOUT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WORK_SYMBOL() {
  return getToken(MySQLParser::WORK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::WRAPPER_SYMBOL() {
  return getToken(MySQLParser::WRAPPER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::X509_SYMBOL() {
  return getToken(MySQLParser::X509_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::XID_SYMBOL() {
  return getToken(MySQLParser::XID_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::XML_SYMBOL() {
  return getToken(MySQLParser::XML_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::YEAR_SYMBOL() {
  return getToken(MySQLParser::YEAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ZONE_SYMBOL() {
  return getToken(MySQLParser::ZONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::ARRAY_SYMBOL() {
  return getToken(MySQLParser::ARRAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::FAILED_LOGIN_ATTEMPTS_SYMBOL() {
  return getToken(MySQLParser::FAILED_LOGIN_ATTEMPTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::MEMBER_SYMBOL() {
  return getToken(MySQLParser::MEMBER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::OFF_SYMBOL() {
  return getToken(MySQLParser::OFF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PASSWORD_LOCK_TIME_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_LOCK_TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REQUIRE_ROW_FORMAT_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::STREAM_SYMBOL() {
  return getToken(MySQLParser::STREAM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BULK_SYMBOL() {
  return getToken(MySQLParser::BULK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GENERATE_SYMBOL() {
  return getToken(MySQLParser::GENERATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::PARSE_TREE_SYMBOL() {
  return getToken(MySQLParser::PARSE_TREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::GTIDS_SYMBOL() {
  return getToken(MySQLParser::GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::LOG_SYMBOL() {
  return getToken(MySQLParser::LOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::S3_SYMBOL() {
  return getToken(MySQLParser::S3_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::BERNOULLI_SYMBOL() {
  return getToken(MySQLParser::BERNOULLI_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::AUTO_SYMBOL() {
  return getToken(MySQLParser::AUTO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::VECTOR_SYMBOL() {
  return getToken(MySQLParser::VECTOR_SYMBOL, 0);
}


size_t MySQLParser::IdentifierKeywordsUnambiguousContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierKeywordsUnambiguous;
}

void MySQLParser::IdentifierKeywordsUnambiguousContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierKeywordsUnambiguous(this);
}

void MySQLParser::IdentifierKeywordsUnambiguousContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierKeywordsUnambiguous(this);
}


std::any MySQLParser::IdentifierKeywordsUnambiguousContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierKeywordsUnambiguous(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierKeywordsUnambiguousContext* MySQLParser::identifierKeywordsUnambiguous() {
  IdentifierKeywordsUnambiguousContext *_localctx = _tracker.createInstance<IdentifierKeywordsUnambiguousContext>(_ctx, getState());
  enterRule(_localctx, 1516, MySQLParser::RuleIdentifierKeywordsUnambiguous);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9646);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1211, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9633);
      _la = _input->LA(1);
      if (!(((((_la - 48) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 48)) & ((1ULL << (MySQLParser::ACCOUNT_SYMBOL - 48))
        | (1ULL << (MySQLParser::ACTION_SYMBOL - 48))
        | (1ULL << (MySQLParser::ADDDATE_SYMBOL - 48))
        | (1ULL << (MySQLParser::AFTER_SYMBOL - 48))
        | (1ULL << (MySQLParser::AGAINST_SYMBOL - 48))
        | (1ULL << (MySQLParser::AGGREGATE_SYMBOL - 48))
        | (1ULL << (MySQLParser::ALGORITHM_SYMBOL - 48))
        | (1ULL << (MySQLParser::ALWAYS_SYMBOL - 48))
        | (1ULL << (MySQLParser::ANY_SYMBOL - 48))
        | (1ULL << (MySQLParser::AT_SYMBOL - 48))
        | (1ULL << (MySQLParser::AUTOEXTEND_SIZE_SYMBOL - 48))
        | (1ULL << (MySQLParser::AUTO_INCREMENT_SYMBOL - 48))
        | (1ULL << (MySQLParser::AVG_ROW_LENGTH_SYMBOL - 48))
        | (1ULL << (MySQLParser::AVG_SYMBOL - 48))
        | (1ULL << (MySQLParser::BACKUP_SYMBOL - 48))
        | (1ULL << (MySQLParser::BINLOG_SYMBOL - 48))
        | (1ULL << (MySQLParser::BIT_SYMBOL - 48))
        | (1ULL << (MySQLParser::BLOCK_SYMBOL - 48))
        | (1ULL << (MySQLParser::BOOLEAN_SYMBOL - 48))
        | (1ULL << (MySQLParser::BOOL_SYMBOL - 48))
        | (1ULL << (MySQLParser::BTREE_SYMBOL - 48))
        | (1ULL << (MySQLParser::CASCADED_SYMBOL - 48))
        | (1ULL << (MySQLParser::CATALOG_NAME_SYMBOL - 48))
        | (1ULL << (MySQLParser::CHAIN_SYMBOL - 48))
        | (1ULL << (MySQLParser::CHANGED_SYMBOL - 48))
        | (1ULL << (MySQLParser::CHANNEL_SYMBOL - 48))
        | (1ULL << (MySQLParser::CIPHER_SYMBOL - 48))
        | (1ULL << (MySQLParser::CLASS_ORIGIN_SYMBOL - 48))
        | (1ULL << (MySQLParser::CLIENT_SYMBOL - 48))
        | (1ULL << (MySQLParser::CLOSE_SYMBOL - 48))
        | (1ULL << (MySQLParser::COALESCE_SYMBOL - 48)))) != 0) || ((((_la - 112) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 112)) & ((1ULL << (MySQLParser::CODE_SYMBOL - 112))
        | (1ULL << (MySQLParser::COLLATION_SYMBOL - 112))
        | (1ULL << (MySQLParser::COLUMNS_SYMBOL - 112))
        | (1ULL << (MySQLParser::COLUMN_NAME_SYMBOL - 112))
        | (1ULL << (MySQLParser::COLUMN_FORMAT_SYMBOL - 112))
        | (1ULL << (MySQLParser::COMMITTED_SYMBOL - 112))
        | (1ULL << (MySQLParser::COMPACT_SYMBOL - 112))
        | (1ULL << (MySQLParser::COMPLETION_SYMBOL - 112))
        | (1ULL << (MySQLParser::COMPRESSED_SYMBOL - 112))
        | (1ULL << (MySQLParser::COMPRESSION_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONCURRENT_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONNECTION_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONSISTENT_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONSTRAINT_CATALOG_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONSTRAINT_NAME_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONSTRAINT_SCHEMA_SYMBOL - 112))
        | (1ULL << (MySQLParser::CONTEXT_SYMBOL - 112))
        | (1ULL << (MySQLParser::CPU_SYMBOL - 112))
        | (1ULL << (MySQLParser::CURRENT_SYMBOL - 112))
        | (1ULL << (MySQLParser::CURSOR_NAME_SYMBOL - 112))
        | (1ULL << (MySQLParser::DATAFILE_SYMBOL - 112))
        | (1ULL << (MySQLParser::DATA_SYMBOL - 112))
        | (1ULL << (MySQLParser::DATETIME_SYMBOL - 112))
        | (1ULL << (MySQLParser::DATE_SYMBOL - 112))
        | (1ULL << (MySQLParser::DAY_SYMBOL - 112))
        | (1ULL << (MySQLParser::DEFAULT_AUTH_SYMBOL - 112))
        | (1ULL << (MySQLParser::DEFINER_SYMBOL - 112))
        | (1ULL << (MySQLParser::DELAY_KEY_WRITE_SYMBOL - 112)))) != 0) || ((((_la - 178) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 178)) & ((1ULL << (MySQLParser::DIAGNOSTICS_SYMBOL - 178))
        | (1ULL << (MySQLParser::DIRECTORY_SYMBOL - 178))
        | (1ULL << (MySQLParser::DISABLE_SYMBOL - 178))
        | (1ULL << (MySQLParser::DISCARD_SYMBOL - 178))
        | (1ULL << (MySQLParser::DISK_SYMBOL - 178))
        | (1ULL << (MySQLParser::DUMPFILE_SYMBOL - 178))
        | (1ULL << (MySQLParser::DUPLICATE_SYMBOL - 178))
        | (1ULL << (MySQLParser::DYNAMIC_SYMBOL - 178))
        | (1ULL << (MySQLParser::ENABLE_SYMBOL - 178))
        | (1ULL << (MySQLParser::ENCRYPTION_SYMBOL - 178))
        | (1ULL << (MySQLParser::ENDS_SYMBOL - 178))
        | (1ULL << (MySQLParser::ENGINES_SYMBOL - 178))
        | (1ULL << (MySQLParser::ENGINE_SYMBOL - 178))
        | (1ULL << (MySQLParser::ENUM_SYMBOL - 178))
        | (1ULL << (MySQLParser::ERROR_SYMBOL - 178))
        | (1ULL << (MySQLParser::ERRORS_SYMBOL - 178))
        | (1ULL << (MySQLParser::ESCAPE_SYMBOL - 178))
        | (1ULL << (MySQLParser::EVENTS_SYMBOL - 178))
        | (1ULL << (MySQLParser::EVERY_SYMBOL - 178))
        | (1ULL << (MySQLParser::EXCHANGE_SYMBOL - 178))
        | (1ULL << (MySQLParser::EXPANSION_SYMBOL - 178))
        | (1ULL << (MySQLParser::EXPIRE_SYMBOL - 178))
        | (1ULL << (MySQLParser::EXPORT_SYMBOL - 178))
        | (1ULL << (MySQLParser::EXTENDED_SYMBOL - 178))
        | (1ULL << (MySQLParser::EXTENT_SIZE_SYMBOL - 178))
        | (1ULL << (MySQLParser::FAST_SYMBOL - 178))
        | (1ULL << (MySQLParser::FAULTS_SYMBOL - 178))
        | (1ULL << (MySQLParser::FILE_BLOCK_SIZE_SYMBOL - 178))
        | (1ULL << (MySQLParser::FILTER_SYMBOL - 178))
        | (1ULL << (MySQLParser::FIRST_SYMBOL - 178))
        | (1ULL << (MySQLParser::FIXED_SYMBOL - 178))
        | (1ULL << (MySQLParser::FORMAT_SYMBOL - 178))
        | (1ULL << (MySQLParser::FOUND_SYMBOL - 178))
        | (1ULL << (MySQLParser::FULL_SYMBOL - 178)))) != 0) || ((((_la - 244) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 244)) & ((1ULL << (MySQLParser::GENERAL_SYMBOL - 244))
        | (1ULL << (MySQLParser::GROUP_REPLICATION_SYMBOL - 244))
        | (1ULL << (MySQLParser::GEOMETRYCOLLECTION_SYMBOL - 244))
        | (1ULL << (MySQLParser::GEOMETRY_SYMBOL - 244))
        | (1ULL << (MySQLParser::GET_FORMAT_SYMBOL - 244))
        | (1ULL << (MySQLParser::GRANTS_SYMBOL - 244))
        | (1ULL << (MySQLParser::HASH_SYMBOL - 244))
        | (1ULL << (MySQLParser::HOST_SYMBOL - 244))
        | (1ULL << (MySQLParser::HOSTS_SYMBOL - 244))
        | (1ULL << (MySQLParser::HOUR_SYMBOL - 244))
        | (1ULL << (MySQLParser::IDENTIFIED_SYMBOL - 244))
        | (1ULL << (MySQLParser::IGNORE_SERVER_IDS_SYMBOL - 244))
        | (1ULL << (MySQLParser::INDEXES_SYMBOL - 244))
        | (1ULL << (MySQLParser::INITIAL_SIZE_SYMBOL - 244))
        | (1ULL << (MySQLParser::INSERT_METHOD_SYMBOL - 244))
        | (1ULL << (MySQLParser::INSTANCE_SYMBOL - 244))
        | (1ULL << (MySQLParser::INVOKER_SYMBOL - 244))
        | (1ULL << (MySQLParser::IO_SYMBOL - 244))
        | (1ULL << (MySQLParser::IPC_SYMBOL - 244))
        | (1ULL << (MySQLParser::ISOLATION_SYMBOL - 244))
        | (1ULL << (MySQLParser::ISSUER_SYMBOL - 244))
        | (1ULL << (MySQLParser::JSON_SYMBOL - 244))
        | (1ULL << (MySQLParser::KEY_BLOCK_SIZE_SYMBOL - 244))
        | (1ULL << (MySQLParser::LAST_SYMBOL - 244))
        | (1ULL << (MySQLParser::LEAVES_SYMBOL - 244))
        | (1ULL << (MySQLParser::LESS_SYMBOL - 244)))) != 0) || ((((_la - 308) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 308)) & ((1ULL << (MySQLParser::LEVEL_SYMBOL - 308))
        | (1ULL << (MySQLParser::LINESTRING_SYMBOL - 308))
        | (1ULL << (MySQLParser::LIST_SYMBOL - 308))
        | (1ULL << (MySQLParser::LOCKS_SYMBOL - 308))
        | (1ULL << (MySQLParser::LOGFILE_SYMBOL - 308))
        | (1ULL << (MySQLParser::LOGS_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_AUTO_POSITION_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_CONNECT_RETRY_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_DELAY_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_HOST_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_LOG_FILE_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_LOG_POS_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_PASSWORD_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_PORT_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_RETRY_COUNT_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SERVER_ID_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_CAPATH_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_CA_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_CERT_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_CIPHER_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_CRL_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_CRLPATH_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_KEY_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SSL_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_TLS_VERSION_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_USER_SYMBOL - 308))
        | (1ULL << (MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL - 308))
        | (1ULL << (MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL - 308))
        | (1ULL << (MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL - 308))
        | (1ULL << (MySQLParser::MAX_ROWS_SYMBOL - 308))
        | (1ULL << (MySQLParser::MAX_SIZE_SYMBOL - 308))
        | (1ULL << (MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL - 308))
        | (1ULL << (MySQLParser::MAX_USER_CONNECTIONS_SYMBOL - 308))
        | (1ULL << (MySQLParser::MEDIUM_SYMBOL - 308))
        | (1ULL << (MySQLParser::MEMORY_SYMBOL - 308))
        | (1ULL << (MySQLParser::MERGE_SYMBOL - 308))
        | (1ULL << (MySQLParser::MESSAGE_TEXT_SYMBOL - 308))
        | (1ULL << (MySQLParser::MICROSECOND_SYMBOL - 308))
        | (1ULL << (MySQLParser::MIGRATE_SYMBOL - 308)))) != 0) || ((((_la - 374) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 374)) & ((1ULL << (MySQLParser::MINUTE_SYMBOL - 374))
        | (1ULL << (MySQLParser::MIN_ROWS_SYMBOL - 374))
        | (1ULL << (MySQLParser::MODE_SYMBOL - 374))
        | (1ULL << (MySQLParser::MODIFY_SYMBOL - 374))
        | (1ULL << (MySQLParser::MONTH_SYMBOL - 374))
        | (1ULL << (MySQLParser::MULTILINESTRING_SYMBOL - 374))
        | (1ULL << (MySQLParser::MULTIPOINT_SYMBOL - 374))
        | (1ULL << (MySQLParser::MULTIPOLYGON_SYMBOL - 374))
        | (1ULL << (MySQLParser::MUTEX_SYMBOL - 374))
        | (1ULL << (MySQLParser::MYSQL_ERRNO_SYMBOL - 374))
        | (1ULL << (MySQLParser::NAMES_SYMBOL - 374))
        | (1ULL << (MySQLParser::NAME_SYMBOL - 374))
        | (1ULL << (MySQLParser::NATIONAL_SYMBOL - 374))
        | (1ULL << (MySQLParser::NCHAR_SYMBOL - 374))
        | (1ULL << (MySQLParser::NDBCLUSTER_SYMBOL - 374))
        | (1ULL << (MySQLParser::NEVER_SYMBOL - 374))
        | (1ULL << (MySQLParser::NEW_SYMBOL - 374))
        | (1ULL << (MySQLParser::NEXT_SYMBOL - 374))
        | (1ULL << (MySQLParser::NODEGROUP_SYMBOL - 374))
        | (1ULL << (MySQLParser::NO_WAIT_SYMBOL - 374))
        | (1ULL << (MySQLParser::NUMBER_SYMBOL - 374))
        | (1ULL << (MySQLParser::NVARCHAR_SYMBOL - 374))
        | (1ULL << (MySQLParser::OFFSET_SYMBOL - 374))
        | (1ULL << (MySQLParser::ONE_SYMBOL - 374))
        | (1ULL << (MySQLParser::ONLY_SYMBOL - 374))
        | (1ULL << (MySQLParser::OPEN_SYMBOL - 374))
        | (1ULL << (MySQLParser::OPTIONS_SYMBOL - 374))
        | (1ULL << (MySQLParser::OWNER_SYMBOL - 374))
        | (1ULL << (MySQLParser::PACK_KEYS_SYMBOL - 374))
        | (1ULL << (MySQLParser::PAGE_SYMBOL - 374))
        | (1ULL << (MySQLParser::PARSER_SYMBOL - 374))
        | (1ULL << (MySQLParser::PARTIAL_SYMBOL - 374))
        | (1ULL << (MySQLParser::PARTITIONING_SYMBOL - 374))
        | (1ULL << (MySQLParser::PARTITIONS_SYMBOL - 374))
        | (1ULL << (MySQLParser::PASSWORD_SYMBOL - 374))
        | (1ULL << (MySQLParser::PHASE_SYMBOL - 374)))) != 0) || ((((_la - 438) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 438)) & ((1ULL << (MySQLParser::PLUGINS_SYMBOL - 438))
        | (1ULL << (MySQLParser::PLUGIN_DIR_SYMBOL - 438))
        | (1ULL << (MySQLParser::PLUGIN_SYMBOL - 438))
        | (1ULL << (MySQLParser::POINT_SYMBOL - 438))
        | (1ULL << (MySQLParser::POLYGON_SYMBOL - 438))
        | (1ULL << (MySQLParser::PORT_SYMBOL - 438))
        | (1ULL << (MySQLParser::PRESERVE_SYMBOL - 438))
        | (1ULL << (MySQLParser::PREV_SYMBOL - 438))
        | (1ULL << (MySQLParser::PRIVILEGES_SYMBOL - 438))
        | (1ULL << (MySQLParser::PROCESSLIST_SYMBOL - 438))
        | (1ULL << (MySQLParser::PROFILE_SYMBOL - 438))
        | (1ULL << (MySQLParser::PROFILES_SYMBOL - 438))
        | (1ULL << (MySQLParser::QUARTER_SYMBOL - 438))
        | (1ULL << (MySQLParser::QUERY_SYMBOL - 438))
        | (1ULL << (MySQLParser::QUICK_SYMBOL - 438))
        | (1ULL << (MySQLParser::READ_ONLY_SYMBOL - 438))
        | (1ULL << (MySQLParser::REBUILD_SYMBOL - 438))
        | (1ULL << (MySQLParser::RECOVER_SYMBOL - 438))
        | (1ULL << (MySQLParser::REDO_BUFFER_SIZE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REDUNDANT_SYMBOL - 438))
        | (1ULL << (MySQLParser::RELAY_SYMBOL - 438))
        | (1ULL << (MySQLParser::RELAYLOG_SYMBOL - 438))
        | (1ULL << (MySQLParser::RELAY_LOG_FILE_SYMBOL - 438))
        | (1ULL << (MySQLParser::RELAY_LOG_POS_SYMBOL - 438))
        | (1ULL << (MySQLParser::RELAY_THREAD_SYMBOL - 438))
        | (1ULL << (MySQLParser::REMOVE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REORGANIZE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPEATABLE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_DO_DB_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_IGNORE_DB_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_DO_TABLE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL - 438))
        | (1ULL << (MySQLParser::REPLICATE_REWRITE_DB_SYMBOL - 438))
        | (1ULL << (MySQLParser::RESTORE_SYMBOL - 438)))) != 0) || ((((_la - 502) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 502)) & ((1ULL << (MySQLParser::RESUME_SYMBOL - 502))
        | (1ULL << (MySQLParser::RETURNED_SQLSTATE_SYMBOL - 502))
        | (1ULL << (MySQLParser::RETURNS_SYMBOL - 502))
        | (1ULL << (MySQLParser::REVERSE_SYMBOL - 502))
        | (1ULL << (MySQLParser::ROLLUP_SYMBOL - 502))
        | (1ULL << (MySQLParser::ROTATE_SYMBOL - 502))
        | (1ULL << (MySQLParser::ROUTINE_SYMBOL - 502))
        | (1ULL << (MySQLParser::ROW_COUNT_SYMBOL - 502))
        | (1ULL << (MySQLParser::ROW_FORMAT_SYMBOL - 502))
        | (1ULL << (MySQLParser::RTREE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SCHEDULE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SCHEMA_NAME_SYMBOL - 502))
        | (1ULL << (MySQLParser::SECOND_SYMBOL - 502))
        | (1ULL << (MySQLParser::SECURITY_SYMBOL - 502))
        | (1ULL << (MySQLParser::SERIALIZABLE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SERIAL_SYMBOL - 502))
        | (1ULL << (MySQLParser::SERVER_SYMBOL - 502))
        | (1ULL << (MySQLParser::SHARE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SIMPLE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SLOW_SYMBOL - 502))
        | (1ULL << (MySQLParser::SNAPSHOT_SYMBOL - 502))
        | (1ULL << (MySQLParser::SOCKET_SYMBOL - 502))
        | (1ULL << (MySQLParser::SONAME_SYMBOL - 502))
        | (1ULL << (MySQLParser::SOUNDS_SYMBOL - 502))
        | (1ULL << (MySQLParser::SOURCE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SQL_AFTER_GTIDS_SYMBOL - 502))
        | (1ULL << (MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL - 502))
        | (1ULL << (MySQLParser::SQL_BEFORE_GTIDS_SYMBOL - 502))
        | (1ULL << (MySQLParser::SQL_BUFFER_RESULT_SYMBOL - 502))
        | (1ULL << (MySQLParser::SQL_NO_CACHE_SYMBOL - 502))
        | (1ULL << (MySQLParser::SQL_THREAD_SYMBOL - 502)))) != 0) || ((((_la - 566) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 566)) & ((1ULL << (MySQLParser::STACKED_SYMBOL - 566))
        | (1ULL << (MySQLParser::STARTS_SYMBOL - 566))
        | (1ULL << (MySQLParser::STATS_AUTO_RECALC_SYMBOL - 566))
        | (1ULL << (MySQLParser::STATS_PERSISTENT_SYMBOL - 566))
        | (1ULL << (MySQLParser::STATS_SAMPLE_PAGES_SYMBOL - 566))
        | (1ULL << (MySQLParser::STATUS_SYMBOL - 566))
        | (1ULL << (MySQLParser::STORAGE_SYMBOL - 566))
        | (1ULL << (MySQLParser::STRING_SYMBOL - 566))
        | (1ULL << (MySQLParser::SUBCLASS_ORIGIN_SYMBOL - 566))
        | (1ULL << (MySQLParser::SUBDATE_SYMBOL - 566))
        | (1ULL << (MySQLParser::SUBJECT_SYMBOL - 566))
        | (1ULL << (MySQLParser::SUBPARTITIONS_SYMBOL - 566))
        | (1ULL << (MySQLParser::SUBPARTITION_SYMBOL - 566))
        | (1ULL << (MySQLParser::SUSPEND_SYMBOL - 566))
        | (1ULL << (MySQLParser::SWAPS_SYMBOL - 566))
        | (1ULL << (MySQLParser::SWITCHES_SYMBOL - 566))
        | (1ULL << (MySQLParser::TABLES_SYMBOL - 566))
        | (1ULL << (MySQLParser::TABLESPACE_SYMBOL - 566))
        | (1ULL << (MySQLParser::TABLE_CHECKSUM_SYMBOL - 566))
        | (1ULL << (MySQLParser::TABLE_NAME_SYMBOL - 566))
        | (1ULL << (MySQLParser::TEMPORARY_SYMBOL - 566))
        | (1ULL << (MySQLParser::TEMPTABLE_SYMBOL - 566))
        | (1ULL << (MySQLParser::TEXT_SYMBOL - 566))
        | (1ULL << (MySQLParser::THAN_SYMBOL - 566))
        | (1ULL << (MySQLParser::TIMESTAMP_SYMBOL - 566))
        | (1ULL << (MySQLParser::TIMESTAMPADD_SYMBOL - 566))
        | (1ULL << (MySQLParser::TIMESTAMPDIFF_SYMBOL - 566))
        | (1ULL << (MySQLParser::TIME_SYMBOL - 566))
        | (1ULL << (MySQLParser::TRANSACTION_SYMBOL - 566))
        | (1ULL << (MySQLParser::TRIGGERS_SYMBOL - 566))
        | (1ULL << (MySQLParser::TYPES_SYMBOL - 566))
        | (1ULL << (MySQLParser::TYPE_SYMBOL - 566))
        | (1ULL << (MySQLParser::UNCOMMITTED_SYMBOL - 566))
        | (1ULL << (MySQLParser::UNDEFINED_SYMBOL - 566))
        | (1ULL << (MySQLParser::UNDOFILE_SYMBOL - 566)))) != 0) || ((((_la - 630) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 630)) & ((1ULL << (MySQLParser::UNDO_BUFFER_SIZE_SYMBOL - 630))
        | (1ULL << (MySQLParser::UNKNOWN_SYMBOL - 630))
        | (1ULL << (MySQLParser::UNTIL_SYMBOL - 630))
        | (1ULL << (MySQLParser::UPGRADE_SYMBOL - 630))
        | (1ULL << (MySQLParser::USER_RESOURCES_SYMBOL - 630))
        | (1ULL << (MySQLParser::USER_SYMBOL - 630))
        | (1ULL << (MySQLParser::USE_FRM_SYMBOL - 630))
        | (1ULL << (MySQLParser::VALIDATION_SYMBOL - 630))
        | (1ULL << (MySQLParser::VALUE_SYMBOL - 630))
        | (1ULL << (MySQLParser::VARIABLES_SYMBOL - 630))
        | (1ULL << (MySQLParser::VIEW_SYMBOL - 630))
        | (1ULL << (MySQLParser::WAIT_SYMBOL - 630))
        | (1ULL << (MySQLParser::WARNINGS_SYMBOL - 630))
        | (1ULL << (MySQLParser::WEEK_SYMBOL - 630))
        | (1ULL << (MySQLParser::WEIGHT_STRING_SYMBOL - 630))
        | (1ULL << (MySQLParser::WITHOUT_SYMBOL - 630))
        | (1ULL << (MySQLParser::WORK_SYMBOL - 630))
        | (1ULL << (MySQLParser::WRAPPER_SYMBOL - 630))
        | (1ULL << (MySQLParser::X509_SYMBOL - 630))
        | (1ULL << (MySQLParser::XID_SYMBOL - 630))
        | (1ULL << (MySQLParser::XML_SYMBOL - 630))
        | (1ULL << (MySQLParser::YEAR_SYMBOL - 630))
        | (1ULL << (MySQLParser::ROLE_SYMBOL - 630))
        | (1ULL << (MySQLParser::ADMIN_SYMBOL - 630))
        | (1ULL << (MySQLParser::INVISIBLE_SYMBOL - 630))
        | (1ULL << (MySQLParser::VISIBLE_SYMBOL - 630))
        | (1ULL << (MySQLParser::COMPONENT_SYMBOL - 630)))) != 0) || ((((_la - 694) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 694)) & ((1ULL << (MySQLParser::SKIP_SYMBOL - 694))
        | (1ULL << (MySQLParser::LOCKED_SYMBOL - 694))
        | (1ULL << (MySQLParser::NOWAIT_SYMBOL - 694))
        | (1ULL << (MySQLParser::HISTOGRAM_SYMBOL - 694))
        | (1ULL << (MySQLParser::BUCKETS_SYMBOL - 694))
        | (1ULL << (MySQLParser::EXCLUDE_SYMBOL - 694))
        | (1ULL << (MySQLParser::FOLLOWING_SYMBOL - 694))
        | (1ULL << (MySQLParser::NULLS_SYMBOL - 694))
        | (1ULL << (MySQLParser::OTHERS_SYMBOL - 694))
        | (1ULL << (MySQLParser::PRECEDING_SYMBOL - 694))
        | (1ULL << (MySQLParser::RESPECT_SYMBOL - 694))
        | (1ULL << (MySQLParser::TIES_SYMBOL - 694))
        | (1ULL << (MySQLParser::UNBOUNDED_SYMBOL - 694))
        | (1ULL << (MySQLParser::NESTED_SYMBOL - 694))
        | (1ULL << (MySQLParser::ORDINALITY_SYMBOL - 694))
        | (1ULL << (MySQLParser::PATH_SYMBOL - 694))
        | (1ULL << (MySQLParser::HISTORY_SYMBOL - 694))
        | (1ULL << (MySQLParser::REUSE_SYMBOL - 694))
        | (1ULL << (MySQLParser::SRID_SYMBOL - 694))
        | (1ULL << (MySQLParser::THREAD_PRIORITY_SYMBOL - 694))
        | (1ULL << (MySQLParser::VCPU_SYMBOL - 694))
        | (1ULL << (MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL - 694))
        | (1ULL << (MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL - 694))
        | (1ULL << (MySQLParser::DEFINITION_SYMBOL - 694))
        | (1ULL << (MySQLParser::DESCRIPTION_SYMBOL - 694))
        | (1ULL << (MySQLParser::ORGANIZATION_SYMBOL - 694))
        | (1ULL << (MySQLParser::REFERENCE_SYMBOL - 694))
        | (1ULL << (MySQLParser::OPTIONAL_SYMBOL - 694))
        | (1ULL << (MySQLParser::SECONDARY_SYMBOL - 694))
        | (1ULL << (MySQLParser::SECONDARY_ENGINE_SYMBOL - 694))
        | (1ULL << (MySQLParser::SECONDARY_LOAD_SYMBOL - 694))
        | (1ULL << (MySQLParser::SECONDARY_UNLOAD_SYMBOL - 694))
        | (1ULL << (MySQLParser::ACTIVE_SYMBOL - 694))
        | (1ULL << (MySQLParser::INACTIVE_SYMBOL - 694))
        | (1ULL << (MySQLParser::RETAIN_SYMBOL - 694))
        | (1ULL << (MySQLParser::OLD_SYMBOL - 694))
        | (1ULL << (MySQLParser::NETWORK_NAMESPACE_SYMBOL - 694))
        | (1ULL << (MySQLParser::ENFORCED_SYMBOL - 694))
        | (1ULL << (MySQLParser::OJ_SYMBOL - 694)))) != 0) || ((((_la - 760) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 760)) & ((1ULL << (MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL - 760))
        | (1ULL << (MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL - 760))
        | (1ULL << (MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL - 760))
        | (1ULL << (MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL - 760))
        | (1ULL << (MySQLParser::RETURNING_SYMBOL - 760))
        | (1ULL << (MySQLParser::JSON_VALUE_SYMBOL - 760))
        | (1ULL << (MySQLParser::TLS_SYMBOL - 760))
        | (1ULL << (MySQLParser::ATTRIBUTE_SYMBOL - 760))
        | (1ULL << (MySQLParser::SECONDARY_ENGINE_ATTRIBUTE_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_CONNECTION_AUTO_FAILOVER_SYMBOL - 760))
        | (1ULL << (MySQLParser::ZONE_SYMBOL - 760))
        | (1ULL << (MySQLParser::REPLICA_SYMBOL - 760))
        | (1ULL << (MySQLParser::REPLICAS_SYMBOL - 760))
        | (1ULL << (MySQLParser::ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_SYMBOL - 760))
        | (1ULL << (MySQLParser::GET_SOURCE_PUBLIC_KEY_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_AUTO_POSITION_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_BIND_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_COMPRESSION_ALGORITHM_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_CONNECT_RETRY_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_DELAY_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_HEARTBEAT_PERIOD_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_HOST_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_LOG_FILE_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_LOG_POS_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_PASSWORD_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_PORT_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_PUBLIC_KEY_PATH_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_RETRY_COUNT_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_CA_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_CAPATH_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_CERT_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_CIPHER_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_CRL_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_CRLPATH_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_KEY_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_SSL_VERIFY_SERVER_CERT_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_TLS_CIPHERSUITES_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_TLS_VERSION_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_USER_SYMBOL - 760))
        | (1ULL << (MySQLParser::SOURCE_ZSTD_COMPRESSION_LEVEL_SYMBOL - 760))
        | (1ULL << (MySQLParser::ST_COLLECT_SYMBOL - 760))
        | (1ULL << (MySQLParser::KEYRING_SYMBOL - 760))
        | (1ULL << (MySQLParser::AUTHENTICATION_SYMBOL - 760))
        | (1ULL << (MySQLParser::FACTOR_SYMBOL - 760))
        | (1ULL << (MySQLParser::FINISH_SYMBOL - 760))
        | (1ULL << (MySQLParser::INITIATE_SYMBOL - 760))
        | (1ULL << (MySQLParser::REGISTRATION_SYMBOL - 760))
        | (1ULL << (MySQLParser::UNREGISTER_SYMBOL - 760))
        | (1ULL << (MySQLParser::INITIAL_SYMBOL - 760))
        | (1ULL << (MySQLParser::CHALLENGE_RESPONSE_SYMBOL - 760))
        | (1ULL << (MySQLParser::GTID_ONLY_SYMBOL - 760)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9634);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(9635);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::TIMESTAMP_SYMBOL

      || _la == MySQLParser::TIME_SYMBOL || ((((_la - 756) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 756)) & ((1ULL << (MySQLParser::ARRAY_SYMBOL - 756))
        | (1ULL << (MySQLParser::MEMBER_SYMBOL - 756))
        | (1ULL << (MySQLParser::RANDOM_SYMBOL - 756))
        | (1ULL << (MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL - 756))
        | (1ULL << (MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL - 756))
        | (1ULL << (MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL - 756))
        | (1ULL << (MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL - 756))
        | (1ULL << (MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL - 756))
        | (1ULL << (MySQLParser::PASSWORD_LOCK_TIME_SYMBOL - 756))
        | (1ULL << (MySQLParser::FAILED_LOGIN_ATTEMPTS_SYMBOL - 756))
        | (1ULL << (MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL - 756))
        | (1ULL << (MySQLParser::STREAM_SYMBOL - 756))
        | (1ULL << (MySQLParser::OFF_SYMBOL - 756)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9636);

      if (!(serverVersion >= 80032)) throw FailedPredicateException(this, "serverVersion >= 80032");
      setState(9637);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::BULK_SYMBOL

      || _la == MySQLParser::GENERATE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9638);

      if (!(serverVersion >= 80100)) throw FailedPredicateException(this, "serverVersion >= 80100");

      setState(9639);
      match(MySQLParser::PARSE_TREE_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(9640);

      if (!(serverVersion >= 80200)) throw FailedPredicateException(this, "serverVersion >= 80200");
      setState(9641);
      _la = _input->LA(1);
      if (!(((((_la - 825) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 825)) & ((1ULL << (MySQLParser::LOG_SYMBOL - 825))
        | (1ULL << (MySQLParser::GTIDS_SYMBOL - 825))
        | (1ULL << (MySQLParser::S3_SYMBOL - 825)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(9642);

      if (!(serverVersion >= 80400)) throw FailedPredicateException(this, "serverVersion >= 80400");
      setState(9643);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::AUTO_SYMBOL

      || _la == MySQLParser::BERNOULLI_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(9644);

      if (!(serverVersion >= 90000)) throw FailedPredicateException(this, "serverVersion >= 90000");

      setState(9645);
      match(MySQLParser::VECTOR_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleKeywordContext ------------------------------------------------------------------

MySQLParser::RoleKeywordContext::RoleKeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoleOrLabelKeywordContext* MySQLParser::RoleKeywordContext::roleOrLabelKeyword() {
  return getRuleContext<MySQLParser::RoleOrLabelKeywordContext>(0);
}

MySQLParser::RoleOrIdentifierKeywordContext* MySQLParser::RoleKeywordContext::roleOrIdentifierKeyword() {
  return getRuleContext<MySQLParser::RoleOrIdentifierKeywordContext>(0);
}

MySQLParser::IdentifierKeywordsUnambiguousContext* MySQLParser::RoleKeywordContext::identifierKeywordsUnambiguous() {
  return getRuleContext<MySQLParser::IdentifierKeywordsUnambiguousContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext* MySQLParser::RoleKeywordContext::identifierKeywordsAmbiguous2Labels() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext* MySQLParser::RoleKeywordContext::identifierKeywordsAmbiguous4SystemVariables() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext>(0);
}


size_t MySQLParser::RoleKeywordContext::getRuleIndex() const {
  return MySQLParser::RuleRoleKeyword;
}

void MySQLParser::RoleKeywordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleKeyword(this);
}

void MySQLParser::RoleKeywordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleKeyword(this);
}


std::any MySQLParser::RoleKeywordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleKeyword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleKeywordContext* MySQLParser::roleKeyword() {
  RoleKeywordContext *_localctx = _tracker.createInstance<RoleKeywordContext>(_ctx, getState());
  enterRule(_localctx, 1518, MySQLParser::RuleRoleKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9658);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1214, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9648);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(9651);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1212, _ctx)) {
      case 1: {
        setState(9649);
        roleOrLabelKeyword();
        break;
      }

      case 2: {
        setState(9650);
        roleOrIdentifierKeyword();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9656);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1213, _ctx)) {
      case 1: {
        setState(9653);
        identifierKeywordsUnambiguous();
        break;
      }

      case 2: {
        setState(9654);
        identifierKeywordsAmbiguous2Labels();
        break;
      }

      case 3: {
        setState(9655);
        identifierKeywordsAmbiguous4SystemVariables();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- LValueKeywordContext ------------------------------------------------------------------

MySQLParser::LValueKeywordContext::LValueKeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::IdentifierKeywordsUnambiguousContext* MySQLParser::LValueKeywordContext::identifierKeywordsUnambiguous() {
  return getRuleContext<MySQLParser::IdentifierKeywordsUnambiguousContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext* MySQLParser::LValueKeywordContext::identifierKeywordsAmbiguous1RolesAndLabels() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous1RolesAndLabelsContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext* MySQLParser::LValueKeywordContext::identifierKeywordsAmbiguous2Labels() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous2LabelsContext>(0);
}

MySQLParser::IdentifierKeywordsAmbiguous3RolesContext* MySQLParser::LValueKeywordContext::identifierKeywordsAmbiguous3Roles() {
  return getRuleContext<MySQLParser::IdentifierKeywordsAmbiguous3RolesContext>(0);
}


size_t MySQLParser::LValueKeywordContext::getRuleIndex() const {
  return MySQLParser::RuleLValueKeyword;
}

void MySQLParser::LValueKeywordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterLValueKeyword(this);
}

void MySQLParser::LValueKeywordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitLValueKeyword(this);
}


std::any MySQLParser::LValueKeywordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitLValueKeyword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::LValueKeywordContext* MySQLParser::lValueKeyword() {
  LValueKeywordContext *_localctx = _tracker.createInstance<LValueKeywordContext>(_ctx, getState());
  enterRule(_localctx, 1520, MySQLParser::RuleLValueKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9664);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1215, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9660);
      identifierKeywordsUnambiguous();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9661);
      identifierKeywordsAmbiguous1RolesAndLabels();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9662);
      identifierKeywordsAmbiguous2Labels();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9663);
      identifierKeywordsAmbiguous3Roles();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierKeywordsAmbiguous4SystemVariablesContext ------------------------------------------------------------------

MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::IdentifierKeywordsAmbiguous4SystemVariablesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::PERSIST_SYMBOL() {
  return getToken(MySQLParser::PERSIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::PERSIST_ONLY_SYMBOL() {
  return getToken(MySQLParser::PERSIST_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::SESSION_SYMBOL() {
  return getToken(MySQLParser::SESSION_SYMBOL, 0);
}


size_t MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::getRuleIndex() const {
  return MySQLParser::RuleIdentifierKeywordsAmbiguous4SystemVariables;
}

void MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterIdentifierKeywordsAmbiguous4SystemVariables(this);
}

void MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitIdentifierKeywordsAmbiguous4SystemVariables(this);
}


std::any MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitIdentifierKeywordsAmbiguous4SystemVariables(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::IdentifierKeywordsAmbiguous4SystemVariablesContext* MySQLParser::identifierKeywordsAmbiguous4SystemVariables() {
  IdentifierKeywordsAmbiguous4SystemVariablesContext *_localctx = _tracker.createInstance<IdentifierKeywordsAmbiguous4SystemVariablesContext>(_ctx, getState());
  enterRule(_localctx, 1522, MySQLParser::RuleIdentifierKeywordsAmbiguous4SystemVariables);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(9666);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::GLOBAL_SYMBOL || _la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::SESSION_SYMBOL || _la == MySQLParser::PERSIST_SYMBOL

    || _la == MySQLParser::PERSIST_ONLY_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleOrIdentifierKeywordContext ------------------------------------------------------------------

MySQLParser::RoleOrIdentifierKeywordContext::RoleOrIdentifierKeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::ACCOUNT_SYMBOL() {
  return getToken(MySQLParser::ACCOUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::ASCII_SYMBOL() {
  return getToken(MySQLParser::ASCII_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::ALWAYS_SYMBOL() {
  return getToken(MySQLParser::ALWAYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::BACKUP_SYMBOL() {
  return getToken(MySQLParser::BACKUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::BEGIN_SYMBOL() {
  return getToken(MySQLParser::BEGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::BYTE_SYMBOL() {
  return getToken(MySQLParser::BYTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::CACHE_SYMBOL() {
  return getToken(MySQLParser::CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::CHARSET_SYMBOL() {
  return getToken(MySQLParser::CHARSET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::CLONE_SYMBOL() {
  return getToken(MySQLParser::CLONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::CLOSE_SYMBOL() {
  return getToken(MySQLParser::CLOSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::COMMENT_SYMBOL() {
  return getToken(MySQLParser::COMMENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::COMMIT_SYMBOL() {
  return getToken(MySQLParser::COMMIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::CONTAINS_SYMBOL() {
  return getToken(MySQLParser::CONTAINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::DEALLOCATE_SYMBOL() {
  return getToken(MySQLParser::DEALLOCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::DO_SYMBOL() {
  return getToken(MySQLParser::DO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::END_SYMBOL() {
  return getToken(MySQLParser::END_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::FLUSH_SYMBOL() {
  return getToken(MySQLParser::FLUSH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::FOLLOWS_SYMBOL() {
  return getToken(MySQLParser::FOLLOWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::GROUP_REPLICATION_SYMBOL() {
  return getToken(MySQLParser::GROUP_REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::HANDLER_SYMBOL() {
  return getToken(MySQLParser::HANDLER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::HELP_SYMBOL() {
  return getToken(MySQLParser::HELP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::HOST_SYMBOL() {
  return getToken(MySQLParser::HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::INSTALL_SYMBOL() {
  return getToken(MySQLParser::INSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::INVISIBLE_SYMBOL() {
  return getToken(MySQLParser::INVISIBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::LANGUAGE_SYMBOL() {
  return getToken(MySQLParser::LANGUAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::NO_SYMBOL() {
  return getToken(MySQLParser::NO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::OPEN_SYMBOL() {
  return getToken(MySQLParser::OPEN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::OPTIONS_SYMBOL() {
  return getToken(MySQLParser::OPTIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::OWNER_SYMBOL() {
  return getToken(MySQLParser::OWNER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::PARSER_SYMBOL() {
  return getToken(MySQLParser::PARSER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::PARTITION_SYMBOL() {
  return getToken(MySQLParser::PARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::PORT_SYMBOL() {
  return getToken(MySQLParser::PORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::PRECEDES_SYMBOL() {
  return getToken(MySQLParser::PRECEDES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::PREPARE_SYMBOL() {
  return getToken(MySQLParser::PREPARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::REMOVE_SYMBOL() {
  return getToken(MySQLParser::REMOVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::REPAIR_SYMBOL() {
  return getToken(MySQLParser::REPAIR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::RESET_SYMBOL() {
  return getToken(MySQLParser::RESET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::RESTORE_SYMBOL() {
  return getToken(MySQLParser::RESTORE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::ROLLBACK_SYMBOL() {
  return getToken(MySQLParser::ROLLBACK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SAVEPOINT_SYMBOL() {
  return getToken(MySQLParser::SAVEPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SECONDARY_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SECONDARY_ENGINE_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SECONDARY_LOAD_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_LOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SECONDARY_UNLOAD_SYMBOL() {
  return getToken(MySQLParser::SECONDARY_UNLOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SECURITY_SYMBOL() {
  return getToken(MySQLParser::SECURITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SERVER_SYMBOL() {
  return getToken(MySQLParser::SERVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SIGNED_SYMBOL() {
  return getToken(MySQLParser::SIGNED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SOCKET_SYMBOL() {
  return getToken(MySQLParser::SOCKET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SONAME_SYMBOL() {
  return getToken(MySQLParser::SONAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::STOP_SYMBOL() {
  return getToken(MySQLParser::STOP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::TRUNCATE_SYMBOL() {
  return getToken(MySQLParser::TRUNCATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::UNICODE_SYMBOL() {
  return getToken(MySQLParser::UNICODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::UNINSTALL_SYMBOL() {
  return getToken(MySQLParser::UNINSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::UPGRADE_SYMBOL() {
  return getToken(MySQLParser::UPGRADE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::VISIBLE_SYMBOL() {
  return getToken(MySQLParser::VISIBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::WRAPPER_SYMBOL() {
  return getToken(MySQLParser::WRAPPER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::XA_SYMBOL() {
  return getToken(MySQLParser::XA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::SHUTDOWN_SYMBOL() {
  return getToken(MySQLParser::SHUTDOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrIdentifierKeywordContext::IMPORT_SYMBOL() {
  return getToken(MySQLParser::IMPORT_SYMBOL, 0);
}


size_t MySQLParser::RoleOrIdentifierKeywordContext::getRuleIndex() const {
  return MySQLParser::RuleRoleOrIdentifierKeyword;
}

void MySQLParser::RoleOrIdentifierKeywordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleOrIdentifierKeyword(this);
}

void MySQLParser::RoleOrIdentifierKeywordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleOrIdentifierKeyword(this);
}


std::any MySQLParser::RoleOrIdentifierKeywordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleOrIdentifierKeyword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleOrIdentifierKeywordContext* MySQLParser::roleOrIdentifierKeyword() {
  RoleOrIdentifierKeywordContext *_localctx = _tracker.createInstance<RoleOrIdentifierKeywordContext>(_ctx, getState());
  enterRule(_localctx, 1524, MySQLParser::RuleRoleOrIdentifierKeyword);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9673);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1216, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9668);
      _la = _input->LA(1);
      if (!(((((_la - 48) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 48)) & ((1ULL << (MySQLParser::ACCOUNT_SYMBOL - 48))
        | (1ULL << (MySQLParser::ALWAYS_SYMBOL - 48))
        | (1ULL << (MySQLParser::ASCII_SYMBOL - 48))
        | (1ULL << (MySQLParser::BACKUP_SYMBOL - 48))
        | (1ULL << (MySQLParser::BEGIN_SYMBOL - 48))
        | (1ULL << (MySQLParser::BYTE_SYMBOL - 48))
        | (1ULL << (MySQLParser::CACHE_SYMBOL - 48))
        | (1ULL << (MySQLParser::CHARSET_SYMBOL - 48))
        | (1ULL << (MySQLParser::CHECKSUM_SYMBOL - 48))
        | (1ULL << (MySQLParser::CLOSE_SYMBOL - 48)))) != 0) || ((((_la - 119) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 119)) & ((1ULL << (MySQLParser::COMMENT_SYMBOL - 119))
        | (1ULL << (MySQLParser::COMMIT_SYMBOL - 119))
        | (1ULL << (MySQLParser::CONTAINS_SYMBOL - 119))
        | (1ULL << (MySQLParser::DEALLOCATE_SYMBOL - 119)))) != 0) || ((((_la - 186) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 186)) & ((1ULL << (MySQLParser::DO_SYMBOL - 186))
        | (1ULL << (MySQLParser::END_SYMBOL - 186))
        | (1ULL << (MySQLParser::FLUSH_SYMBOL - 186))
        | (1ULL << (MySQLParser::FOLLOWS_SYMBOL - 186))
        | (1ULL << (MySQLParser::FORMAT_SYMBOL - 186))
        | (1ULL << (MySQLParser::GROUP_REPLICATION_SYMBOL - 186)))) != 0) || ((((_la - 255) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 255)) & ((1ULL << (MySQLParser::HANDLER_SYMBOL - 255))
        | (1ULL << (MySQLParser::HELP_SYMBOL - 255))
        | (1ULL << (MySQLParser::HOST_SYMBOL - 255))
        | (1ULL << (MySQLParser::INSTALL_SYMBOL - 255))
        | (1ULL << (MySQLParser::LANGUAGE_SYMBOL - 255)))) != 0) || ((((_la - 403) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 403)) & ((1ULL << (MySQLParser::NO_SYMBOL - 403))
        | (1ULL << (MySQLParser::OPEN_SYMBOL - 403))
        | (1ULL << (MySQLParser::OPTIONS_SYMBOL - 403))
        | (1ULL << (MySQLParser::OWNER_SYMBOL - 403))
        | (1ULL << (MySQLParser::PARSER_SYMBOL - 403))
        | (1ULL << (MySQLParser::PARTITION_SYMBOL - 403))
        | (1ULL << (MySQLParser::PORT_SYMBOL - 403))
        | (1ULL << (MySQLParser::PRECEDES_SYMBOL - 403))
        | (1ULL << (MySQLParser::PREPARE_SYMBOL - 403)))) != 0) || ((((_la - 482) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 482)) & ((1ULL << (MySQLParser::REMOVE_SYMBOL - 482))
        | (1ULL << (MySQLParser::REPAIR_SYMBOL - 482))
        | (1ULL << (MySQLParser::RESET_SYMBOL - 482))
        | (1ULL << (MySQLParser::RESTORE_SYMBOL - 482))
        | (1ULL << (MySQLParser::ROLLBACK_SYMBOL - 482))
        | (1ULL << (MySQLParser::SAVEPOINT_SYMBOL - 482))
        | (1ULL << (MySQLParser::SECURITY_SYMBOL - 482))
        | (1ULL << (MySQLParser::SERVER_SYMBOL - 482))
        | (1ULL << (MySQLParser::SIGNED_SYMBOL - 482))
        | (1ULL << (MySQLParser::SLAVE_SYMBOL - 482))
        | (1ULL << (MySQLParser::SOCKET_SYMBOL - 482)))) != 0) || ((((_la - 546) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 546)) & ((1ULL << (MySQLParser::SONAME_SYMBOL - 546))
        | (1ULL << (MySQLParser::START_SYMBOL - 546))
        | (1ULL << (MySQLParser::STOP_SYMBOL - 546)))) != 0) || ((((_la - 623) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 623)) & ((1ULL << (MySQLParser::TRUNCATE_SYMBOL - 623))
        | (1ULL << (MySQLParser::UNICODE_SYMBOL - 623))
        | (1ULL << (MySQLParser::UNINSTALL_SYMBOL - 623))
        | (1ULL << (MySQLParser::UPGRADE_SYMBOL - 623))
        | (1ULL << (MySQLParser::WRAPPER_SYMBOL - 623))
        | (1ULL << (MySQLParser::XA_SYMBOL - 623))
        | (1ULL << (MySQLParser::ROLE_SYMBOL - 623))
        | (1ULL << (MySQLParser::INVISIBLE_SYMBOL - 623)))) != 0) || ((((_la - 687) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 687)) & ((1ULL << (MySQLParser::VISIBLE_SYMBOL - 687))
        | (1ULL << (MySQLParser::CLONE_SYMBOL - 687))
        | (1ULL << (MySQLParser::SECONDARY_SYMBOL - 687))
        | (1ULL << (MySQLParser::SECONDARY_ENGINE_SYMBOL - 687))
        | (1ULL << (MySQLParser::SECONDARY_LOAD_SYMBOL - 687))
        | (1ULL << (MySQLParser::SECONDARY_UNLOAD_SYMBOL - 687)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9669);

      if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
      setState(9670);
      match(MySQLParser::SHUTDOWN_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9671);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9672);
      match(MySQLParser::IMPORT_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleOrLabelKeywordContext ------------------------------------------------------------------

MySQLParser::RoleOrLabelKeywordContext::RoleOrLabelKeywordContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ACTION_SYMBOL() {
  return getToken(MySQLParser::ACTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ACTIVE_SYMBOL() {
  return getToken(MySQLParser::ACTIVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ADDDATE_SYMBOL() {
  return getToken(MySQLParser::ADDDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AFTER_SYMBOL() {
  return getToken(MySQLParser::AFTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AGAINST_SYMBOL() {
  return getToken(MySQLParser::AGAINST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AGGREGATE_SYMBOL() {
  return getToken(MySQLParser::AGGREGATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::ALGORITHM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ANALYSE_SYMBOL() {
  return getToken(MySQLParser::ANALYSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ANY_SYMBOL() {
  return getToken(MySQLParser::ANY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AT_SYMBOL() {
  return getToken(MySQLParser::AT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AUTO_INCREMENT_SYMBOL() {
  return getToken(MySQLParser::AUTO_INCREMENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AUTOEXTEND_SIZE_SYMBOL() {
  return getToken(MySQLParser::AUTOEXTEND_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AVG_ROW_LENGTH_SYMBOL() {
  return getToken(MySQLParser::AVG_ROW_LENGTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::AVG_SYMBOL() {
  return getToken(MySQLParser::AVG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BINLOG_SYMBOL() {
  return getToken(MySQLParser::BINLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BIT_SYMBOL() {
  return getToken(MySQLParser::BIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BLOCK_SYMBOL() {
  return getToken(MySQLParser::BLOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BOOL_SYMBOL() {
  return getToken(MySQLParser::BOOL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BOOLEAN_SYMBOL() {
  return getToken(MySQLParser::BOOLEAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BTREE_SYMBOL() {
  return getToken(MySQLParser::BTREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::BUCKETS_SYMBOL() {
  return getToken(MySQLParser::BUCKETS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CASCADED_SYMBOL() {
  return getToken(MySQLParser::CASCADED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CATALOG_NAME_SYMBOL() {
  return getToken(MySQLParser::CATALOG_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CHAIN_SYMBOL() {
  return getToken(MySQLParser::CHAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CHANGED_SYMBOL() {
  return getToken(MySQLParser::CHANGED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CHANNEL_SYMBOL() {
  return getToken(MySQLParser::CHANNEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CIPHER_SYMBOL() {
  return getToken(MySQLParser::CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CLIENT_SYMBOL() {
  return getToken(MySQLParser::CLIENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CLASS_ORIGIN_SYMBOL() {
  return getToken(MySQLParser::CLASS_ORIGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COALESCE_SYMBOL() {
  return getToken(MySQLParser::COALESCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CODE_SYMBOL() {
  return getToken(MySQLParser::CODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COLLATION_SYMBOL() {
  return getToken(MySQLParser::COLLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COLUMN_NAME_SYMBOL() {
  return getToken(MySQLParser::COLUMN_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COLUMN_FORMAT_SYMBOL() {
  return getToken(MySQLParser::COLUMN_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COMMITTED_SYMBOL() {
  return getToken(MySQLParser::COMMITTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COMPACT_SYMBOL() {
  return getToken(MySQLParser::COMPACT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COMPLETION_SYMBOL() {
  return getToken(MySQLParser::COMPLETION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COMPONENT_SYMBOL() {
  return getToken(MySQLParser::COMPONENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COMPRESSED_SYMBOL() {
  return getToken(MySQLParser::COMPRESSED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::COMPRESSION_SYMBOL() {
  return getToken(MySQLParser::COMPRESSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONCURRENT_SYMBOL() {
  return getToken(MySQLParser::CONCURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONNECTION_SYMBOL() {
  return getToken(MySQLParser::CONNECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONSISTENT_SYMBOL() {
  return getToken(MySQLParser::CONSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONSTRAINT_CATALOG_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_CATALOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONSTRAINT_SCHEMA_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_SCHEMA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONSTRAINT_NAME_SYMBOL() {
  return getToken(MySQLParser::CONSTRAINT_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CONTEXT_SYMBOL() {
  return getToken(MySQLParser::CONTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CPU_SYMBOL() {
  return getToken(MySQLParser::CPU_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CURSOR_NAME_SYMBOL() {
  return getToken(MySQLParser::CURSOR_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DATA_SYMBOL() {
  return getToken(MySQLParser::DATA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DATAFILE_SYMBOL() {
  return getToken(MySQLParser::DATAFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DATETIME_SYMBOL() {
  return getToken(MySQLParser::DATETIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DAY_SYMBOL() {
  return getToken(MySQLParser::DAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DEFAULT_AUTH_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_AUTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DEFINER_SYMBOL() {
  return getToken(MySQLParser::DEFINER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DELAY_KEY_WRITE_SYMBOL() {
  return getToken(MySQLParser::DELAY_KEY_WRITE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DES_KEY_FILE_SYMBOL() {
  return getToken(MySQLParser::DES_KEY_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DESCRIPTION_SYMBOL() {
  return getToken(MySQLParser::DESCRIPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DIAGNOSTICS_SYMBOL() {
  return getToken(MySQLParser::DIAGNOSTICS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DIRECTORY_SYMBOL() {
  return getToken(MySQLParser::DIRECTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DISABLE_SYMBOL() {
  return getToken(MySQLParser::DISABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DISCARD_SYMBOL() {
  return getToken(MySQLParser::DISCARD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DISK_SYMBOL() {
  return getToken(MySQLParser::DISK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DUMPFILE_SYMBOL() {
  return getToken(MySQLParser::DUMPFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DUPLICATE_SYMBOL() {
  return getToken(MySQLParser::DUPLICATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::DYNAMIC_SYMBOL() {
  return getToken(MySQLParser::DYNAMIC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENCRYPTION_SYMBOL() {
  return getToken(MySQLParser::ENCRYPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENDS_SYMBOL() {
  return getToken(MySQLParser::ENDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENUM_SYMBOL() {
  return getToken(MySQLParser::ENUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENGINES_SYMBOL() {
  return getToken(MySQLParser::ENGINES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENGINE_ATTRIBUTE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_ATTRIBUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ERRORS_SYMBOL() {
  return getToken(MySQLParser::ERRORS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ESCAPE_SYMBOL() {
  return getToken(MySQLParser::ESCAPE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EVENTS_SYMBOL() {
  return getToken(MySQLParser::EVENTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EVERY_SYMBOL() {
  return getToken(MySQLParser::EVERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXCLUDE_SYMBOL() {
  return getToken(MySQLParser::EXCLUDE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXPANSION_SYMBOL() {
  return getToken(MySQLParser::EXPANSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXPORT_SYMBOL() {
  return getToken(MySQLParser::EXPORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXTENT_SIZE_SYMBOL() {
  return getToken(MySQLParser::EXTENT_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FAULTS_SYMBOL() {
  return getToken(MySQLParser::FAULTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FAST_SYMBOL() {
  return getToken(MySQLParser::FAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FOLLOWING_SYMBOL() {
  return getToken(MySQLParser::FOLLOWING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FOUND_SYMBOL() {
  return getToken(MySQLParser::FOUND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ENABLE_SYMBOL() {
  return getToken(MySQLParser::ENABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FILE_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::FILE_BLOCK_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FILTER_SYMBOL() {
  return getToken(MySQLParser::FILTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FIRST_SYMBOL() {
  return getToken(MySQLParser::FIRST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FIXED_SYMBOL() {
  return getToken(MySQLParser::FIXED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::GENERAL_SYMBOL() {
  return getToken(MySQLParser::GENERAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::GEOMETRY_SYMBOL() {
  return getToken(MySQLParser::GEOMETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::GEOMETRYCOLLECTION_SYMBOL() {
  return getToken(MySQLParser::GEOMETRYCOLLECTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::GET_FORMAT_SYMBOL() {
  return getToken(MySQLParser::GET_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::GRANTS_SYMBOL() {
  return getToken(MySQLParser::GRANTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::HASH_SYMBOL() {
  return getToken(MySQLParser::HASH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::HISTOGRAM_SYMBOL() {
  return getToken(MySQLParser::HISTOGRAM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::HISTORY_SYMBOL() {
  return getToken(MySQLParser::HISTORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::HOSTS_SYMBOL() {
  return getToken(MySQLParser::HOSTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::HOUR_SYMBOL() {
  return getToken(MySQLParser::HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::IGNORE_SERVER_IDS_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SERVER_IDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::INVOKER_SYMBOL() {
  return getToken(MySQLParser::INVOKER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::INDEXES_SYMBOL() {
  return getToken(MySQLParser::INDEXES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::INITIAL_SIZE_SYMBOL() {
  return getToken(MySQLParser::INITIAL_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::INSTANCE_SYMBOL() {
  return getToken(MySQLParser::INSTANCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::INACTIVE_SYMBOL() {
  return getToken(MySQLParser::INACTIVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::IO_SYMBOL() {
  return getToken(MySQLParser::IO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::IPC_SYMBOL() {
  return getToken(MySQLParser::IPC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ISOLATION_SYMBOL() {
  return getToken(MySQLParser::ISOLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ISSUER_SYMBOL() {
  return getToken(MySQLParser::ISSUER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::INSERT_METHOD_SYMBOL() {
  return getToken(MySQLParser::INSERT_METHOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::JSON_SYMBOL() {
  return getToken(MySQLParser::JSON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::KEY_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::KEY_BLOCK_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LAST_SYMBOL() {
  return getToken(MySQLParser::LAST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LEAVES_SYMBOL() {
  return getToken(MySQLParser::LEAVES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LESS_SYMBOL() {
  return getToken(MySQLParser::LESS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LEVEL_SYMBOL() {
  return getToken(MySQLParser::LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LINESTRING_SYMBOL() {
  return getToken(MySQLParser::LINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LIST_SYMBOL() {
  return getToken(MySQLParser::LIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LOCKED_SYMBOL() {
  return getToken(MySQLParser::LOCKED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LOCKS_SYMBOL() {
  return getToken(MySQLParser::LOCKS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LOGFILE_SYMBOL() {
  return getToken(MySQLParser::LOGFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_ROWS_SYMBOL() {
  return getToken(MySQLParser::MAX_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_HEARTBEAT_PERIOD_SYMBOL() {
  return getToken(MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_HOST_SYMBOL() {
  return getToken(MySQLParser::MASTER_HOST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_PORT_SYMBOL() {
  return getToken(MySQLParser::MASTER_PORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_POS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_USER_SYMBOL() {
  return getToken(MySQLParser::MASTER_USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::MASTER_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_PUBLIC_KEY_PATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_CONNECT_RETRY_SYMBOL() {
  return getToken(MySQLParser::MASTER_CONNECT_RETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_RETRY_COUNT_SYMBOL() {
  return getToken(MySQLParser::MASTER_RETRY_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_DELAY_SYMBOL() {
  return getToken(MySQLParser::MASTER_DELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_CA_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_CAPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CAPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_TLS_VERSION_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_VERSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_CERT_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_CIPHER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_CRL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_CRLPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRLPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SSL_KEY_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_AUTO_POSITION_SYMBOL() {
  return getToken(MySQLParser::MASTER_AUTO_POSITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_CONNECTIONS_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_QUERIES_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_STATEMENT_TIME_SYMBOL() {
  return getToken(MySQLParser::MAX_STATEMENT_TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_SIZE_SYMBOL() {
  return getToken(MySQLParser::MAX_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_UPDATES_PER_HOUR_SYMBOL() {
  return getToken(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MAX_USER_CONNECTIONS_SYMBOL() {
  return getToken(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MEDIUM_SYMBOL() {
  return getToken(MySQLParser::MEDIUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MERGE_SYMBOL() {
  return getToken(MySQLParser::MERGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MESSAGE_TEXT_SYMBOL() {
  return getToken(MySQLParser::MESSAGE_TEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MICROSECOND_SYMBOL() {
  return getToken(MySQLParser::MICROSECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MIGRATE_SYMBOL() {
  return getToken(MySQLParser::MIGRATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MINUTE_SYMBOL() {
  return getToken(MySQLParser::MINUTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MIN_ROWS_SYMBOL() {
  return getToken(MySQLParser::MIN_ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MODIFY_SYMBOL() {
  return getToken(MySQLParser::MODIFY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MODE_SYMBOL() {
  return getToken(MySQLParser::MODE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MONTH_SYMBOL() {
  return getToken(MySQLParser::MONTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MULTILINESTRING_SYMBOL() {
  return getToken(MySQLParser::MULTILINESTRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MULTIPOINT_SYMBOL() {
  return getToken(MySQLParser::MULTIPOINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MULTIPOLYGON_SYMBOL() {
  return getToken(MySQLParser::MULTIPOLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MUTEX_SYMBOL() {
  return getToken(MySQLParser::MUTEX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MYSQL_ERRNO_SYMBOL() {
  return getToken(MySQLParser::MYSQL_ERRNO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NAME_SYMBOL() {
  return getToken(MySQLParser::NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NAMES_SYMBOL() {
  return getToken(MySQLParser::NAMES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NATIONAL_SYMBOL() {
  return getToken(MySQLParser::NATIONAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NCHAR_SYMBOL() {
  return getToken(MySQLParser::NCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NDBCLUSTER_SYMBOL() {
  return getToken(MySQLParser::NDBCLUSTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NESTED_SYMBOL() {
  return getToken(MySQLParser::NESTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NEVER_SYMBOL() {
  return getToken(MySQLParser::NEVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NEXT_SYMBOL() {
  return getToken(MySQLParser::NEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NEW_SYMBOL() {
  return getToken(MySQLParser::NEW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NO_WAIT_SYMBOL() {
  return getToken(MySQLParser::NO_WAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NODEGROUP_SYMBOL() {
  return getToken(MySQLParser::NODEGROUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NULLS_SYMBOL() {
  return getToken(MySQLParser::NULLS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NOWAIT_SYMBOL() {
  return getToken(MySQLParser::NOWAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NUMBER_SYMBOL() {
  return getToken(MySQLParser::NUMBER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::NVARCHAR_SYMBOL() {
  return getToken(MySQLParser::NVARCHAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::OFFSET_SYMBOL() {
  return getToken(MySQLParser::OFFSET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::OLD_SYMBOL() {
  return getToken(MySQLParser::OLD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::OLD_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::OLD_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ONE_SYMBOL() {
  return getToken(MySQLParser::ONE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::OPTIONAL_SYMBOL() {
  return getToken(MySQLParser::OPTIONAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ORDINALITY_SYMBOL() {
  return getToken(MySQLParser::ORDINALITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ORGANIZATION_SYMBOL() {
  return getToken(MySQLParser::ORGANIZATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::OTHERS_SYMBOL() {
  return getToken(MySQLParser::OTHERS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PACK_KEYS_SYMBOL() {
  return getToken(MySQLParser::PACK_KEYS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PAGE_SYMBOL() {
  return getToken(MySQLParser::PAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PARTIAL_SYMBOL() {
  return getToken(MySQLParser::PARTIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PARTITIONING_SYMBOL() {
  return getToken(MySQLParser::PARTITIONING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PARTITIONS_SYMBOL() {
  return getToken(MySQLParser::PARTITIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PATH_SYMBOL() {
  return getToken(MySQLParser::PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PHASE_SYMBOL() {
  return getToken(MySQLParser::PHASE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PLUGIN_DIR_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_DIR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PLUGIN_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PLUGINS_SYMBOL() {
  return getToken(MySQLParser::PLUGINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::POINT_SYMBOL() {
  return getToken(MySQLParser::POINT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::POLYGON_SYMBOL() {
  return getToken(MySQLParser::POLYGON_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PRECEDING_SYMBOL() {
  return getToken(MySQLParser::PRECEDING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PRESERVE_SYMBOL() {
  return getToken(MySQLParser::PRESERVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PREV_SYMBOL() {
  return getToken(MySQLParser::PREV_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::THREAD_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::THREAD_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PROCESSLIST_SYMBOL() {
  return getToken(MySQLParser::PROCESSLIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PROFILE_SYMBOL() {
  return getToken(MySQLParser::PROFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::PROFILES_SYMBOL() {
  return getToken(MySQLParser::PROFILES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::QUARTER_SYMBOL() {
  return getToken(MySQLParser::QUARTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::QUICK_SYMBOL() {
  return getToken(MySQLParser::QUICK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::READ_ONLY_SYMBOL() {
  return getToken(MySQLParser::READ_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REBUILD_SYMBOL() {
  return getToken(MySQLParser::REBUILD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RECOVER_SYMBOL() {
  return getToken(MySQLParser::RECOVER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REDO_BUFFER_SIZE_SYMBOL() {
  return getToken(MySQLParser::REDO_BUFFER_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REDOFILE_SYMBOL() {
  return getToken(MySQLParser::REDOFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REDUNDANT_SYMBOL() {
  return getToken(MySQLParser::REDUNDANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RELAY_SYMBOL() {
  return getToken(MySQLParser::RELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RELAYLOG_SYMBOL() {
  return getToken(MySQLParser::RELAYLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RELAY_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RELAY_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_POS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RELAY_THREAD_SYMBOL() {
  return getToken(MySQLParser::RELAY_THREAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REMOTE_SYMBOL() {
  return getToken(MySQLParser::REMOTE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REORGANIZE_SYMBOL() {
  return getToken(MySQLParser::REORGANIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPEATABLE_SYMBOL() {
  return getToken(MySQLParser::REPEATABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_DO_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_DO_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_IGNORE_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_IGNORE_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_DO_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_DO_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_IGNORE_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_WILD_DO_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_WILD_IGNORE_TABLE_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REPLICATE_REWRITE_DB_SYMBOL() {
  return getToken(MySQLParser::REPLICATE_REWRITE_DB_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::USER_RESOURCES_SYMBOL() {
  return getToken(MySQLParser::USER_RESOURCES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RESPECT_SYMBOL() {
  return getToken(MySQLParser::RESPECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RESUME_SYMBOL() {
  return getToken(MySQLParser::RESUME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RETAIN_SYMBOL() {
  return getToken(MySQLParser::RETAIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RETURNED_SQLSTATE_SYMBOL() {
  return getToken(MySQLParser::RETURNED_SQLSTATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RETURNS_SYMBOL() {
  return getToken(MySQLParser::RETURNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REUSE_SYMBOL() {
  return getToken(MySQLParser::REUSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::REVERSE_SYMBOL() {
  return getToken(MySQLParser::REVERSE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROLLUP_SYMBOL() {
  return getToken(MySQLParser::ROLLUP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROTATE_SYMBOL() {
  return getToken(MySQLParser::ROTATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROUTINE_SYMBOL() {
  return getToken(MySQLParser::ROUTINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROW_COUNT_SYMBOL() {
  return getToken(MySQLParser::ROW_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROW_FORMAT_SYMBOL() {
  return getToken(MySQLParser::ROW_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::RTREE_SYMBOL() {
  return getToken(MySQLParser::RTREE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SCHEDULE_SYMBOL() {
  return getToken(MySQLParser::SCHEDULE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SCHEMA_NAME_SYMBOL() {
  return getToken(MySQLParser::SCHEMA_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SECOND_SYMBOL() {
  return getToken(MySQLParser::SECOND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SERIAL_SYMBOL() {
  return getToken(MySQLParser::SERIAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SERIALIZABLE_SYMBOL() {
  return getToken(MySQLParser::SERIALIZABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SESSION_SYMBOL() {
  return getToken(MySQLParser::SESSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SHARE_SYMBOL() {
  return getToken(MySQLParser::SHARE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SIMPLE_SYMBOL() {
  return getToken(MySQLParser::SIMPLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SKIP_SYMBOL() {
  return getToken(MySQLParser::SKIP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SLOW_SYMBOL() {
  return getToken(MySQLParser::SLOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SNAPSHOT_SYMBOL() {
  return getToken(MySQLParser::SNAPSHOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SOUNDS_SYMBOL() {
  return getToken(MySQLParser::SOUNDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SOURCE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_AFTER_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_AFTER_MTS_GAPS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_BEFORE_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_BEFORE_GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_CACHE_SYMBOL() {
  return getToken(MySQLParser::SQL_CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_BUFFER_RESULT_SYMBOL() {
  return getToken(MySQLParser::SQL_BUFFER_RESULT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_NO_CACHE_SYMBOL() {
  return getToken(MySQLParser::SQL_NO_CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SQL_THREAD_SYMBOL() {
  return getToken(MySQLParser::SQL_THREAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SRID_SYMBOL() {
  return getToken(MySQLParser::SRID_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STACKED_SYMBOL() {
  return getToken(MySQLParser::STACKED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STARTS_SYMBOL() {
  return getToken(MySQLParser::STARTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STATS_AUTO_RECALC_SYMBOL() {
  return getToken(MySQLParser::STATS_AUTO_RECALC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STATS_PERSISTENT_SYMBOL() {
  return getToken(MySQLParser::STATS_PERSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STATS_SAMPLE_PAGES_SYMBOL() {
  return getToken(MySQLParser::STATS_SAMPLE_PAGES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::STRING_SYMBOL() {
  return getToken(MySQLParser::STRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUBCLASS_ORIGIN_SYMBOL() {
  return getToken(MySQLParser::SUBCLASS_ORIGIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUBDATE_SYMBOL() {
  return getToken(MySQLParser::SUBDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUBJECT_SYMBOL() {
  return getToken(MySQLParser::SUBJECT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUBPARTITION_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUBPARTITIONS_SYMBOL() {
  return getToken(MySQLParser::SUBPARTITIONS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUPER_SYMBOL() {
  return getToken(MySQLParser::SUPER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SUSPEND_SYMBOL() {
  return getToken(MySQLParser::SUSPEND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SWAPS_SYMBOL() {
  return getToken(MySQLParser::SWAPS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SWITCHES_SYMBOL() {
  return getToken(MySQLParser::SWITCHES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TABLE_NAME_SYMBOL() {
  return getToken(MySQLParser::TABLE_NAME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TABLE_CHECKSUM_SYMBOL() {
  return getToken(MySQLParser::TABLE_CHECKSUM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TABLESPACE_SYMBOL() {
  return getToken(MySQLParser::TABLESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TEMPORARY_SYMBOL() {
  return getToken(MySQLParser::TEMPORARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TEMPTABLE_SYMBOL() {
  return getToken(MySQLParser::TEMPTABLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TEXT_SYMBOL() {
  return getToken(MySQLParser::TEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::THAN_SYMBOL() {
  return getToken(MySQLParser::THAN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TIES_SYMBOL() {
  return getToken(MySQLParser::TIES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TRANSACTION_SYMBOL() {
  return getToken(MySQLParser::TRANSACTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TRIGGERS_SYMBOL() {
  return getToken(MySQLParser::TRIGGERS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TIMESTAMP_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TIMESTAMPADD_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMPADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TIMESTAMPDIFF_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMPDIFF_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TIME_SYMBOL() {
  return getToken(MySQLParser::TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TYPES_SYMBOL() {
  return getToken(MySQLParser::TYPES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TYPE_SYMBOL() {
  return getToken(MySQLParser::TYPE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UDF_RETURNS_SYMBOL() {
  return getToken(MySQLParser::UDF_RETURNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNBOUNDED_SYMBOL() {
  return getToken(MySQLParser::UNBOUNDED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNCOMMITTED_SYMBOL() {
  return getToken(MySQLParser::UNCOMMITTED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNDEFINED_SYMBOL() {
  return getToken(MySQLParser::UNDEFINED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNDO_BUFFER_SIZE_SYMBOL() {
  return getToken(MySQLParser::UNDO_BUFFER_SIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNDOFILE_SYMBOL() {
  return getToken(MySQLParser::UNDOFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNKNOWN_SYMBOL() {
  return getToken(MySQLParser::UNKNOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::UNTIL_SYMBOL() {
  return getToken(MySQLParser::UNTIL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::USE_FRM_SYMBOL() {
  return getToken(MySQLParser::USE_FRM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::VARIABLES_SYMBOL() {
  return getToken(MySQLParser::VARIABLES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::VCPU_SYMBOL() {
  return getToken(MySQLParser::VCPU_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::VALUE_SYMBOL() {
  return getToken(MySQLParser::VALUE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::WARNINGS_SYMBOL() {
  return getToken(MySQLParser::WARNINGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::WAIT_SYMBOL() {
  return getToken(MySQLParser::WAIT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::WEEK_SYMBOL() {
  return getToken(MySQLParser::WEEK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::WORK_SYMBOL() {
  return getToken(MySQLParser::WORK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::WEIGHT_STRING_SYMBOL() {
  return getToken(MySQLParser::WEIGHT_STRING_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::X509_SYMBOL() {
  return getToken(MySQLParser::X509_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::XID_SYMBOL() {
  return getToken(MySQLParser::XID_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::XML_SYMBOL() {
  return getToken(MySQLParser::XML_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::YEAR_SYMBOL() {
  return getToken(MySQLParser::YEAR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::SHUTDOWN_SYMBOL() {
  return getToken(MySQLParser::SHUTDOWN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::CUBE_SYMBOL() {
  return getToken(MySQLParser::CUBE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::IMPORT_SYMBOL() {
  return getToken(MySQLParser::IMPORT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::FUNCTION_SYMBOL() {
  return getToken(MySQLParser::FUNCTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROWS_SYMBOL() {
  return getToken(MySQLParser::ROWS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ROW_SYMBOL() {
  return getToken(MySQLParser::ROW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXCHANGE_SYMBOL() {
  return getToken(MySQLParser::EXCHANGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::EXPIRE_SYMBOL() {
  return getToken(MySQLParser::EXPIRE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ONLY_SYMBOL() {
  return getToken(MySQLParser::ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::VALIDATION_SYMBOL() {
  return getToken(MySQLParser::VALIDATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::WITHOUT_SYMBOL() {
  return getToken(MySQLParser::WITHOUT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::ADMIN_SYMBOL() {
  return getToken(MySQLParser::ADMIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::MASTER_SERVER_ID_SYMBOL() {
  return getToken(MySQLParser::MASTER_SERVER_ID_SYMBOL, 0);
}


size_t MySQLParser::RoleOrLabelKeywordContext::getRuleIndex() const {
  return MySQLParser::RuleRoleOrLabelKeyword;
}

void MySQLParser::RoleOrLabelKeywordContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleOrLabelKeyword(this);
}

void MySQLParser::RoleOrLabelKeywordContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleOrLabelKeyword(this);
}


std::any MySQLParser::RoleOrLabelKeywordContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleOrLabelKeyword(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleOrLabelKeywordContext* MySQLParser::roleOrLabelKeyword() {
  RoleOrLabelKeywordContext *_localctx = _tracker.createInstance<RoleOrLabelKeywordContext>(_ctx, getState());
  enterRule(_localctx, 1526, MySQLParser::RuleRoleOrLabelKeyword);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(9686);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1217, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(9675);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << MySQLParser::ACTION_SYMBOL)
        | (1ULL << MySQLParser::ADDDATE_SYMBOL)
        | (1ULL << MySQLParser::AFTER_SYMBOL)
        | (1ULL << MySQLParser::AGAINST_SYMBOL)
        | (1ULL << MySQLParser::AGGREGATE_SYMBOL)
        | (1ULL << MySQLParser::ALGORITHM_SYMBOL)
        | (1ULL << MySQLParser::ANALYSE_SYMBOL)
        | (1ULL << MySQLParser::ANY_SYMBOL))) != 0) || ((((_la - 67) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 67)) & ((1ULL << (MySQLParser::AT_SYMBOL - 67))
        | (1ULL << (MySQLParser::AUTOEXTEND_SIZE_SYMBOL - 67))
        | (1ULL << (MySQLParser::AUTO_INCREMENT_SYMBOL - 67))
        | (1ULL << (MySQLParser::AVG_ROW_LENGTH_SYMBOL - 67))
        | (1ULL << (MySQLParser::AVG_SYMBOL - 67))
        | (1ULL << (MySQLParser::BINLOG_SYMBOL - 67))
        | (1ULL << (MySQLParser::BIT_SYMBOL - 67))
        | (1ULL << (MySQLParser::BLOCK_SYMBOL - 67))
        | (1ULL << (MySQLParser::BOOLEAN_SYMBOL - 67))
        | (1ULL << (MySQLParser::BOOL_SYMBOL - 67))
        | (1ULL << (MySQLParser::BTREE_SYMBOL - 67))
        | (1ULL << (MySQLParser::CASCADED_SYMBOL - 67))
        | (1ULL << (MySQLParser::CATALOG_NAME_SYMBOL - 67))
        | (1ULL << (MySQLParser::CHAIN_SYMBOL - 67))
        | (1ULL << (MySQLParser::CHANGED_SYMBOL - 67))
        | (1ULL << (MySQLParser::CHANNEL_SYMBOL - 67))
        | (1ULL << (MySQLParser::CIPHER_SYMBOL - 67))
        | (1ULL << (MySQLParser::CLASS_ORIGIN_SYMBOL - 67))
        | (1ULL << (MySQLParser::CLIENT_SYMBOL - 67))
        | (1ULL << (MySQLParser::COALESCE_SYMBOL - 67))
        | (1ULL << (MySQLParser::CODE_SYMBOL - 67))
        | (1ULL << (MySQLParser::COLLATION_SYMBOL - 67))
        | (1ULL << (MySQLParser::COLUMNS_SYMBOL - 67))
        | (1ULL << (MySQLParser::COLUMN_NAME_SYMBOL - 67))
        | (1ULL << (MySQLParser::COLUMN_FORMAT_SYMBOL - 67))
        | (1ULL << (MySQLParser::COMMITTED_SYMBOL - 67))
        | (1ULL << (MySQLParser::COMPACT_SYMBOL - 67))
        | (1ULL << (MySQLParser::COMPLETION_SYMBOL - 67))
        | (1ULL << (MySQLParser::COMPRESSED_SYMBOL - 67))
        | (1ULL << (MySQLParser::COMPRESSION_SYMBOL - 67))
        | (1ULL << (MySQLParser::CONCURRENT_SYMBOL - 67))
        | (1ULL << (MySQLParser::CONNECTION_SYMBOL - 67))
        | (1ULL << (MySQLParser::CONSISTENT_SYMBOL - 67)))) != 0) || ((((_la - 131) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 131)) & ((1ULL << (MySQLParser::CONSTRAINT_CATALOG_SYMBOL - 131))
        | (1ULL << (MySQLParser::CONSTRAINT_NAME_SYMBOL - 131))
        | (1ULL << (MySQLParser::CONSTRAINT_SCHEMA_SYMBOL - 131))
        | (1ULL << (MySQLParser::CONTEXT_SYMBOL - 131))
        | (1ULL << (MySQLParser::CPU_SYMBOL - 131))
        | (1ULL << (MySQLParser::CURRENT_SYMBOL - 131))
        | (1ULL << (MySQLParser::CURSOR_NAME_SYMBOL - 131))
        | (1ULL << (MySQLParser::DATAFILE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DATA_SYMBOL - 131))
        | (1ULL << (MySQLParser::DATETIME_SYMBOL - 131))
        | (1ULL << (MySQLParser::DATE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DAY_SYMBOL - 131))
        | (1ULL << (MySQLParser::DEFAULT_AUTH_SYMBOL - 131))
        | (1ULL << (MySQLParser::DEFINER_SYMBOL - 131))
        | (1ULL << (MySQLParser::DELAY_KEY_WRITE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DES_KEY_FILE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DIAGNOSTICS_SYMBOL - 131))
        | (1ULL << (MySQLParser::DIRECTORY_SYMBOL - 131))
        | (1ULL << (MySQLParser::DISABLE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DISCARD_SYMBOL - 131))
        | (1ULL << (MySQLParser::DISK_SYMBOL - 131))
        | (1ULL << (MySQLParser::DUMPFILE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DUPLICATE_SYMBOL - 131))
        | (1ULL << (MySQLParser::DYNAMIC_SYMBOL - 131)))) != 0) || ((((_la - 195) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 195)) & ((1ULL << (MySQLParser::ENABLE_SYMBOL - 195))
        | (1ULL << (MySQLParser::ENCRYPTION_SYMBOL - 195))
        | (1ULL << (MySQLParser::ENDS_SYMBOL - 195))
        | (1ULL << (MySQLParser::ENGINES_SYMBOL - 195))
        | (1ULL << (MySQLParser::ENGINE_SYMBOL - 195))
        | (1ULL << (MySQLParser::ENUM_SYMBOL - 195))
        | (1ULL << (MySQLParser::ERROR_SYMBOL - 195))
        | (1ULL << (MySQLParser::ERRORS_SYMBOL - 195))
        | (1ULL << (MySQLParser::ESCAPE_SYMBOL - 195))
        | (1ULL << (MySQLParser::EVENTS_SYMBOL - 195))
        | (1ULL << (MySQLParser::EVERY_SYMBOL - 195))
        | (1ULL << (MySQLParser::EXPANSION_SYMBOL - 195))
        | (1ULL << (MySQLParser::EXPORT_SYMBOL - 195))
        | (1ULL << (MySQLParser::EXTENDED_SYMBOL - 195))
        | (1ULL << (MySQLParser::EXTENT_SIZE_SYMBOL - 195))
        | (1ULL << (MySQLParser::FAST_SYMBOL - 195))
        | (1ULL << (MySQLParser::FAULTS_SYMBOL - 195))
        | (1ULL << (MySQLParser::FILE_BLOCK_SIZE_SYMBOL - 195))
        | (1ULL << (MySQLParser::FILTER_SYMBOL - 195))
        | (1ULL << (MySQLParser::FIRST_SYMBOL - 195))
        | (1ULL << (MySQLParser::FIXED_SYMBOL - 195))
        | (1ULL << (MySQLParser::FOUND_SYMBOL - 195))
        | (1ULL << (MySQLParser::FULL_SYMBOL - 195))
        | (1ULL << (MySQLParser::GENERAL_SYMBOL - 195))
        | (1ULL << (MySQLParser::GEOMETRYCOLLECTION_SYMBOL - 195))
        | (1ULL << (MySQLParser::GEOMETRY_SYMBOL - 195))
        | (1ULL << (MySQLParser::GET_FORMAT_SYMBOL - 195))
        | (1ULL << (MySQLParser::GLOBAL_SYMBOL - 195))
        | (1ULL << (MySQLParser::GRANTS_SYMBOL - 195))
        | (1ULL << (MySQLParser::HASH_SYMBOL - 195)))) != 0) || ((((_la - 261) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 261)) & ((1ULL << (MySQLParser::HOSTS_SYMBOL - 261))
        | (1ULL << (MySQLParser::HOUR_SYMBOL - 261))
        | (1ULL << (MySQLParser::IDENTIFIED_SYMBOL - 261))
        | (1ULL << (MySQLParser::IGNORE_SERVER_IDS_SYMBOL - 261))
        | (1ULL << (MySQLParser::INDEXES_SYMBOL - 261))
        | (1ULL << (MySQLParser::INITIAL_SIZE_SYMBOL - 261))
        | (1ULL << (MySQLParser::INSERT_METHOD_SYMBOL - 261))
        | (1ULL << (MySQLParser::INSTANCE_SYMBOL - 261))
        | (1ULL << (MySQLParser::INVOKER_SYMBOL - 261))
        | (1ULL << (MySQLParser::IO_SYMBOL - 261))
        | (1ULL << (MySQLParser::IPC_SYMBOL - 261))
        | (1ULL << (MySQLParser::ISOLATION_SYMBOL - 261))
        | (1ULL << (MySQLParser::ISSUER_SYMBOL - 261))
        | (1ULL << (MySQLParser::JSON_SYMBOL - 261))
        | (1ULL << (MySQLParser::KEY_BLOCK_SIZE_SYMBOL - 261))
        | (1ULL << (MySQLParser::LAST_SYMBOL - 261))
        | (1ULL << (MySQLParser::LEAVES_SYMBOL - 261))
        | (1ULL << (MySQLParser::LESS_SYMBOL - 261))
        | (1ULL << (MySQLParser::LEVEL_SYMBOL - 261))
        | (1ULL << (MySQLParser::LINESTRING_SYMBOL - 261))
        | (1ULL << (MySQLParser::LIST_SYMBOL - 261))
        | (1ULL << (MySQLParser::LOCAL_SYMBOL - 261))
        | (1ULL << (MySQLParser::LOCKS_SYMBOL - 261))
        | (1ULL << (MySQLParser::LOGFILE_SYMBOL - 261))
        | (1ULL << (MySQLParser::LOGS_SYMBOL - 261)))) != 0) || ((((_la - 328) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 328)) & ((1ULL << (MySQLParser::MASTER_AUTO_POSITION_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_CONNECT_RETRY_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_DELAY_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_HOST_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_LOG_FILE_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_LOG_POS_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_PASSWORD_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_PORT_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_RETRY_COUNT_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_CAPATH_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_CA_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_CERT_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_CIPHER_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_CRL_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_CRLPATH_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_KEY_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SSL_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_TLS_VERSION_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_USER_SYMBOL - 328))
        | (1ULL << (MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_ROWS_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_SIZE_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_STATEMENT_TIME_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL - 328))
        | (1ULL << (MySQLParser::MAX_USER_CONNECTIONS_SYMBOL - 328))
        | (1ULL << (MySQLParser::MEDIUM_SYMBOL - 328))
        | (1ULL << (MySQLParser::MEMORY_SYMBOL - 328))
        | (1ULL << (MySQLParser::MERGE_SYMBOL - 328))
        | (1ULL << (MySQLParser::MESSAGE_TEXT_SYMBOL - 328))
        | (1ULL << (MySQLParser::MICROSECOND_SYMBOL - 328))
        | (1ULL << (MySQLParser::MIGRATE_SYMBOL - 328))
        | (1ULL << (MySQLParser::MINUTE_SYMBOL - 328))
        | (1ULL << (MySQLParser::MIN_ROWS_SYMBOL - 328))
        | (1ULL << (MySQLParser::MODE_SYMBOL - 328))
        | (1ULL << (MySQLParser::MODIFY_SYMBOL - 328))
        | (1ULL << (MySQLParser::MONTH_SYMBOL - 328))
        | (1ULL << (MySQLParser::MULTILINESTRING_SYMBOL - 328))
        | (1ULL << (MySQLParser::MULTIPOINT_SYMBOL - 328))
        | (1ULL << (MySQLParser::MULTIPOLYGON_SYMBOL - 328))
        | (1ULL << (MySQLParser::MUTEX_SYMBOL - 328))
        | (1ULL << (MySQLParser::MYSQL_ERRNO_SYMBOL - 328))
        | (1ULL << (MySQLParser::NAMES_SYMBOL - 328))
        | (1ULL << (MySQLParser::NAME_SYMBOL - 328))
        | (1ULL << (MySQLParser::NATIONAL_SYMBOL - 328)))) != 0) || ((((_la - 392) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 392)) & ((1ULL << (MySQLParser::NCHAR_SYMBOL - 392))
        | (1ULL << (MySQLParser::NDBCLUSTER_SYMBOL - 392))
        | (1ULL << (MySQLParser::NEVER_SYMBOL - 392))
        | (1ULL << (MySQLParser::NEW_SYMBOL - 392))
        | (1ULL << (MySQLParser::NEXT_SYMBOL - 392))
        | (1ULL << (MySQLParser::NODEGROUP_SYMBOL - 392))
        | (1ULL << (MySQLParser::NO_WAIT_SYMBOL - 392))
        | (1ULL << (MySQLParser::NUMBER_SYMBOL - 392))
        | (1ULL << (MySQLParser::NVARCHAR_SYMBOL - 392))
        | (1ULL << (MySQLParser::OFFSET_SYMBOL - 392))
        | (1ULL << (MySQLParser::OLD_PASSWORD_SYMBOL - 392))
        | (1ULL << (MySQLParser::ONE_SYMBOL - 392))
        | (1ULL << (MySQLParser::PACK_KEYS_SYMBOL - 392))
        | (1ULL << (MySQLParser::PAGE_SYMBOL - 392))
        | (1ULL << (MySQLParser::PARTIAL_SYMBOL - 392))
        | (1ULL << (MySQLParser::PARTITIONING_SYMBOL - 392))
        | (1ULL << (MySQLParser::PARTITIONS_SYMBOL - 392))
        | (1ULL << (MySQLParser::PASSWORD_SYMBOL - 392))
        | (1ULL << (MySQLParser::PHASE_SYMBOL - 392))
        | (1ULL << (MySQLParser::PLUGINS_SYMBOL - 392))
        | (1ULL << (MySQLParser::PLUGIN_DIR_SYMBOL - 392))
        | (1ULL << (MySQLParser::PLUGIN_SYMBOL - 392))
        | (1ULL << (MySQLParser::POINT_SYMBOL - 392))
        | (1ULL << (MySQLParser::POLYGON_SYMBOL - 392))
        | (1ULL << (MySQLParser::PRESERVE_SYMBOL - 392))
        | (1ULL << (MySQLParser::PREV_SYMBOL - 392))
        | (1ULL << (MySQLParser::PRIVILEGES_SYMBOL - 392))
        | (1ULL << (MySQLParser::PROCESSLIST_SYMBOL - 392))
        | (1ULL << (MySQLParser::PROFILE_SYMBOL - 392)))) != 0) || ((((_la - 456) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 456)) & ((1ULL << (MySQLParser::PROFILES_SYMBOL - 456))
        | (1ULL << (MySQLParser::QUARTER_SYMBOL - 456))
        | (1ULL << (MySQLParser::QUERY_SYMBOL - 456))
        | (1ULL << (MySQLParser::QUICK_SYMBOL - 456))
        | (1ULL << (MySQLParser::READ_ONLY_SYMBOL - 456))
        | (1ULL << (MySQLParser::REBUILD_SYMBOL - 456))
        | (1ULL << (MySQLParser::RECOVER_SYMBOL - 456))
        | (1ULL << (MySQLParser::REDOFILE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REDO_BUFFER_SIZE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REDUNDANT_SYMBOL - 456))
        | (1ULL << (MySQLParser::RELAY_SYMBOL - 456))
        | (1ULL << (MySQLParser::RELAYLOG_SYMBOL - 456))
        | (1ULL << (MySQLParser::RELAY_LOG_FILE_SYMBOL - 456))
        | (1ULL << (MySQLParser::RELAY_LOG_POS_SYMBOL - 456))
        | (1ULL << (MySQLParser::RELAY_THREAD_SYMBOL - 456))
        | (1ULL << (MySQLParser::REORGANIZE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPEATABLE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_DO_DB_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_IGNORE_DB_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_DO_TABLE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL - 456))
        | (1ULL << (MySQLParser::REPLICATE_REWRITE_DB_SYMBOL - 456))
        | (1ULL << (MySQLParser::RESUME_SYMBOL - 456))
        | (1ULL << (MySQLParser::RETURNED_SQLSTATE_SYMBOL - 456))
        | (1ULL << (MySQLParser::RETURNS_SYMBOL - 456))
        | (1ULL << (MySQLParser::REVERSE_SYMBOL - 456))
        | (1ULL << (MySQLParser::ROLLUP_SYMBOL - 456))
        | (1ULL << (MySQLParser::ROTATE_SYMBOL - 456))
        | (1ULL << (MySQLParser::ROUTINE_SYMBOL - 456))
        | (1ULL << (MySQLParser::ROW_COUNT_SYMBOL - 456))
        | (1ULL << (MySQLParser::ROW_FORMAT_SYMBOL - 456))
        | (1ULL << (MySQLParser::RTREE_SYMBOL - 456))
        | (1ULL << (MySQLParser::SCHEDULE_SYMBOL - 456)))) != 0) || ((((_la - 520) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 520)) & ((1ULL << (MySQLParser::SCHEMA_NAME_SYMBOL - 520))
        | (1ULL << (MySQLParser::SECOND_SYMBOL - 520))
        | (1ULL << (MySQLParser::SERIALIZABLE_SYMBOL - 520))
        | (1ULL << (MySQLParser::SERIAL_SYMBOL - 520))
        | (1ULL << (MySQLParser::SESSION_SYMBOL - 520))
        | (1ULL << (MySQLParser::SHARE_SYMBOL - 520))
        | (1ULL << (MySQLParser::SIMPLE_SYMBOL - 520))
        | (1ULL << (MySQLParser::SLOW_SYMBOL - 520))
        | (1ULL << (MySQLParser::SNAPSHOT_SYMBOL - 520))
        | (1ULL << (MySQLParser::SOUNDS_SYMBOL - 520))
        | (1ULL << (MySQLParser::SOURCE_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_AFTER_GTIDS_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_BEFORE_GTIDS_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_BUFFER_RESULT_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_CACHE_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_NO_CACHE_SYMBOL - 520))
        | (1ULL << (MySQLParser::SQL_THREAD_SYMBOL - 520))
        | (1ULL << (MySQLParser::STACKED_SYMBOL - 520))
        | (1ULL << (MySQLParser::STARTS_SYMBOL - 520))
        | (1ULL << (MySQLParser::STATS_AUTO_RECALC_SYMBOL - 520))
        | (1ULL << (MySQLParser::STATS_PERSISTENT_SYMBOL - 520))
        | (1ULL << (MySQLParser::STATS_SAMPLE_PAGES_SYMBOL - 520))
        | (1ULL << (MySQLParser::STATUS_SYMBOL - 520))
        | (1ULL << (MySQLParser::STORAGE_SYMBOL - 520))
        | (1ULL << (MySQLParser::STRING_SYMBOL - 520))
        | (1ULL << (MySQLParser::SUBCLASS_ORIGIN_SYMBOL - 520)))) != 0) || ((((_la - 584) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 584)) & ((1ULL << (MySQLParser::SUBDATE_SYMBOL - 584))
        | (1ULL << (MySQLParser::SUBJECT_SYMBOL - 584))
        | (1ULL << (MySQLParser::SUBPARTITIONS_SYMBOL - 584))
        | (1ULL << (MySQLParser::SUBPARTITION_SYMBOL - 584))
        | (1ULL << (MySQLParser::SUPER_SYMBOL - 584))
        | (1ULL << (MySQLParser::SUSPEND_SYMBOL - 584))
        | (1ULL << (MySQLParser::SWAPS_SYMBOL - 584))
        | (1ULL << (MySQLParser::SWITCHES_SYMBOL - 584))
        | (1ULL << (MySQLParser::TABLES_SYMBOL - 584))
        | (1ULL << (MySQLParser::TABLESPACE_SYMBOL - 584))
        | (1ULL << (MySQLParser::TABLE_CHECKSUM_SYMBOL - 584))
        | (1ULL << (MySQLParser::TABLE_NAME_SYMBOL - 584))
        | (1ULL << (MySQLParser::TEMPORARY_SYMBOL - 584))
        | (1ULL << (MySQLParser::TEMPTABLE_SYMBOL - 584))
        | (1ULL << (MySQLParser::TEXT_SYMBOL - 584))
        | (1ULL << (MySQLParser::THAN_SYMBOL - 584))
        | (1ULL << (MySQLParser::TIMESTAMP_SYMBOL - 584))
        | (1ULL << (MySQLParser::TIMESTAMPADD_SYMBOL - 584))
        | (1ULL << (MySQLParser::TIMESTAMPDIFF_SYMBOL - 584))
        | (1ULL << (MySQLParser::TIME_SYMBOL - 584))
        | (1ULL << (MySQLParser::TRANSACTION_SYMBOL - 584))
        | (1ULL << (MySQLParser::TRIGGERS_SYMBOL - 584))
        | (1ULL << (MySQLParser::TYPES_SYMBOL - 584))
        | (1ULL << (MySQLParser::TYPE_SYMBOL - 584))
        | (1ULL << (MySQLParser::UDF_RETURNS_SYMBOL - 584))
        | (1ULL << (MySQLParser::UNCOMMITTED_SYMBOL - 584))
        | (1ULL << (MySQLParser::UNDEFINED_SYMBOL - 584))
        | (1ULL << (MySQLParser::UNDOFILE_SYMBOL - 584))
        | (1ULL << (MySQLParser::UNDO_BUFFER_SIZE_SYMBOL - 584))
        | (1ULL << (MySQLParser::UNKNOWN_SYMBOL - 584))
        | (1ULL << (MySQLParser::UNTIL_SYMBOL - 584))
        | (1ULL << (MySQLParser::USER_RESOURCES_SYMBOL - 584))
        | (1ULL << (MySQLParser::USER_SYMBOL - 584))
        | (1ULL << (MySQLParser::USE_FRM_SYMBOL - 584)))) != 0) || ((((_la - 653) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 653)) & ((1ULL << (MySQLParser::VALUE_SYMBOL - 653))
        | (1ULL << (MySQLParser::VARIABLES_SYMBOL - 653))
        | (1ULL << (MySQLParser::VIEW_SYMBOL - 653))
        | (1ULL << (MySQLParser::WAIT_SYMBOL - 653))
        | (1ULL << (MySQLParser::WARNINGS_SYMBOL - 653))
        | (1ULL << (MySQLParser::WEEK_SYMBOL - 653))
        | (1ULL << (MySQLParser::WEIGHT_STRING_SYMBOL - 653))
        | (1ULL << (MySQLParser::WORK_SYMBOL - 653))
        | (1ULL << (MySQLParser::X509_SYMBOL - 653))
        | (1ULL << (MySQLParser::XID_SYMBOL - 653))
        | (1ULL << (MySQLParser::XML_SYMBOL - 653))
        | (1ULL << (MySQLParser::YEAR_SYMBOL - 653))
        | (1ULL << (MySQLParser::COMPONENT_SYMBOL - 653))
        | (1ULL << (MySQLParser::SKIP_SYMBOL - 653))
        | (1ULL << (MySQLParser::LOCKED_SYMBOL - 653))
        | (1ULL << (MySQLParser::NOWAIT_SYMBOL - 653))
        | (1ULL << (MySQLParser::HISTOGRAM_SYMBOL - 653))
        | (1ULL << (MySQLParser::BUCKETS_SYMBOL - 653))
        | (1ULL << (MySQLParser::REMOTE_SYMBOL - 653))
        | (1ULL << (MySQLParser::EXCLUDE_SYMBOL - 653))
        | (1ULL << (MySQLParser::FOLLOWING_SYMBOL - 653))
        | (1ULL << (MySQLParser::NULLS_SYMBOL - 653))
        | (1ULL << (MySQLParser::OTHERS_SYMBOL - 653)))) != 0) || ((((_la - 718) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 718)) & ((1ULL << (MySQLParser::PRECEDING_SYMBOL - 718))
        | (1ULL << (MySQLParser::RESPECT_SYMBOL - 718))
        | (1ULL << (MySQLParser::TIES_SYMBOL - 718))
        | (1ULL << (MySQLParser::UNBOUNDED_SYMBOL - 718))
        | (1ULL << (MySQLParser::NESTED_SYMBOL - 718))
        | (1ULL << (MySQLParser::ORDINALITY_SYMBOL - 718))
        | (1ULL << (MySQLParser::PATH_SYMBOL - 718))
        | (1ULL << (MySQLParser::HISTORY_SYMBOL - 718))
        | (1ULL << (MySQLParser::REUSE_SYMBOL - 718))
        | (1ULL << (MySQLParser::SRID_SYMBOL - 718))
        | (1ULL << (MySQLParser::THREAD_PRIORITY_SYMBOL - 718))
        | (1ULL << (MySQLParser::VCPU_SYMBOL - 718))
        | (1ULL << (MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL - 718))
        | (1ULL << (MySQLParser::DESCRIPTION_SYMBOL - 718))
        | (1ULL << (MySQLParser::ORGANIZATION_SYMBOL - 718))
        | (1ULL << (MySQLParser::OPTIONAL_SYMBOL - 718))
        | (1ULL << (MySQLParser::ACTIVE_SYMBOL - 718))
        | (1ULL << (MySQLParser::INACTIVE_SYMBOL - 718))
        | (1ULL << (MySQLParser::RETAIN_SYMBOL - 718))
        | (1ULL << (MySQLParser::OLD_SYMBOL - 718))
        | (1ULL << (MySQLParser::ENGINE_ATTRIBUTE_SYMBOL - 718)))) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(9676);

      if (!(serverVersion < 50709)) throw FailedPredicateException(this, "serverVersion < 50709");
      setState(9677);
      match(MySQLParser::SHUTDOWN_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(9678);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(9679);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CUBE_SYMBOL || _la == MySQLParser::FUNCTION_SYMBOL

      || _la == MySQLParser::IMPORT_SYMBOL || _la == MySQLParser::ROWS_SYMBOL

      || _la == MySQLParser::ROW_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(9680);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(9681);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::EXCHANGE_SYMBOL

      || _la == MySQLParser::EXPIRE_SYMBOL || _la == MySQLParser::ONLY_SYMBOL || _la == MySQLParser::SUPER_SYMBOL

      || _la == MySQLParser::VALIDATION_SYMBOL || _la == MySQLParser::WITHOUT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(9682);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(9683);
      match(MySQLParser::ADMIN_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(9684);

      if (!(serverVersion < 80024)) throw FailedPredicateException(this, "serverVersion < 80024");
      setState(9685);
      match(MySQLParser::MASTER_SERVER_ID_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

bool MySQLParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 1: return simpleStatementSempred(antlrcpp::downCast<SimpleStatementContext *>(context), predicateIndex);
    case 2: return alterStatementSempred(antlrcpp::downCast<AlterStatementContext *>(context), predicateIndex);
    case 3: return alterDatabaseSempred(antlrcpp::downCast<AlterDatabaseContext *>(context), predicateIndex);
    case 14: return standaloneAlterCommandsSempred(antlrcpp::downCast<StandaloneAlterCommandsContext *>(context), predicateIndex);
    case 15: return alterPartitionSempred(antlrcpp::downCast<AlterPartitionContext *>(context), predicateIndex);
    case 18: return alterListItemSempred(antlrcpp::downCast<AlterListItemContext *>(context), predicateIndex);
    case 25: return withValidationSempred(antlrcpp::downCast<WithValidationContext *>(context), predicateIndex);
    case 28: return alterTablespaceSempred(antlrcpp::downCast<AlterTablespaceContext *>(context), predicateIndex);
    case 33: return alterTablespaceOptionSempred(antlrcpp::downCast<AlterTablespaceOptionContext *>(context), predicateIndex);
    case 39: return alterInstanceStatementSempred(antlrcpp::downCast<AlterInstanceStatementContext *>(context), predicateIndex);
    case 40: return createStatementSempred(antlrcpp::downCast<CreateStatementContext *>(context), predicateIndex);
    case 42: return createDatabaseOptionSempred(antlrcpp::downCast<CreateDatabaseOptionContext *>(context), predicateIndex);
    case 51: return createProcedureSempred(antlrcpp::downCast<CreateProcedureContext *>(context), predicateIndex);
    case 53: return storedRoutineBodySempred(antlrcpp::downCast<StoredRoutineBodyContext *>(context), predicateIndex);
    case 54: return createFunctionSempred(antlrcpp::downCast<CreateFunctionContext *>(context), predicateIndex);
    case 55: return createUdfSempred(antlrcpp::downCast<CreateUdfContext *>(context), predicateIndex);
    case 56: return routineCreateOptionSempred(antlrcpp::downCast<RoutineCreateOptionContext *>(context), predicateIndex);
    case 60: return routineOptionSempred(antlrcpp::downCast<RoutineOptionContext *>(context), predicateIndex);
    case 73: return tsDataFileNameSempred(antlrcpp::downCast<TsDataFileNameContext *>(context), predicateIndex);
    case 76: return tablespaceOptionSempred(antlrcpp::downCast<TablespaceOptionContext *>(context), predicateIndex);
    case 89: return createViewSempred(antlrcpp::downCast<CreateViewContext *>(context), predicateIndex);
    case 93: return createTriggerSempred(antlrcpp::downCast<CreateTriggerContext *>(context), predicateIndex);
    case 99: return dropStatementSempred(antlrcpp::downCast<DropStatementContext *>(context), predicateIndex);
    case 121: return deleteStatementSempred(antlrcpp::downCast<DeleteStatementContext *>(context), predicateIndex);
    case 124: return doStatementSempred(antlrcpp::downCast<DoStatementContext *>(context), predicateIndex);
    case 135: return valuesReferenceSempred(antlrcpp::downCast<ValuesReferenceContext *>(context), predicateIndex);
    case 137: return loadStatementSempred(antlrcpp::downCast<LoadStatementContext *>(context), predicateIndex);
    case 140: return loadFromSempred(antlrcpp::downCast<LoadFromContext *>(context), predicateIndex);
    case 141: return loadSourceTypeSempred(antlrcpp::downCast<LoadSourceTypeContext *>(context), predicateIndex);
    case 142: return sourceCountSempred(antlrcpp::downCast<SourceCountContext *>(context), predicateIndex);
    case 143: return sourceOrderSempred(antlrcpp::downCast<SourceOrderContext *>(context), predicateIndex);
    case 148: return loadAlgorithmSempred(antlrcpp::downCast<LoadAlgorithmContext *>(context), predicateIndex);
    case 149: return compressionAlgorithmSempred(antlrcpp::downCast<CompressionAlgorithmContext *>(context), predicateIndex);
    case 150: return loadParallelSempred(antlrcpp::downCast<LoadParallelContext *>(context), predicateIndex);
    case 151: return loadMemorySempred(antlrcpp::downCast<LoadMemoryContext *>(context), predicateIndex);
    case 154: return selectStatementWithIntoSempred(antlrcpp::downCast<SelectStatementWithIntoContext *>(context), predicateIndex);
    case 155: return queryExpressionSempred(antlrcpp::downCast<QueryExpressionContext *>(context), predicateIndex);
    case 156: return queryExpressionBodySempred(antlrcpp::downCast<QueryExpressionBodyContext *>(context), predicateIndex);
    case 158: return queryPrimarySempred(antlrcpp::downCast<QueryPrimaryContext *>(context), predicateIndex);
    case 159: return querySpecificationSempred(antlrcpp::downCast<QuerySpecificationContext *>(context), predicateIndex);
    case 170: return intoClauseSempred(antlrcpp::downCast<IntoClauseContext *>(context), predicateIndex);
    case 173: return qualifyClauseSempred(antlrcpp::downCast<QualifyClauseContext *>(context), predicateIndex);
    case 187: return groupByClauseSempred(antlrcpp::downCast<GroupByClauseContext *>(context), predicateIndex);
    case 188: return olapOptionSempred(antlrcpp::downCast<OlapOptionContext *>(context), predicateIndex);
    case 196: return selectOptionSempred(antlrcpp::downCast<SelectOptionContext *>(context), predicateIndex);
    case 197: return lockingClauseListSempred(antlrcpp::downCast<LockingClauseListContext *>(context), predicateIndex);
    case 198: return lockingClauseSempred(antlrcpp::downCast<LockingClauseContext *>(context), predicateIndex);
    case 199: return lockStrenghSempred(antlrcpp::downCast<LockStrenghContext *>(context), predicateIndex);
    case 205: return tableReferenceSempred(antlrcpp::downCast<TableReferenceContext *>(context), predicateIndex);
    case 211: return tableFactorSempred(antlrcpp::downCast<TableFactorContext *>(context), predicateIndex);
    case 214: return derivedTableSempred(antlrcpp::downCast<DerivedTableContext *>(context), predicateIndex);
    case 218: return jtColumnSempred(antlrcpp::downCast<JtColumnContext *>(context), predicateIndex);
    case 225: return tableAliasSempred(antlrcpp::downCast<TableAliasContext *>(context), predicateIndex);
    case 234: return updateStatementSempred(antlrcpp::downCast<UpdateStatementContext *>(context), predicateIndex);
    case 240: return lockStatementSempred(antlrcpp::downCast<LockStatementContext *>(context), predicateIndex);
    case 242: return lockOptionSempred(antlrcpp::downCast<LockOptionContext *>(context), predicateIndex);
    case 244: return xaConvertSempred(antlrcpp::downCast<XaConvertContext *>(context), predicateIndex);
    case 246: return replicationStatementSempred(antlrcpp::downCast<ReplicationStatementContext *>(context), predicateIndex);
    case 247: return purgeOptionsSempred(antlrcpp::downCast<PurgeOptionsContext *>(context), predicateIndex);
    case 248: return resetOptionSempred(antlrcpp::downCast<ResetOptionContext *>(context), predicateIndex);
    case 249: return masterOrBinaryLogsAndGtidsSempred(antlrcpp::downCast<MasterOrBinaryLogsAndGtidsContext *>(context), predicateIndex);
    case 250: return sourceResetOptionsSempred(antlrcpp::downCast<SourceResetOptionsContext *>(context), predicateIndex);
    case 251: return replicationSourceSempred(antlrcpp::downCast<ReplicationSourceContext *>(context), predicateIndex);
    case 254: return sourceDefinitionSempred(antlrcpp::downCast<SourceDefinitionContext *>(context), predicateIndex);
    case 288: return changeReplicationFilterSempred(antlrcpp::downCast<ChangeReplicationFilterContext *>(context), predicateIndex);
    case 304: return groupReplicationSempred(antlrcpp::downCast<GroupReplicationContext *>(context), predicateIndex);
    case 310: return replicaSempred(antlrcpp::downCast<ReplicaContext *>(context), predicateIndex);
    case 314: return cloneStatementSempred(antlrcpp::downCast<CloneStatementContext *>(context), predicateIndex);
    case 317: return accountManagementStatementSempred(antlrcpp::downCast<AccountManagementStatementContext *>(context), predicateIndex);
    case 318: return alterUserStatementSempred(antlrcpp::downCast<AlterUserStatementContext *>(context), predicateIndex);
    case 320: return alterUserSempred(antlrcpp::downCast<AlterUserContext *>(context), predicateIndex);
    case 321: return oldAlterUserSempred(antlrcpp::downCast<OldAlterUserContext *>(context), predicateIndex);
    case 323: return createUserStatementSempred(antlrcpp::downCast<CreateUserStatementContext *>(context), predicateIndex);
    case 324: return createUserTailSempred(antlrcpp::downCast<CreateUserTailContext *>(context), predicateIndex);
    case 326: return defaultRoleClauseSempred(antlrcpp::downCast<DefaultRoleClauseContext *>(context), predicateIndex);
    case 329: return accountLockPasswordExpireOptionsSempred(antlrcpp::downCast<AccountLockPasswordExpireOptionsContext *>(context), predicateIndex);
    case 330: return dropUserStatementSempred(antlrcpp::downCast<DropUserStatementContext *>(context), predicateIndex);
    case 331: return grantStatementSempred(antlrcpp::downCast<GrantStatementContext *>(context), predicateIndex);
    case 332: return grantTargetListSempred(antlrcpp::downCast<GrantTargetListContext *>(context), predicateIndex);
    case 337: return versionedRequireClauseSempred(antlrcpp::downCast<VersionedRequireClauseContext *>(context), predicateIndex);
    case 339: return revokeStatementSempred(antlrcpp::downCast<RevokeStatementContext *>(context), predicateIndex);
    case 342: return roleOrPrivilegeSempred(antlrcpp::downCast<RoleOrPrivilegeContext *>(context), predicateIndex);
    case 343: return grantIdentifierSempred(antlrcpp::downCast<GrantIdentifierContext *>(context), predicateIndex);
    case 346: return grantOptionSempred(antlrcpp::downCast<GrantOptionContext *>(context), predicateIndex);
    case 350: return tableAdministrationStatementSempred(antlrcpp::downCast<TableAdministrationStatementContext *>(context), predicateIndex);
    case 351: return histogramAutoUpdateSempred(antlrcpp::downCast<HistogramAutoUpdateContext *>(context), predicateIndex);
    case 352: return histogramUpdateParamSempred(antlrcpp::downCast<HistogramUpdateParamContext *>(context), predicateIndex);
    case 362: return installSetValueListSempred(antlrcpp::downCast<InstallSetValueListContext *>(context), predicateIndex);
    case 364: return startOptionValueListSempred(antlrcpp::downCast<StartOptionValueListContext *>(context), predicateIndex);
    case 369: return optionValueNoOptionTypeSempred(antlrcpp::downCast<OptionValueNoOptionTypeContext *>(context), predicateIndex);
    case 373: return setExprOrDefaultSempred(antlrcpp::downCast<SetExprOrDefaultContext *>(context), predicateIndex);
    case 380: return showParseTreeStatementSempred(antlrcpp::downCast<ShowParseTreeStatementContext *>(context), predicateIndex);
    case 386: return showBinaryLogsStatementSempred(antlrcpp::downCast<ShowBinaryLogsStatementContext *>(context), predicateIndex);
    case 391: return showKeysStatementSempred(antlrcpp::downCast<ShowKeysStatementContext *>(context), predicateIndex);
    case 410: return showReplicaStatusStatementSempred(antlrcpp::downCast<ShowReplicaStatusStatementContext *>(context), predicateIndex);
    case 421: return showCommandTypeSempred(antlrcpp::downCast<ShowCommandTypeContext *>(context), predicateIndex);
    case 427: return otherAdministrativeStatementSempred(antlrcpp::downCast<OtherAdministrativeStatementContext *>(context), predicateIndex);
    case 435: return flushOptionSempred(antlrcpp::downCast<FlushOptionContext *>(context), predicateIndex);
    case 453: return utilityStatementSempred(antlrcpp::downCast<UtilityStatementContext *>(context), predicateIndex);
    case 455: return explainStatementSempred(antlrcpp::downCast<ExplainStatementContext *>(context), predicateIndex);
    case 456: return explainOptionsSempred(antlrcpp::downCast<ExplainOptionsContext *>(context), predicateIndex);
    case 462: return exprSempred(antlrcpp::downCast<ExprContext *>(context), predicateIndex);
    case 463: return boolPriSempred(antlrcpp::downCast<BoolPriContext *>(context), predicateIndex);
    case 465: return predicateSempred(antlrcpp::downCast<PredicateContext *>(context), predicateIndex);
    case 467: return bitExprSempred(antlrcpp::downCast<BitExprContext *>(context), predicateIndex);
    case 468: return simpleExprSempred(antlrcpp::downCast<SimpleExprContext *>(context), predicateIndex);
    case 469: return arrayCastSempred(antlrcpp::downCast<ArrayCastContext *>(context), predicateIndex);
    case 470: return jsonOperatorSempred(antlrcpp::downCast<JsonOperatorContext *>(context), predicateIndex);
    case 471: return sumExprSempred(antlrcpp::downCast<SumExprContext *>(context), predicateIndex);
    case 473: return windowFunctionCallSempred(antlrcpp::downCast<WindowFunctionCallContext *>(context), predicateIndex);
    case 476: return tablesampleClauseSempred(antlrcpp::downCast<TablesampleClauseContext *>(context), predicateIndex);
    case 478: return leadLagInfoSempred(antlrcpp::downCast<LeadLagInfoContext *>(context), predicateIndex);
    case 487: return runtimeFunctionCallSempred(antlrcpp::downCast<RuntimeFunctionCallContext *>(context), predicateIndex);
    case 489: return geometryFunctionSempred(antlrcpp::downCast<GeometryFunctionContext *>(context), predicateIndex);
    case 504: return lvalueVariableSempred(antlrcpp::downCast<LvalueVariableContext *>(context), predicateIndex);
    case 509: return castTypeSempred(antlrcpp::downCast<CastTypeContext *>(context), predicateIndex);
    case 523: return channelSempred(antlrcpp::downCast<ChannelContext *>(context), predicateIndex);
    case 565: return checkOrReferencesSempred(antlrcpp::downCast<CheckOrReferencesContext *>(context), predicateIndex);
    case 567: return constraintEnforcementSempred(antlrcpp::downCast<ConstraintEnforcementContext *>(context), predicateIndex);
    case 570: return fieldDefinitionSempred(antlrcpp::downCast<FieldDefinitionContext *>(context), predicateIndex);
    case 571: return columnAttributeSempred(antlrcpp::downCast<ColumnAttributeContext *>(context), predicateIndex);
    case 582: return keyPartOrExpressionSempred(antlrcpp::downCast<KeyPartOrExpressionContext *>(context), predicateIndex);
    case 585: return commonIndexOptionSempred(antlrcpp::downCast<CommonIndexOptionContext *>(context), predicateIndex);
    case 591: return dataTypeSempred(antlrcpp::downCast<DataTypeContext *>(context), predicateIndex);
    case 602: return charsetNameSempred(antlrcpp::downCast<CharsetNameContext *>(context), predicateIndex);
    case 603: return collationNameSempred(antlrcpp::downCast<CollationNameContext *>(context), predicateIndex);
    case 608: return createTableOptionSempred(antlrcpp::downCast<CreateTableOptionContext *>(context), predicateIndex);
    case 627: return persistedVariableIdentifierSempred(antlrcpp::downCast<PersistedVariableIdentifierContext *>(context), predicateIndex);
    case 640: return fieldTermSempred(antlrcpp::downCast<FieldTermContext *>(context), predicateIndex);
    case 645: return createUserSempred(antlrcpp::downCast<CreateUserContext *>(context), predicateIndex);
    case 647: return identificationSempred(antlrcpp::downCast<IdentificationContext *>(context), predicateIndex);
    case 648: return identifiedByPasswordSempred(antlrcpp::downCast<IdentifiedByPasswordContext *>(context), predicateIndex);
    case 668: return columnNameSempred(antlrcpp::downCast<ColumnNameContext *>(context), predicateIndex);
    case 712: return pureIdentifierSempred(antlrcpp::downCast<PureIdentifierContext *>(context), predicateIndex);
    case 717: return simpleIdentifierSempred(antlrcpp::downCast<SimpleIdentifierContext *>(context), predicateIndex);
    case 722: return real_ulonglong_numberSempred(antlrcpp::downCast<Real_ulonglong_numberContext *>(context), predicateIndex);
    case 724: return signedLiteralOrNullSempred(antlrcpp::downCast<SignedLiteralOrNullContext *>(context), predicateIndex);
    case 726: return literalOrNullSempred(antlrcpp::downCast<LiteralOrNullContext *>(context), predicateIndex);
    case 729: return textStringLiteralSempred(antlrcpp::downCast<TextStringLiteralContext *>(context), predicateIndex);
    case 731: return textStringHashSempred(antlrcpp::downCast<TextStringHashContext *>(context), predicateIndex);
    case 749: return optionTypeSempred(antlrcpp::downCast<OptionTypeContext *>(context), predicateIndex);
    case 751: return setVarIdentTypeSempred(antlrcpp::downCast<SetVarIdentTypeContext *>(context), predicateIndex);
    case 753: return identifierKeywordSempred(antlrcpp::downCast<IdentifierKeywordContext *>(context), predicateIndex);
    case 755: return identifierKeywordsAmbiguous2LabelsSempred(antlrcpp::downCast<IdentifierKeywordsAmbiguous2LabelsContext *>(context), predicateIndex);
    case 756: return labelKeywordSempred(antlrcpp::downCast<LabelKeywordContext *>(context), predicateIndex);
    case 758: return identifierKeywordsUnambiguousSempred(antlrcpp::downCast<IdentifierKeywordsUnambiguousContext *>(context), predicateIndex);
    case 759: return roleKeywordSempred(antlrcpp::downCast<RoleKeywordContext *>(context), predicateIndex);
    case 762: return roleOrIdentifierKeywordSempred(antlrcpp::downCast<RoleOrIdentifierKeywordContext *>(context), predicateIndex);
    case 763: return roleOrLabelKeywordSempred(antlrcpp::downCast<RoleOrLabelKeywordContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool MySQLParser::simpleStatementSempred(SimpleStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return serverVersion >= 80000;
    case 1: return serverVersion >= 80000;
    case 2: return serverVersion >= 80200;
    case 3: return serverVersion < 80400;
    case 4: return serverVersion >= 90200;
    case 5: return serverVersion >= 50704;
    case 6: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterStatementSempred(AlterStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 7: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterDatabaseSempred(AlterDatabaseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 8: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::standaloneAlterCommandsSempred(StandaloneAlterCommandsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 9: return serverVersion >= 80014;
    case 10: return serverVersion >= 80200;
    case 11: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterPartitionSempred(AlterPartitionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 12: return serverVersion >= 50704;
    case 13: return serverVersion >= 50704;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterListItemSempred(AlterListItemContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 14: return serverVersion >= 80017;
    case 15: return serverVersion >= 80019;
    case 16: return serverVersion >= 80014;
    case 17: return serverVersion >= 80024;
    case 18: return serverVersion >= 80000;
    case 19: return serverVersion >= 80017;
    case 20: return serverVersion >= 80019;
    case 21: return serverVersion >= 80000;
    case 22: return serverVersion >= 80014;
    case 23: return serverVersion >= 50708 && serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::withValidationSempred(WithValidationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 24: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterTablespaceSempred(AlterTablespaceContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 25: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterTablespaceOptionSempred(AlterTablespaceOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 26: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterInstanceStatementSempred(AlterInstanceStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 27: return serverVersion >= 50713;
    case 28: return serverVersion >= 80016;
    case 29: return serverVersion >= 80021;
    case 30: return serverVersion >= 80021;
    case 31: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createStatementSempred(CreateStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 32: return serverVersion >= 80000;
    case 33: return serverVersion >= 80011;
    case 34: return serverVersion >= 80014;
    case 35: return serverVersion >= 90200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createDatabaseOptionSempred(CreateDatabaseOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 36: return serverVersion >= 80016;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createProcedureSempred(CreateProcedureContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 37: return serverVersion >= 80029;

  default:
    break;
  }
  return true;
}

bool MySQLParser::storedRoutineBodySempred(StoredRoutineBodyContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 38: return serverVersion >= 80032 && supportMle;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createFunctionSempred(CreateFunctionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 39: return serverVersion >= 80029;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUdfSempred(CreateUdfContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 40: return serverVersion >= 80029;

  default:
    break;
  }
  return true;
}

bool MySQLParser::routineCreateOptionSempred(RoutineCreateOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 41: return serverVersion >= 90200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::routineOptionSempred(RoutineOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 42: return serverVersion >= 80032;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tsDataFileNameSempred(TsDataFileNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 43: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tablespaceOptionSempred(TablespaceOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 44: return serverVersion >= 50707;
    case 45: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createViewSempred(CreateViewContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 46: return serverVersion >= 90100;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createTriggerSempred(CreateTriggerContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 47: return serverVersion >= 80029;

  default:
    break;
  }
  return true;
}

bool MySQLParser::dropStatementSempred(DropStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 48: return serverVersion >= 80000;
    case 49: return serverVersion >= 80011;
    case 50: return serverVersion >= 80014;
    case 51: return serverVersion >= 90200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::deleteStatementSempred(DeleteStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 52: return serverVersion >= 80000;
    case 53: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::doStatementSempred(DoStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 54: return serverVersion < 50709;
    case 55: return serverVersion >= 50709;

  default:
    break;
  }
  return true;
}

bool MySQLParser::valuesReferenceSempred(ValuesReferenceContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 56: return  serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::loadStatementSempred(LoadStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 57: return  serverVersion >= 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::loadFromSempred(LoadFromContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 58: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::loadSourceTypeSempred(LoadSourceTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 59: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::sourceCountSempred(SourceCountContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 60: return serverVersion >= 80200;
    case 61: return serverVersion < 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::sourceOrderSempred(SourceOrderContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 62: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::loadAlgorithmSempred(LoadAlgorithmContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 63: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::compressionAlgorithmSempred(CompressionAlgorithmContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 64: return serverVersion >= 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::loadParallelSempred(LoadParallelContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 65: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::loadMemorySempred(LoadMemoryContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 66: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::selectStatementWithIntoSempred(SelectStatementWithIntoContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 67: return serverVersion >= 80024 && serverVersion < 80031;

  default:
    break;
  }
  return true;
}

bool MySQLParser::queryExpressionSempred(QueryExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 68: return serverVersion >= 80000;
    case 69: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::queryExpressionBodySempred(QueryExpressionBodyContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 70: return serverVersion >= 80031;

  default:
    break;
  }
  return true;
}

bool MySQLParser::queryPrimarySempred(QueryPrimaryContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 71: return serverVersion >= 80019;
    case 72: return serverVersion >= 80019;

  default:
    break;
  }
  return true;
}

bool MySQLParser::querySpecificationSempred(QuerySpecificationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 73: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::intoClauseSempred(IntoClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 74: return serverVersion < 90101;
    case 75: return serverVersion >= 90101;
    case 76: return serverVersion >= 90101;

  default:
    break;
  }
  return true;
}

bool MySQLParser::qualifyClauseSempred(QualifyClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 77: return serverVersion >= 80300;

  default:
    break;
  }
  return true;
}

bool MySQLParser::groupByClauseSempred(GroupByClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 78: return serverVersion >= 80032;

  default:
    break;
  }
  return true;
}

bool MySQLParser::olapOptionSempred(OlapOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 79: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::selectOptionSempred(SelectOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 80: return serverVersion < 80000;
    case 81: return serverVersion >= 50704 && serverVersion < 50708;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockingClauseListSempred(LockingClauseListContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 82: return serverVersion >= 80031;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockingClauseSempred(LockingClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 83: return serverVersion >= 80000;
    case 84: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockStrenghSempred(LockStrenghContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 85: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableReferenceSempred(TableReferenceContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 86: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableFactorSempred(TableFactorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 87: return serverVersion >= 80004;

  default:
    break;
  }
  return true;
}

bool MySQLParser::derivedTableSempred(DerivedTableContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 88: return serverVersion >= 80000;
    case 89: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::jtColumnSempred(JtColumnContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 90: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableAliasSempred(TableAliasContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 91: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::updateStatementSempred(UpdateStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 92: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockStatementSempred(LockStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 93: return serverVersion >= 80000;
    case 94: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockOptionSempred(LockOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 95: return serverVersion < 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::xaConvertSempred(XaConvertContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 96: return serverVersion >= 50704;

  default:
    break;
  }
  return true;
}

bool MySQLParser::replicationStatementSempred(ReplicationStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 97: return serverVersion > 80000;
    case 98: return serverVersion > 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::purgeOptionsSempred(PurgeOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 99: return serverVersion < 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::resetOptionSempred(ResetOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 100: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::masterOrBinaryLogsAndGtidsSempred(MasterOrBinaryLogsAndGtidsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 101: return serverVersion < 80400;
    case 102: return serverVersion >= 80200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::sourceResetOptionsSempred(SourceResetOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 103: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::replicationSourceSempred(ReplicationSourceContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 104: return serverVersion < 80400;
    case 105: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::sourceDefinitionSempred(SourceDefinitionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 106: return serverVersion >= 80024;
    case 107: return serverVersion >= 80024;
    case 108: return serverVersion >= 80027;

  default:
    break;
  }
  return true;
}

bool MySQLParser::changeReplicationFilterSempred(ChangeReplicationFilterContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 109: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::groupReplicationSempred(GroupReplicationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 110: return serverVersion >= 80021;

  default:
    break;
  }
  return true;
}

bool MySQLParser::replicaSempred(ReplicaContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 111: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::cloneStatementSempred(CloneStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 112: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::accountManagementStatementSempred(AccountManagementStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 113: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterUserStatementSempred(AlterUserStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 114: return serverVersion >= 50706;
    case 115: return serverVersion < 80014;
    case 116: return serverVersion >= 80014;
    case 117: return serverVersion >= 80000;
    case 118: return serverVersion >= 80013;
    case 119: return serverVersion >= 80014;
    case 120: return serverVersion >= 80014;
    case 121: return serverVersion >= 80027;
    case 122: return serverVersion < 80000;
    case 123: return serverVersion >= 80000;
    case 124: return serverVersion >= 80027;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterUserSempred(AlterUserContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 125: return serverVersion < 80025;
    case 126: return serverVersion >= 80025;
    case 127: return serverVersion >= 80027;
    case 128: return serverVersion >= 80027;
    case 129: return serverVersion >= 80027;

  default:
    break;
  }
  return true;
}

bool MySQLParser::oldAlterUserSempred(OldAlterUserContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 130: return serverVersion >= 80013;
    case 131: return serverVersion >= 80014;
    case 132: return serverVersion >= 80018;
    case 133: return serverVersion >= 80013;
    case 134: return serverVersion >= 80014;
    case 135: return serverVersion >= 80014;
    case 136: return serverVersion >= 80018;
    case 137: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUserStatementSempred(CreateUserStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 138: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUserTailSempred(CreateUserTailContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 139: return serverVersion >= 50706;
    case 140: return serverVersion >= 80021;

  default:
    break;
  }
  return true;
}

bool MySQLParser::defaultRoleClauseSempred(DefaultRoleClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 141: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::accountLockPasswordExpireOptionsSempred(AccountLockPasswordExpireOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 142: return serverVersion >= 80014;
    case 143: return serverVersion >= 80019;
    case 144: return serverVersion >= 80019;

  default:
    break;
  }
  return true;
}

bool MySQLParser::dropUserStatementSempred(DropUserStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 145: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantStatementSempred(GrantStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 146: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantTargetListSempred(GrantTargetListContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 147: return serverVersion < 80011;
    case 148: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::versionedRequireClauseSempred(VersionedRequireClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 149: return serverVersion < 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::revokeStatementSempred(RevokeStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 150: return serverVersion >= 80030;
    case 151: return serverVersion >= 80000;
    case 152: return serverVersion >= 80000;
    case 153: return serverVersion >= 80030;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleOrPrivilegeSempred(RoleOrPrivilegeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 154: return serverVersion > 80000;
    case 155: return serverVersion > 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantIdentifierSempred(GrantIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 156: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantOptionSempred(GrantOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 157: return serverVersion < 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableAdministrationStatementSempred(TableAdministrationStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 158: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::histogramAutoUpdateSempred(HistogramAutoUpdateContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 159: return serverVersion >= 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::histogramUpdateParamSempred(HistogramUpdateParamContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 160: return serverVersion >= 80031;

  default:
    break;
  }
  return true;
}

bool MySQLParser::installSetValueListSempred(InstallSetValueListContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 161: return serverVersion >= 80032;

  default:
    break;
  }
  return true;
}

bool MySQLParser::startOptionValueListSempred(StartOptionValueListContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 162: return serverVersion < 50706;
    case 163: return serverVersion < 80014;
    case 164: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::optionValueNoOptionTypeSempred(OptionValueNoOptionTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 165: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::setExprOrDefaultSempred(SetExprOrDefaultContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 166: return serverVersion >= 80000;
    case 167: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showParseTreeStatementSempred(ShowParseTreeStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 168: return serverVersion >= 80100;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showBinaryLogsStatementSempred(ShowBinaryLogsStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 169: return serverVersion < 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showKeysStatementSempred(ShowKeysStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 170: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showReplicaStatusStatementSempred(ShowReplicaStatusStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 171: return serverVersion < 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showCommandTypeSempred(ShowCommandTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 172: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::otherAdministrativeStatementSempred(OtherAdministrativeStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 173: return serverVersion >= 50709;

  default:
    break;
  }
  return true;
}

bool MySQLParser::flushOptionSempred(FlushOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 174: return serverVersion < 80300;
    case 175: return serverVersion < 80000;
    case 176: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::utilityStatementSempred(UtilityStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 177: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::explainStatementSempred(ExplainStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 178: return serverVersion >= 80032;

  default:
    break;
  }
  return true;
}

bool MySQLParser::explainOptionsSempred(ExplainOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 179: return serverVersion >= 80100;
    case 180: return serverVersion < 80000;
    case 181: return serverVersion < 80000;
    case 182: return serverVersion >= 80018;
    case 183: return serverVersion >= 80019;

  default:
    break;
  }
  return true;
}

bool MySQLParser::exprSempred(ExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 184: return precpred(_ctx, 3);
    case 185: return precpred(_ctx, 2);
    case 186: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool MySQLParser::boolPriSempred(BoolPriContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 187: return precpred(_ctx, 3);
    case 188: return precpred(_ctx, 2);
    case 189: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool MySQLParser::predicateSempred(PredicateContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 190: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::bitExprSempred(BitExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 191: return precpred(_ctx, 7);
    case 192: return precpred(_ctx, 6);
    case 193: return precpred(_ctx, 5);
    case 194: return precpred(_ctx, 3);
    case 195: return precpred(_ctx, 2);
    case 196: return precpred(_ctx, 1);
    case 197: return precpred(_ctx, 4);

  default:
    break;
  }
  return true;
}

bool MySQLParser::simpleExprSempred(SimpleExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 198: return serverVersion >= 80000;
    case 199: return serverVersion >= 80000;
    case 200: return serverVersion >= 80022;
    case 201: return precpred(_ctx, 16);
    case 202: return precpred(_ctx, 24);

  default:
    break;
  }
  return true;
}

bool MySQLParser::arrayCastSempred(ArrayCastContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 203: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::jsonOperatorSempred(JsonOperatorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 204: return serverVersion >= 50708;
    case 205: return serverVersion >= 50713;

  default:
    break;
  }
  return true;
}

bool MySQLParser::sumExprSempred(SumExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 206: return serverVersion >= 80000;
    case 207: return serverVersion >= 80000;
    case 208: return serverVersion >= 80000;
    case 209: return serverVersion >= 80024;
    case 210: return serverVersion >= 80000;
    case 211: return serverVersion >= 80000;
    case 212: return serverVersion >= 80000;
    case 213: return serverVersion >= 80000;
    case 214: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::windowFunctionCallSempred(WindowFunctionCallContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 215: return serverVersion < 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tablesampleClauseSempred(TablesampleClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 216: return serverVersion >= 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::leadLagInfoSempred(LeadLagInfoContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 217: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::runtimeFunctionCallSempred(RuntimeFunctionCallContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 218: return serverVersion >= 80021;
    case 219: return serverVersion >= 80200;
    case 220: return serverVersion < 80011;
    case 221: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::geometryFunctionSempred(GeometryFunctionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 222: return serverVersion < 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lvalueVariableSempred(LvalueVariableContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 223: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::castTypeSempred(CastTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 224: return serverVersion >= 80024;
    case 225: return serverVersion >= 50708;
    case 226: return serverVersion >= 80017;
    case 227: return serverVersion >= 80017;
    case 228: return serverVersion >= 80027;

  default:
    break;
  }
  return true;
}

bool MySQLParser::channelSempred(ChannelContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 229: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::checkOrReferencesSempred(CheckOrReferencesContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 230: return serverVersion < 80016;

  default:
    break;
  }
  return true;
}

bool MySQLParser::constraintEnforcementSempred(ConstraintEnforcementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 231: return  serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::fieldDefinitionSempred(FieldDefinitionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 232: return serverVersion >= 50707;
    case 233: return serverVersion < 80000;
    case 234: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::columnAttributeSempred(ColumnAttributeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 235: return serverVersion >= 80014;
    case 236: return serverVersion >= 80013;
    case 237: return serverVersion >= 80000;
    case 238: return serverVersion >= 80017;
    case 239: return serverVersion >= 80017;
    case 240: return serverVersion >= 80024;
    case 241: return serverVersion >= 80024;
    case 242: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::keyPartOrExpressionSempred(KeyPartOrExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 243: return serverVersion >= 80013;

  default:
    break;
  }
  return true;
}

bool MySQLParser::commonIndexOptionSempred(CommonIndexOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 244: return serverVersion >= 80000;
    case 245: return serverVersion >= 80024;
    case 246: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::dataTypeSempred(DataTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 247: return serverVersion >= 50708;

  default:
    break;
  }
  return true;
}

bool MySQLParser::charsetNameSempred(CharsetNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 248: return serverVersion < 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::collationNameSempred(CollationNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 249: return serverVersion < 80011;
    case 250: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createTableOptionSempred(CreateTableOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 251: return serverVersion >= 80014;
    case 252: return serverVersion >= 50708;
    case 253: return serverVersion >= 50711;
    case 254: return serverVersion >= 50707;
    case 255: return serverVersion >= 80024;
    case 256: return serverVersion >= 80024;
    case 257: return serverVersion >= 80024;
    case 258: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::persistedVariableIdentifierSempred(PersistedVariableIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 259: return serverVersion >= 80032;

  default:
    break;
  }
  return true;
}

bool MySQLParser::fieldTermSempred(FieldTermContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 260: return serverVersion >= 80400;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUserSempred(CreateUserContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 261: return serverVersion >= 80027;
    case 262: return serverVersion >= 80027;
    case 263: return serverVersion >= 80027;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identificationSempred(IdentificationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 264: return serverVersion >= 80018;
    case 265: return serverVersion >= 50706;
    case 266: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identifiedByPasswordSempred(IdentifiedByPasswordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 267: return serverVersion < 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::columnNameSempred(ColumnNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 268: return serverVersion >= 80000;
    case 269: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::pureIdentifierSempred(PureIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 270: return isSqlModeActive(AnsiQuotes);

  default:
    break;
  }
  return true;
}

bool MySQLParser::simpleIdentifierSempred(SimpleIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 271: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::real_ulonglong_numberSempred(Real_ulonglong_numberContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 272: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::signedLiteralOrNullSempred(SignedLiteralOrNullContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 273: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::literalOrNullSempred(LiteralOrNullContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 274: return serverVersion >= 80024;

  default:
    break;
  }
  return true;
}

bool MySQLParser::textStringLiteralSempred(TextStringLiteralContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 275: return !isSqlModeActive(AnsiQuotes);

  default:
    break;
  }
  return true;
}

bool MySQLParser::textStringHashSempred(TextStringHashContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 276: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::optionTypeSempred(OptionTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 277: return serverVersion >= 80000;
    case 278: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::setVarIdentTypeSempred(SetVarIdentTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 279: return serverVersion >= 80000;
    case 280: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identifierKeywordSempred(IdentifierKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 281: return serverVersion < 80017;
    case 282: return serverVersion >= 50709;
    case 283: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identifierKeywordsAmbiguous2LabelsSempred(IdentifierKeywordsAmbiguous2LabelsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 284: return serverVersion >= 90200;

  default:
    break;
  }
  return true;
}

bool MySQLParser::labelKeywordSempred(LabelKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 285: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identifierKeywordsUnambiguousSempred(IdentifierKeywordsUnambiguousContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 286: return serverVersion >= 80019;
    case 287: return serverVersion >= 80032;
    case 288: return serverVersion >= 80100;
    case 289: return serverVersion >= 80200;
    case 290: return serverVersion >= 80400;
    case 291: return serverVersion >= 90000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleKeywordSempred(RoleKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 292: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleOrIdentifierKeywordSempred(RoleOrIdentifierKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 293: return serverVersion >= 50709;
    case 294: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleOrLabelKeywordSempred(RoleOrLabelKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 295: return serverVersion < 50709;
    case 296: return serverVersion < 80000;
    case 297: return serverVersion >= 80000;
    case 298: return serverVersion >= 80014;
    case 299: return serverVersion < 80024;

  default:
    break;
  }
  return true;
}

void MySQLParser::initialize() {
  std::call_once(mysqlparserParserOnceFlag, mysqlparserParserInitialize);
}
