/*
 * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
 *
 * 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 /build/mysql-workbench/src/mysql-workbench-community-8.0.47-src/library/parsers/grammars/MySQLParser.g4 by ANTLR 4.13.2


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

#include "MySQLParser.h"


#include "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;
};

::antlr4::internal::OnceFlag mysqlparserParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
std::unique_ptr<MySQLParserStaticData> mysqlparserParserStaticData = nullptr;

void mysqlparserParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  if (mysqlparserParserStaticData != nullptr) {
    return;
  }
#else
  assert(mysqlparserParserStaticData == nullptr);
#endif
  auto staticData = std::make_unique<MySQLParserStaticData>(
    std::vector<std::string>{
      "query", "simpleStatement", "alterStatement", "alterDatabase", "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", "viewSelect", "viewCheckOption", 
      "createStatement", "createDatabase", "createDatabaseOption", "createTable", 
      "tableElementList", "tableElement", "duplicateAsQueryExpression", 
      "queryExpressionOrParens", "createRoutine", "createProcedure", "createFunction", 
      "createUdf", "routineCreateOption", "routineAlterOptions", "routineOption", 
      "createIndex", "indexNameAndType", "createIndexTarget", "createLogfileGroup", 
      "logfileGroupOptions", "logfileGroupOption", "createServer", "serverOptions", 
      "serverOption", "createTablespace", "createUndoTablespace", "tsDataFileName", 
      "tsDataFile", "tablespaceOptions", "tablespaceOption", "tsOptionInitialSize", 
      "tsOptionUndoRedoBufferSize", "tsOptionAutoextendSize", "tsOptionMaxSize", 
      "tsOptionExtentSize", "tsOptionNodegroup", "tsOptionEngine", "tsOptionWait", 
      "tsOptionComment", "tsOptionFileblockSize", "tsOptionEncryption", 
      "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", 
      "renameTableStatement", "renamePair", "truncateTableStatement", "importStatement", 
      "callStatement", "deleteStatement", "partitionDelete", "deleteStatementOption", 
      "doStatement", "handlerStatement", "handlerReadOrScan", "insertStatement", 
      "insertLockOption", "insertFromConstructor", "fields", "insertValues", 
      "insertQueryExpression", "valueList", "values", "valuesReference", 
      "insertUpdateList", "loadStatement", "dataOrXml", "xmlRowsIdentifiedBy", 
      "loadDataFileTail", "loadDataFileTargetList", "fieldOrVariableList", 
      "replaceStatement", "selectStatement", "selectStatementWithInto", 
      "queryExpression", "queryExpressionBody", "queryExpressionParens", 
      "queryPrimary", "querySpecification", "subquery", "querySpecOption", 
      "limitClause", "simpleLimitClause", "limitOptions", "limitOption", 
      "intoClause", "procedureAnalyseClause", "havingClause", "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", "onEmpty", 
      "onError", "jtOnResponse", "unionOption", "tableAlias", "indexHintList", 
      "indexHint", "indexHintType", "keyOrIndex", "constraintKeyType", "indexHintClause", 
      "indexList", "indexListElement", "updateStatement", "transactionOrLockingStatement", 
      "transactionStatement", "beginWork", "transactionCharacteristic", 
      "savepointStatement", "lockStatement", "lockItem", "lockOption", "xaStatement", 
      "xaConvert", "xid", "replicationStatement", "resetOption", "masterResetOptions", 
      "replicationLoad", "changeMaster", "changeMasterOptions", "masterOption", 
      "privilegeCheckDef", "tablePrimaryKeyCheckDef", "masterTlsCiphersuitesDef", 
      "masterFileDef", "serverIdList", "changeReplication", "filterDefinition", 
      "filterDbList", "filterTableList", "filterStringList", "filterWildDbTableString", 
      "filterDbPairList", "slave", "slaveUntilOptions", "slaveConnectionOptions", 
      "slaveThreadOptions", "slaveThreadOption", "groupReplication", "preparedStatement", 
      "executeStatement", "executeVarList", "cloneStatement", "dataDirSSL", 
      "ssl", "accountManagementStatement", "alterUser", "alterUserTail", 
      "userFunction", "createUser", "createUserTail", "defaultRoleClause", 
      "requireClause", "connectOptions", "accountLockPasswordExpireOptions", 
      "dropUser", "grant", "grantTargetList", "grantOptions", "exceptRoleList", 
      "withRoles", "grantAs", "versionedRequireClause", "renameUser", "revoke", 
      "onTypeTo", "aclType", "roleOrPrivilegesList", "roleOrPrivilege", 
      "grantIdentifier", "requireList", "requireListElement", "grantOption", 
      "setRole", "roleList", "role", "tableAdministrationStatement", "histogram", 
      "checkOption", "repairType", "installUninstallStatment", "setStatement", 
      "startOptionValueList", "transactionCharacteristics", "transactionAccessMode", 
      "isolationLevel", "optionValueListContinued", "optionValueNoOptionType", 
      "optionValue", "setSystemVariable", "startOptionValueListFollowingOptionType", 
      "optionValueFollowingOptionType", "setExprOrDefault", "showStatement", 
      "showCommandType", "nonBlocking", "fromOrIn", "inDb", "profileType", 
      "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", "explainableStatement", "helpCommand", 
      "useCommand", "restartServer", "expr", "boolPri", "compOp", "predicate", 
      "predicateOperations", "bitExpr", "simpleExpr", "arrayCast", "jsonOperator", 
      "sumExpr", "groupingOperation", "windowFunctionCall", "windowingClause", 
      "leadLagInfo", "nullTreatment", "jsonFunction", "inSumExpr", "identListArg", 
      "identList", "fulltextOptions", "runtimeFunctionCall", "geometryFunction", 
      "timeFunctionParameters", "fractionalPrecision", "weightStringLevels", 
      "weightStringLevelListItem", "dateTimeTtype", "trimFunction", "substringFunction", 
      "functionCall", "udfExprList", "udfExpr", "variable", "userVariable", 
      "systemVariable", "internalVariableName", "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", "getDiagnostics", "signalAllowedExpr", "statementInformationItem", 
      "conditionInformationItem", "signalInformationItemName", "signalStatement", 
      "resignalStatement", "signalInformationItem", "cursorOpen", "cursorClose", 
      "cursorFetch", "schedule", "columnDefinition", "checkOrReferences", 
      "checkConstraint", "constraintEnforcement", "tableConstraintDef", 
      "constraintName", "fieldDefinition", "columnAttribute", "columnFormat", 
      "storageMedia", "gcolAttribute", "references", "deleteOption", "keyList", 
      "keyPart", "keyListWithExpression", "keyPartOrExpression", "keyListVariants", 
      "indexType", "indexOption", "commonIndexOption", "visibility", "indexTypeClause", 
      "fulltextIndexOption", "spatialIndexOption", "dataTypeDefinition", 
      "dataType", "nchar", "realType", "fieldLength", "fieldOptions", "charsetWithOptBinary", 
      "ascii", "unicode", "wsNumCodepoints", "typeDatetimePrecision", "charsetName", 
      "collationName", "createTableOptions", "createTableOptionsSpaceSeparated", 
      "createTableOption", "ternaryOption", "defaultCollation", "defaultEncryption", 
      "defaultCharset", "partitionClause", "partitionTypeDef", "subPartitions", 
      "partitionKeyAlgorithm", "partitionDefinitions", "partitionDefinition", 
      "partitionValuesIn", "partitionOption", "subpartitionDefinition", 
      "partitionValueItemListParen", "partitionValueItem", "definerClause", 
      "ifExists", "ifNotExists", "procedureParameter", "functionParameter", 
      "collate", "typeWithOptCollate", "schemaIdentifierPair", "viewRefList", 
      "updateList", "updateElement", "charsetClause", "fieldsClause", "fieldTerm", 
      "linesClause", "lineTerm", "userList", "createUserList", "alterUserList", 
      "createUserEntry", "alterUserEntry", "retainCurrentPassword", "discardOldPassword", 
      "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", "roleRef", "pluginRef", "componentRef", "resourceGroupRef", 
      "windowName", "pureIdentifier", "identifier", "identifierList", "identifierListWithParentheses", 
      "qualifiedIdentifier", "simpleIdentifier", "dotIdentifier", "ulong_number", 
      "real_ulong_number", "ulonglong_number", "real_ulonglong_number", 
      "literal", "signedLiteral", "stringList", "textStringLiteral", "textString", 
      "textStringHash", "textLiteral", "textStringNoLinebreak", "textStringLiteralList", 
      "numLiteral", "boolLiteral", "nullLiteral", "temporalLiteral", "floatOptions", 
      "standardFloatOptions", "precision", "textOrIdentifier", "lValueIdentifier", 
      "roleIdentifierOrText", "sizeNumber", "parentheses", "equal", "optionType", 
      "varIdentType", "setVarIdentType", "identifierKeyword", "identifierKeywordsAmbiguous1RolesAndLabels", 
      "identifierKeywordsAmbiguous2Labels", "labelKeyword", "identifierKeywordsAmbiguous3Roles", 
      "identifierKeywordsUnambiguous", "roleKeyword", "lValueKeyword", "identifierKeywordsAmbiguous4SystemVariables", 
      "roleOrIdentifierKeyword", "roleOrLabelKeyword"
    },
    std::vector<std::string>{
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "'='", "':='", "'<=>'", "'>='", "'>'", "'<='", "'<'", "'!='", 
      "'+'", "'-'", "'*'", "'/'", "'%'", "'!'", "'~'", "'<<'", "'>>'", "'&&'", 
      "'&'", "'^'", "'||'", "'|'", "'.'", "','", "';'", "':'", "'('", "')'", 
      "'{'", "'}'", "'_'", "'->'", "'->>'", "'@'", "", "'@@'", "'\\N'", 
      "'\\u003F'", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "", "", "", "", "'<>'"
    },
    std::vector<std::string>{
      "", "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", "AUTHORS_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", "CHARACTER_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", "CONTRIBUTORS_SYMBOL", "CONVERT_SYMBOL", 
      "COUNT_SYMBOL", "CPU_SYMBOL", "CREATE_SYMBOL", "CROSS_SYMBOL", "CUBE_SYMBOL", 
      "CURDATE_SYMBOL", "CURRENT_SYMBOL", "CURRENT_DATE_SYMBOL", "CURRENT_TIME_SYMBOL", 
      "CURRENT_TIMESTAMP_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", "DAYOFMONTH_SYMBOL", "DAY_HOUR_SYMBOL", 
      "DAY_MICROSECOND_SYMBOL", "DAY_MINUTE_SYMBOL", "DAY_SECOND_SYMBOL", 
      "DAY_SYMBOL", "DEALLOCATE_SYMBOL", "DEC_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", "DISTINCTROW_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", "FIELDS_SYMBOL", "FILE_SYMBOL", 
      "FILE_BLOCK_SIZE_SYMBOL", "FILTER_SYMBOL", "FIRST_SYMBOL", "FIXED_SYMBOL", 
      "FLOAT4_SYMBOL", "FLOAT8_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", "INTEGER_SYMBOL", "INTERVAL_SYMBOL", "INTO_SYMBOL", 
      "INT_SYMBOL", "INVOKER_SYMBOL", "IN_SYMBOL", "IO_AFTER_GTIDS_SYMBOL", 
      "IO_BEFORE_GTIDS_SYMBOL", "IO_THREAD_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", "LOCALTIME_SYMBOL", "LOCALTIMESTAMP_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", "MIDDLEINT_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", "NDB_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", "RLIKE_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_SYMBOL", "SCHEMA_NAME_SYMBOL", "SCHEMAS_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", "SOME_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", "TIMESTAMP_ADD_SYMBOL", 
      "TIMESTAMP_DIFF_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", "VARCHARACTER_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", "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_TEXT_SUFFIX", 
      "AT_AT_SIGN_SYMBOL", "NULL2_SYMBOL", "PARAM_MARKER", "HEX_NUMBER", 
      "BIN_NUMBER", "DECIMAL_NUMBER", "FLOAT_NUMBER", "WHITESPACE", "INVALID_INPUT", 
      "UNDERSCORE_CHARSET", "IDENTIFIER", "NCHAR_TEXT", "BACK_TICK_QUOTED_ID", 
      "DOUBLE_QUOTED_TEXT", "SINGLE_QUOTED_TEXT", "VERSION_COMMENT_START", 
      "MYSQL_COMMENT_START", "VERSION_COMMENT_END", "BLOCK_COMMENT", "POUND_COMMENT", 
      "DASHDASH_COMMENT", "NOT_EQUAL2_OPERATOR"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,806,8417,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,1,0,1,0,1,0,3,0,1224,8,0,1,0,1,0,3,0,1228,8,0,1,0,3,
  	0,1231,8,0,3,0,1233,8,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,3,1,1269,8,1,1,2,1,2,1,2,1,2,1,2,1,2,3,2,1277,8,2,
  	1,2,1,2,1,2,3,2,1282,8,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,
  	1,2,1,2,1,2,3,2,1298,8,2,1,3,1,3,1,3,4,3,1303,8,3,11,3,12,3,1304,1,3,
  	1,3,1,3,1,3,1,3,3,3,1312,8,3,1,4,3,4,1315,8,4,1,4,1,4,1,4,1,4,1,4,3,4,
  	1322,8,4,1,4,1,4,1,4,3,4,1327,8,4,1,4,3,4,1330,8,4,1,4,1,4,1,4,3,4,1335,
  	8,4,1,4,1,4,1,4,1,4,3,4,1341,8,4,3,4,1343,8,4,1,4,1,4,3,4,1347,8,4,1,
  	4,1,4,3,4,1351,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,1360,8,5,1,6,1,6,3,
  	6,1364,8,6,1,6,5,6,1367,8,6,10,6,12,6,1370,9,6,1,7,1,7,1,7,3,7,1375,8,
  	7,1,8,1,8,1,8,1,8,1,9,3,9,1382,8,9,1,9,1,9,3,9,1386,8,9,1,9,1,9,1,9,3,
  	9,1391,8,9,1,10,1,10,1,10,3,10,1396,8,10,1,10,1,10,1,10,1,10,1,10,3,10,
  	1403,8,10,1,10,3,10,1406,8,10,1,11,1,11,1,11,1,11,3,11,1412,8,11,1,11,
  	3,11,1415,8,11,1,12,1,12,1,12,5,12,1420,8,12,10,12,12,12,1423,9,12,1,
  	13,1,13,1,13,1,13,1,13,1,13,1,13,3,13,1432,8,13,1,14,1,14,1,14,3,14,1437,
  	8,14,1,14,1,14,1,14,3,14,1442,8,14,1,14,1,14,1,14,1,14,1,14,1,14,3,14,
  	1450,8,14,1,14,1,14,1,14,1,14,3,14,1456,8,14,1,14,1,14,3,14,1460,8,14,
  	1,14,1,14,1,14,3,14,1465,8,14,1,14,1,14,1,14,1,14,1,14,5,14,1472,8,14,
  	10,14,12,14,1475,9,14,1,14,1,14,1,14,3,14,1480,8,14,1,14,1,14,5,14,1484,
  	8,14,10,14,12,14,1487,9,14,1,14,1,14,1,14,3,14,1492,8,14,1,14,1,14,1,
  	14,1,14,1,14,1,14,1,14,3,14,1501,8,14,1,14,1,14,1,14,1,14,3,14,1507,8,
  	14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,3,14,1516,8,14,1,14,1,14,1,14,1,
  	14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,1,14,3,14,1530,8,14,1,15,1,15,3,
  	15,1534,8,15,1,15,1,15,1,15,1,15,3,15,1540,8,15,5,15,1542,8,15,10,15,
  	12,15,1545,9,15,1,16,1,16,1,16,3,16,1550,8,16,1,17,1,17,3,17,1554,8,17,
  	1,17,1,17,1,17,3,17,1559,8,17,1,17,3,17,1562,8,17,1,17,1,17,1,17,1,17,
  	3,17,1568,8,17,1,17,1,17,1,17,1,17,3,17,1574,8,17,1,17,1,17,1,17,1,17,
  	3,17,1580,8,17,1,17,1,17,3,17,1584,8,17,1,17,1,17,1,17,3,17,1589,8,17,
  	1,17,1,17,3,17,1593,8,17,1,17,1,17,3,17,1597,8,17,1,17,1,17,1,17,1,17,
  	1,17,1,17,3,17,1605,8,17,3,17,1607,8,17,1,17,1,17,1,17,1,17,1,17,1,17,
  	1,17,1,17,1,17,1,17,1,17,3,17,1620,8,17,1,17,1,17,1,17,1,17,1,17,1,17,
  	3,17,1628,8,17,1,17,1,17,1,17,1,17,1,17,1,17,3,17,1636,8,17,1,17,1,17,
  	3,17,1640,8,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,
  	1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,
  	1,17,1,17,3,17,1669,8,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,17,
  	1,17,1,17,1,17,1,17,1,17,3,17,1685,8,17,1,17,3,17,1688,8,17,1,17,1,17,
  	1,17,1,17,1,17,1,17,1,17,3,17,1697,8,17,1,18,1,18,1,18,3,18,1702,8,18,
  	1,19,1,19,1,20,1,20,3,20,1708,8,20,1,20,1,20,1,20,3,20,1713,8,20,5,20,
  	1715,8,20,10,20,12,20,1718,9,20,1,21,1,21,3,21,1722,8,21,1,21,1,21,3,
  	21,1726,8,21,1,22,1,22,3,22,1730,8,22,1,22,1,22,3,22,1734,8,22,1,23,1,
  	23,3,23,1738,8,23,1,23,1,23,3,23,1742,8,23,3,23,1744,8,23,1,24,1,24,1,
  	24,1,24,1,25,1,25,1,25,1,26,1,26,3,26,1755,8,26,1,27,1,27,1,27,1,27,1,
  	27,1,27,3,27,1763,8,27,1,27,1,27,1,27,1,27,1,27,1,27,1,27,3,27,1772,8,
  	27,1,27,5,27,1775,8,27,10,27,12,27,1778,9,27,3,27,1780,8,27,1,27,1,27,
  	1,27,3,27,1785,8,27,1,27,1,27,1,27,1,27,1,27,3,27,1792,8,27,1,28,1,28,
  	1,28,1,28,1,28,1,28,3,28,1800,8,28,1,29,1,29,3,29,1804,8,29,1,29,5,29,
  	1807,8,29,10,29,12,29,1810,9,29,1,30,1,30,1,31,1,31,3,31,1816,8,31,1,
  	31,5,31,1819,8,31,10,31,12,31,1822,9,31,1,32,1,32,3,32,1826,8,32,1,32,
  	1,32,1,32,1,32,1,32,1,32,3,32,1834,8,32,1,33,1,33,3,33,1838,8,33,1,33,
  	1,33,1,33,3,33,1843,8,33,1,34,3,34,1846,8,34,1,34,3,34,1849,8,34,1,34,
  	3,34,1852,8,34,1,34,1,34,1,34,1,34,1,35,3,35,1859,8,35,1,35,1,35,1,35,
  	1,36,1,36,3,36,1866,8,36,1,37,1,37,3,37,1870,8,37,1,37,1,37,1,37,1,38,
  	1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,1,38,
  	1,38,1,38,1,38,1,38,3,38,1894,8,38,1,39,1,39,3,39,1898,8,39,1,39,1,39,
  	5,39,1902,8,39,10,39,12,39,1905,9,39,1,40,1,40,1,40,1,40,3,40,1911,8,
  	40,1,41,3,41,1914,8,41,1,41,1,41,3,41,1918,8,41,1,41,1,41,1,41,1,41,1,
  	41,3,41,1925,8,41,1,41,3,41,1928,8,41,1,41,3,41,1931,8,41,1,41,3,41,1934,
  	8,41,1,41,1,41,1,41,1,41,1,41,1,41,1,41,3,41,1943,8,41,1,42,1,42,1,42,
  	5,42,1948,8,42,10,42,12,42,1951,9,42,1,43,1,43,3,43,1955,8,43,1,44,3,
  	44,1958,8,44,1,44,3,44,1961,8,44,1,44,1,44,1,45,1,45,3,45,1967,8,45,1,
  	46,1,46,1,46,1,46,3,46,1973,8,46,1,46,3,46,1976,8,46,1,46,1,46,1,47,3,
  	47,1981,8,47,1,47,1,47,1,47,1,47,1,47,1,47,5,47,1989,8,47,10,47,12,47,
  	1992,9,47,3,47,1994,8,47,1,47,1,47,5,47,1998,8,47,10,47,12,47,2001,9,
  	47,1,47,1,47,1,48,3,48,2006,8,48,1,48,1,48,1,48,1,48,1,48,1,48,5,48,2014,
  	8,48,10,48,12,48,2017,9,48,3,48,2019,8,48,1,48,1,48,1,48,1,48,5,48,2025,
  	8,48,10,48,12,48,2028,9,48,1,48,1,48,1,49,3,49,2033,8,49,1,49,1,49,1,
  	49,1,49,1,49,1,49,1,49,1,50,1,50,3,50,2044,8,50,1,50,3,50,2047,8,50,1,
  	51,4,51,2050,8,51,11,51,12,51,2051,1,52,1,52,1,52,1,52,1,52,1,52,1,52,
  	1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,1,52,3,52,2071,8,52,1,53,
  	3,53,2074,8,53,1,53,3,53,2077,8,53,1,53,1,53,1,53,1,53,3,53,2083,8,53,
  	1,53,3,53,2086,8,53,3,53,2088,8,53,1,53,1,53,5,53,2092,8,53,10,53,12,
  	53,2095,9,53,1,53,1,53,1,53,1,53,1,53,5,53,2102,8,53,10,53,12,53,2105,
  	9,53,1,53,1,53,1,53,1,53,1,53,5,53,2112,8,53,10,53,12,53,2115,9,53,3,
  	53,2117,8,53,1,53,3,53,2120,8,53,1,54,1,54,1,54,3,54,2125,8,54,1,54,1,
  	54,1,54,1,54,3,54,2131,8,54,1,55,1,55,1,55,1,55,1,56,1,56,1,56,1,56,1,
  	56,1,56,1,56,3,56,2144,8,56,1,57,1,57,3,57,2148,8,57,1,57,5,57,2151,8,
  	57,10,57,12,57,2154,9,57,1,58,1,58,1,58,1,58,1,58,1,58,3,58,2162,8,58,
  	1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,5,60,
  	2177,8,60,10,60,12,60,2180,9,60,1,60,1,60,1,61,1,61,1,61,1,61,1,61,1,
  	61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,2198,8,61,1,62,1,62,1,
  	62,1,62,1,62,1,62,1,62,3,62,2207,8,62,1,62,3,62,2210,8,62,1,63,1,63,1,
  	63,1,63,1,63,1,63,3,63,2218,8,63,1,64,1,64,1,64,3,64,2223,8,64,1,64,1,
  	64,3,64,2227,8,64,1,65,1,65,1,65,1,66,1,66,3,66,2234,8,66,1,66,5,66,2237,
  	8,66,10,66,12,66,2240,9,66,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,67,1,
  	67,1,67,1,67,1,67,3,67,2254,8,67,1,68,1,68,3,68,2258,8,68,1,68,1,68,1,
  	69,1,69,3,69,2264,8,69,1,69,1,69,1,70,1,70,3,70,2270,8,70,1,70,1,70,1,
  	71,1,71,3,71,2276,8,71,1,71,1,71,1,72,1,72,3,72,2282,8,72,1,72,1,72,1,
  	73,1,73,3,73,2288,8,73,1,73,1,73,1,74,3,74,2293,8,74,1,74,1,74,3,74,2297,
  	8,74,1,74,1,74,1,75,1,75,1,76,1,76,3,76,2305,8,76,1,76,1,76,1,77,1,77,
  	3,77,2311,8,77,1,77,1,77,1,78,1,78,3,78,2317,8,78,1,78,1,78,1,79,3,79,
  	2322,8,79,1,79,3,79,2325,8,79,1,79,3,79,2328,8,79,1,79,1,79,1,79,1,79,
  	1,80,1,80,1,80,3,80,2337,8,80,1,80,3,80,2340,8,80,1,81,1,81,1,81,1,81,
  	1,82,1,82,1,82,1,82,1,83,3,83,2351,8,83,1,83,1,83,1,83,1,83,1,83,1,83,
  	1,83,1,83,1,83,1,83,3,83,2363,8,83,1,83,1,83,1,84,1,84,1,84,1,84,1,85,
  	3,85,2372,8,85,1,85,1,85,3,85,2376,8,85,1,85,1,85,1,85,1,85,1,85,1,85,
  	1,85,3,85,2385,8,85,1,85,3,85,2388,8,85,1,85,1,85,1,85,1,85,3,85,2394,
  	8,85,3,85,2396,8,85,1,85,1,85,3,85,2400,8,85,1,85,1,85,1,85,1,86,1,86,
  	3,86,2407,8,86,1,86,1,86,1,87,1,87,1,87,1,87,1,87,1,87,1,87,5,87,2418,
  	8,87,10,87,12,87,2421,9,87,1,87,1,87,1,87,1,87,3,87,2427,8,87,1,87,1,
  	87,5,87,2431,8,87,10,87,12,87,2434,9,87,3,87,2436,8,87,1,88,1,88,1,88,
  	1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,1,88,3,88,2453,
  	8,88,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,1,89,
  	1,89,1,89,1,89,1,89,1,89,3,89,2473,8,89,1,90,1,90,3,90,2477,8,90,1,90,
  	1,90,1,91,1,91,3,91,2483,8,91,1,91,1,91,1,92,1,92,3,92,2489,8,92,1,92,
  	1,92,1,93,1,93,3,93,2495,8,93,1,93,1,93,1,94,3,94,2500,8,94,1,94,1,94,
  	1,94,1,94,1,94,3,94,2507,8,94,1,95,1,95,1,95,1,95,1,95,3,95,2514,8,95,
  	1,95,5,95,2517,8,95,10,95,12,95,2520,9,95,3,95,2522,8,95,1,96,1,96,3,
  	96,2526,8,96,1,97,1,97,3,97,2530,8,97,1,97,1,97,1,98,3,98,2535,8,98,1,
  	98,1,98,3,98,2539,8,98,1,98,1,98,3,98,2543,8,98,1,99,1,99,1,99,1,99,3,
  	99,2549,8,99,1,99,5,99,2552,8,99,10,99,12,99,2555,9,99,3,99,2557,8,99,
  	1,100,1,100,3,100,2561,8,100,1,100,1,100,1,101,1,101,3,101,2567,8,101,
  	1,101,1,101,3,101,2571,8,101,1,102,1,102,3,102,2575,8,102,1,102,1,102,
  	1,103,1,103,1,103,1,103,3,103,2583,8,103,1,103,1,103,1,104,1,104,1,104,
  	1,104,3,104,2591,8,104,1,105,1,105,1,105,1,105,1,105,5,105,2598,8,105,
  	10,105,12,105,2601,9,105,1,106,1,106,1,106,1,106,1,107,1,107,3,107,2609,
  	8,107,1,107,1,107,1,108,1,108,1,108,1,108,1,108,1,109,1,109,1,109,1,109,
  	3,109,2622,8,109,1,109,3,109,2625,8,109,1,110,1,110,3,110,2629,8,110,
  	1,110,1,110,5,110,2633,8,110,10,110,12,110,2636,9,110,1,110,1,110,1,110,
  	1,110,1,110,3,110,2643,8,110,1,110,1,110,1,110,3,110,2648,8,110,1,110,
  	3,110,2651,8,110,1,110,3,110,2654,8,110,1,110,3,110,2657,8,110,1,110,
  	3,110,2660,8,110,3,110,2662,8,110,1,110,1,110,1,110,1,110,3,110,2668,
  	8,110,3,110,2670,8,110,1,111,1,111,1,111,1,111,1,111,1,111,1,112,1,112,
  	1,113,1,113,1,113,1,113,1,113,3,113,2685,8,113,1,114,1,114,1,114,1,114,
  	3,114,2691,8,114,1,114,1,114,1,114,1,114,1,114,3,114,2698,8,114,1,114,
  	3,114,2701,8,114,3,114,2703,8,114,3,114,2705,8,114,1,115,1,115,1,115,
  	1,115,1,115,1,115,1,115,1,115,3,115,2715,8,115,3,115,2717,8,115,1,116,
  	1,116,3,116,2721,8,116,1,116,3,116,2724,8,116,1,116,3,116,2727,8,116,
  	1,116,1,116,3,116,2731,8,116,1,116,1,116,1,116,3,116,2736,8,116,1,116,
  	1,116,1,116,1,116,3,116,2742,8,116,1,116,3,116,2745,8,116,1,116,3,116,
  	2748,8,116,1,117,1,117,1,118,1,118,3,118,2754,8,118,1,118,3,118,2757,
  	8,118,1,118,1,118,1,119,1,119,1,119,5,119,2764,8,119,10,119,12,119,2767,
  	9,119,1,120,1,120,1,120,1,121,1,121,1,121,3,121,2775,8,121,1,121,1,121,
  	3,121,2779,8,121,1,122,1,122,3,122,2783,8,122,1,122,1,122,1,122,1,122,
  	3,122,2789,8,122,1,122,5,122,2792,8,122,10,122,12,122,2795,9,122,1,123,
  	1,123,3,123,2799,8,123,1,123,1,123,1,123,3,123,2804,8,123,5,123,2806,
  	8,123,10,123,12,123,2809,9,123,1,124,1,124,1,124,3,124,2814,8,124,1,125,
  	1,125,1,125,1,125,1,125,1,125,1,126,1,126,1,126,3,126,2825,8,126,1,126,
  	3,126,2828,8,126,1,126,1,126,1,126,3,126,2833,8,126,1,126,1,126,1,126,
  	1,126,3,126,2839,8,126,1,126,3,126,2842,8,126,1,126,3,126,2845,8,126,
  	1,126,3,126,2848,8,126,1,126,3,126,2851,8,126,1,126,1,126,1,127,1,127,
  	1,128,1,128,1,128,1,128,1,128,1,129,1,129,1,129,3,129,2865,8,129,1,129,
  	3,129,2868,8,129,1,129,1,129,3,129,2872,8,129,1,130,1,130,3,130,2876,
  	8,130,1,130,1,130,1,131,1,131,3,131,2882,8,131,1,131,1,131,1,131,3,131,
  	2887,8,131,5,131,2889,8,131,10,131,12,131,2892,9,131,1,132,1,132,3,132,
  	2896,8,132,1,132,3,132,2899,8,132,1,132,1,132,3,132,2903,8,132,1,132,
  	1,132,1,132,1,132,3,132,2909,8,132,1,133,1,133,3,133,2913,8,133,1,133,
  	1,133,3,133,2917,8,133,1,134,1,134,1,134,1,134,1,134,1,134,1,134,3,134,
  	2926,8,134,1,134,1,134,1,134,3,134,2931,8,134,1,135,1,135,3,135,2935,
  	8,135,1,135,1,135,3,135,2939,8,135,1,135,3,135,2942,8,135,1,135,1,135,
  	3,135,2946,8,135,1,135,3,135,2949,8,135,3,135,2951,8,135,1,135,1,135,
  	3,135,2955,8,135,1,136,1,136,1,136,1,136,3,136,2961,8,136,1,136,1,136,
  	3,136,2965,8,136,3,136,2967,8,136,1,136,1,136,3,136,2971,8,136,1,136,
  	1,136,3,136,2975,8,136,5,136,2977,8,136,10,136,12,136,2980,9,136,1,137,
  	1,137,1,137,1,137,3,137,2986,8,137,3,137,2988,8,137,1,137,1,137,1,138,
  	1,138,1,138,1,138,1,138,3,138,2997,8,138,1,139,1,139,5,139,3001,8,139,
  	10,139,12,139,3004,9,139,1,139,1,139,3,139,3008,8,139,1,139,3,139,3011,
  	8,139,1,139,3,139,3014,8,139,1,139,3,139,3017,8,139,1,139,3,139,3020,
  	8,139,1,139,1,139,3,139,3024,8,139,1,140,1,140,1,141,1,141,1,142,1,142,
  	1,142,1,143,1,143,1,143,1,144,1,144,1,144,3,144,3039,8,144,1,145,1,145,
  	3,145,3043,8,145,1,146,1,146,1,146,1,146,3,146,3049,8,146,1,146,3,146,
  	3052,8,146,1,146,3,146,3055,8,146,1,146,1,146,1,146,1,146,3,146,3061,
  	8,146,1,146,1,146,1,146,3,146,3066,8,146,5,146,3068,8,146,10,146,12,146,
  	3071,9,146,3,146,3073,8,146,1,147,1,147,1,147,1,147,1,147,1,147,3,147,
  	3081,8,147,3,147,3083,8,147,1,147,1,147,1,148,1,148,1,148,1,149,1,149,
  	1,149,1,149,5,149,3094,8,149,10,149,12,149,3097,9,149,1,150,1,150,1,150,
  	1,150,1,151,1,151,1,151,1,151,1,152,3,152,3108,8,152,1,152,1,152,1,152,
  	3,152,3113,8,152,1,152,3,152,3116,8,152,1,152,3,152,3119,8,152,1,153,
  	1,153,1,153,3,153,3124,8,153,1,154,1,154,1,155,1,155,3,155,3130,8,155,
  	1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,1,156,
  	1,156,1,156,3,156,3146,8,156,1,157,1,157,1,157,1,157,1,157,1,158,1,158,
  	1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,1,158,3,158,
  	3166,8,158,1,159,1,159,1,159,1,159,1,159,1,159,1,159,3,159,3175,8,159,
  	1,160,1,160,3,160,3179,8,160,1,160,1,160,1,160,5,160,3184,8,160,10,160,
  	12,160,3187,9,160,1,161,1,161,3,161,3191,8,161,1,161,1,161,1,161,1,162,
  	1,162,1,162,1,162,3,162,3200,8,162,1,163,1,163,1,163,1,163,1,163,3,163,
  	3207,8,163,1,164,1,164,1,164,1,164,1,165,1,165,1,166,1,166,1,166,3,166,
  	3218,8,166,1,167,1,167,1,167,5,167,3223,8,167,10,167,12,167,3226,9,167,
  	1,168,1,168,1,168,1,168,5,168,3232,8,168,10,168,12,168,3235,9,168,1,169,
  	1,169,1,169,1,170,1,170,1,170,3,170,3243,8,170,1,170,1,170,1,171,1,171,
  	1,171,1,171,1,171,1,171,1,171,1,171,3,171,3255,8,171,1,172,4,172,3258,
  	8,172,11,172,12,172,3259,1,173,1,173,1,173,1,173,1,173,3,173,3267,8,173,
  	1,173,1,173,3,173,3271,8,173,1,173,1,173,1,173,1,173,3,173,3277,8,173,
  	1,174,1,174,1,174,3,174,3282,8,174,1,175,1,175,1,175,3,175,3287,8,175,
  	1,176,1,176,3,176,3291,8,176,1,176,1,176,5,176,3295,8,176,10,176,12,176,
  	3298,9,176,1,177,1,177,1,177,3,177,3303,8,177,3,177,3305,8,177,1,178,
  	3,178,3308,8,178,1,178,1,178,3,178,3312,8,178,1,179,1,179,1,179,1,180,
  	1,180,1,180,1,180,1,180,3,180,3322,8,180,1,180,1,180,1,180,3,180,3327,
  	8,180,1,180,5,180,3330,8,180,10,180,12,180,3333,9,180,1,181,1,181,5,181,
  	3337,8,181,10,181,12,181,3340,9,181,1,182,1,182,1,182,1,182,1,182,1,182,
  	3,182,3348,8,182,1,182,1,182,1,182,1,182,1,182,1,182,3,182,3356,8,182,
  	1,182,1,182,1,182,3,182,3361,8,182,1,183,1,183,3,183,3365,8,183,1,183,
  	1,183,1,183,1,183,3,183,3371,8,183,1,183,3,183,3374,8,183,1,184,3,184,
  	3377,8,184,1,184,1,184,3,184,3381,8,184,1,185,1,185,3,185,3385,8,185,
  	1,185,1,185,1,186,1,186,1,186,1,186,1,186,1,186,3,186,3395,8,186,1,187,
  	1,187,3,187,3399,8,187,1,187,3,187,3402,8,187,1,187,3,187,3405,8,187,
  	1,188,1,188,1,188,3,188,3410,8,188,1,188,1,188,1,189,1,189,3,189,3416,
  	8,189,1,189,1,189,3,189,3420,8,189,1,189,1,189,1,189,1,189,3,189,3426,
  	8,189,1,189,3,189,3429,8,189,3,189,3431,8,189,1,190,1,190,1,190,3,190,
  	3436,8,190,1,190,1,190,1,191,1,191,1,191,1,191,1,191,1,191,1,191,1,191,
  	3,191,3448,8,191,1,192,1,192,1,192,1,192,1,192,5,192,3455,8,192,10,192,
  	12,192,3458,9,192,1,192,1,192,1,193,1,193,1,193,1,193,1,193,1,193,1,193,
  	1,193,3,193,3470,8,193,1,193,3,193,3473,8,193,1,193,1,193,1,193,3,193,
  	3478,8,193,1,193,1,193,1,193,1,193,1,193,3,193,3485,8,193,1,194,1,194,
  	3,194,3489,8,194,1,194,1,194,3,194,3493,8,194,3,194,3495,8,194,1,195,
  	1,195,1,195,1,195,1,196,1,196,1,196,1,196,1,197,1,197,1,197,1,197,3,197,
  	3509,8,197,1,198,1,198,1,199,1,199,1,199,3,199,3516,8,199,1,199,1,199,
  	1,200,1,200,1,200,5,200,3523,8,200,10,200,12,200,3526,9,200,1,201,1,201,
  	1,201,3,201,3531,8,201,1,201,1,201,1,201,1,201,1,201,1,201,1,201,3,201,
  	3540,8,201,1,201,1,201,3,201,3544,8,201,1,201,1,201,3,201,3548,8,201,
  	1,202,1,202,1,203,1,203,1,204,1,204,1,204,1,204,3,204,3558,8,204,3,204,
  	3560,8,204,1,205,1,205,1,205,1,205,1,205,1,205,3,205,3568,8,205,1,206,
  	1,206,1,206,5,206,3573,8,206,10,206,12,206,3576,9,206,1,207,1,207,3,207,
  	3580,8,207,1,208,1,208,3,208,3584,8,208,1,208,1,208,3,208,3588,8,208,
  	1,208,3,208,3591,8,208,1,208,1,208,1,208,1,208,3,208,3597,8,208,1,208,
  	3,208,3600,8,208,1,208,3,208,3603,8,208,1,209,1,209,1,209,1,209,3,209,
  	3609,8,209,1,210,1,210,1,210,5,210,3614,8,210,10,210,12,210,3617,9,210,
  	1,210,1,210,3,210,3621,8,210,1,210,1,210,3,210,3625,8,210,1,210,3,210,
  	3628,8,210,1,210,3,210,3631,8,210,1,210,3,210,3634,8,210,3,210,3636,8,
  	210,1,211,1,211,3,211,3640,8,211,1,212,1,212,1,212,1,212,1,212,1,212,
  	3,212,3648,8,212,1,213,1,213,1,213,1,213,3,213,3654,8,213,1,213,1,213,
  	3,213,3658,8,213,1,213,1,213,1,213,3,213,3663,8,213,1,213,3,213,3666,
  	8,213,1,213,3,213,3669,8,213,1,213,3,213,3672,8,213,3,213,3674,8,213,
  	1,213,1,213,1,213,3,213,3679,8,213,1,214,1,214,1,214,1,214,1,214,5,214,
  	3686,8,214,10,214,12,214,3689,9,214,1,214,1,214,1,214,1,214,1,214,1,214,
  	1,214,1,214,1,214,1,214,3,214,3701,8,214,3,214,3703,8,214,1,215,1,215,
  	3,215,3707,8,215,1,215,1,215,1,216,1,216,3,216,3713,8,216,1,216,3,216,
  	3716,8,216,1,216,3,216,3719,8,216,1,217,1,217,1,217,1,217,3,217,3725,
  	8,217,1,217,1,217,1,217,1,217,1,217,3,217,3732,8,217,3,217,3734,8,217,
  	1,217,1,217,1,217,1,217,1,217,1,217,3,217,3742,8,217,1,217,1,217,1,217,
  	1,217,3,217,3748,8,217,1,218,1,218,1,218,3,218,3753,8,218,1,218,3,218,
  	3756,8,218,1,219,1,219,1,219,1,219,1,219,3,219,3763,8,219,3,219,3765,
  	8,219,1,220,1,220,1,220,1,220,1,220,1,220,1,220,3,220,3774,8,220,1,220,
  	1,220,1,220,1,220,1,220,5,220,3781,8,220,10,220,12,220,3784,9,220,1,220,
  	1,220,1,220,1,220,1,220,1,220,3,220,3792,8,220,1,220,1,220,1,220,1,220,
  	1,220,1,220,3,220,3800,8,220,1,221,1,221,3,221,3804,8,221,1,221,1,221,
  	1,221,1,221,1,221,3,221,3811,8,221,1,221,3,221,3814,8,221,3,221,3816,
  	8,221,1,222,1,222,1,222,1,222,1,222,1,222,3,222,3824,8,222,1,223,1,223,
  	1,223,1,223,3,223,3830,8,223,1,223,1,223,1,223,1,224,1,224,1,224,1,224,
  	1,224,3,224,3840,8,224,1,225,1,225,1,225,5,225,3845,8,225,10,225,12,225,
  	3848,9,225,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,
  	1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,1,226,3,226,3941,8,226,
  	1,227,1,227,3,227,3945,8,227,1,228,1,228,1,229,1,229,3,229,3951,8,229,
  	1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,1,230,
  	3,230,3965,8,230,1,231,1,231,1,231,1,231,5,231,3971,8,231,10,231,12,231,
  	3974,9,231,3,231,3976,8,231,1,231,1,231,1,232,1,232,1,232,1,232,1,232,
  	1,232,5,232,3986,8,232,10,232,12,232,3989,9,232,1,232,1,232,3,232,3993,
  	8,232,1,233,1,233,1,233,1,233,3,233,3999,8,233,1,233,1,233,1,233,1,233,
  	1,233,3,233,4006,8,233,1,233,1,233,1,233,1,233,1,233,3,233,4013,8,233,
  	1,233,1,233,1,233,1,233,1,233,3,233,4020,8,233,1,233,1,233,1,233,1,233,
  	1,233,3,233,4027,8,233,1,233,1,233,1,233,1,233,1,233,3,233,4034,8,233,
  	1,233,1,233,1,233,1,233,1,233,3,233,4041,8,233,1,233,3,233,4044,8,233,
  	1,234,1,234,1,234,5,234,4049,8,234,10,234,12,234,4052,9,234,1,235,1,235,
  	1,235,5,235,4057,8,235,10,235,12,235,4060,9,235,1,236,1,236,1,236,5,236,
  	4065,8,236,10,236,12,236,4068,9,236,1,237,1,237,1,238,1,238,1,238,5,238,
  	4075,8,238,10,238,12,238,4078,9,238,1,239,1,239,1,239,3,239,4083,8,239,
  	1,239,1,239,3,239,4087,8,239,1,239,1,239,3,239,4091,8,239,1,239,1,239,
  	1,239,3,239,4096,8,239,1,239,3,239,4099,8,239,3,239,4101,8,239,1,240,
  	1,240,1,240,1,240,1,240,1,240,1,240,3,240,4110,8,240,1,240,1,240,5,240,
  	4114,8,240,10,240,12,240,4117,9,240,1,241,1,241,1,241,1,241,3,241,4123,
  	8,241,1,241,1,241,1,241,3,241,4128,8,241,1,241,1,241,1,241,3,241,4133,
  	8,241,1,241,1,241,1,241,3,241,4138,8,241,1,241,3,241,4141,8,241,1,242,
  	1,242,1,242,5,242,4146,8,242,10,242,12,242,4149,9,242,1,243,1,243,1,244,
  	1,244,1,244,1,245,1,245,1,245,1,245,1,245,3,245,4161,8,245,1,245,1,245,
  	1,245,1,245,3,245,4167,8,245,1,246,1,246,1,246,1,246,3,246,4173,8,246,
  	1,247,1,247,1,247,5,247,4178,8,247,10,247,12,247,4181,9,247,1,248,1,248,
  	1,248,1,248,1,248,3,248,4188,8,248,1,248,1,248,1,248,1,248,3,248,4194,
  	8,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248,1,248,3,248,
  	4206,8,248,3,248,4208,8,248,1,249,1,249,1,249,1,249,3,249,4214,8,249,
  	1,249,1,249,3,249,4218,8,249,3,249,4220,8,249,1,250,1,250,3,250,4224,
  	8,250,1,250,1,250,1,251,1,251,1,251,1,251,1,251,1,251,1,251,1,251,1,251,
  	3,251,4237,8,251,1,252,1,252,1,252,1,252,3,252,4243,8,252,1,252,1,252,
  	1,253,1,253,1,253,1,253,3,253,4251,8,253,1,253,1,253,1,253,1,253,1,253,
  	1,253,1,253,1,253,1,253,3,253,4262,8,253,1,253,1,253,3,253,4266,8,253,
  	1,253,1,253,1,253,1,253,1,253,1,253,1,253,1,253,1,253,1,253,1,253,3,253,
  	4279,8,253,1,253,1,253,1,253,1,253,1,253,3,253,4286,8,253,1,253,1,253,
  	1,253,1,253,3,253,4292,8,253,1,253,1,253,1,253,1,253,1,253,3,253,4299,
  	8,253,3,253,4301,8,253,1,254,1,254,1,254,1,255,1,255,1,255,1,255,1,255,
  	3,255,4311,8,255,1,255,1,255,1,255,1,255,1,256,1,256,3,256,4319,8,256,
  	1,256,3,256,4322,8,256,1,256,5,256,4325,8,256,10,256,12,256,4328,9,256,
  	1,256,3,256,4331,8,256,1,257,1,257,1,257,1,257,3,257,4337,8,257,1,257,
  	3,257,4340,8,257,1,258,1,258,1,258,3,258,4345,8,258,1,259,1,259,1,259,
  	1,259,1,259,1,259,1,259,1,259,1,259,4,259,4356,8,259,11,259,12,259,4357,
  	1,260,1,260,1,260,1,260,1,260,1,260,1,260,1,260,1,260,1,260,3,260,4370,
  	8,260,1,260,1,260,1,260,3,260,4375,8,260,1,260,1,260,1,260,1,260,1,260,
  	1,260,3,260,4383,8,260,1,260,1,260,1,260,1,260,3,260,4389,8,260,3,260,
  	4391,8,260,3,260,4393,8,260,1,261,1,261,1,261,1,261,3,261,4399,8,261,
  	1,261,1,261,1,262,1,262,1,262,1,262,1,262,1,262,1,262,1,262,3,262,4411,
  	8,262,1,262,1,262,1,262,3,262,4416,8,262,3,262,4418,8,262,1,262,1,262,
  	3,262,4422,8,262,1,262,1,262,1,262,1,262,3,262,4428,8,262,1,262,3,262,
  	4431,8,262,1,262,3,262,4434,8,262,1,262,1,262,1,262,1,262,1,262,1,262,
  	1,262,1,262,3,262,4444,8,262,3,262,4446,8,262,1,263,1,263,1,263,1,263,
  	3,263,4452,8,263,1,264,1,264,1,264,4,264,4457,8,264,11,264,12,264,4458,
  	1,264,1,264,1,264,1,264,3,264,4465,8,264,1,265,1,265,1,265,1,266,1,266,
  	1,266,1,266,1,266,3,266,4475,8,266,1,266,1,266,3,266,4479,8,266,1,267,
  	1,267,1,267,3,267,4484,8,267,1,268,1,268,1,268,1,269,1,269,1,269,1,269,
  	1,269,1,269,1,269,1,269,1,269,1,269,5,269,4499,8,269,10,269,12,269,4502,
  	9,269,1,270,1,270,1,270,1,270,1,270,1,270,1,270,1,270,1,270,1,270,1,270,
  	1,270,1,270,3,270,4517,8,270,1,270,1,270,1,270,3,270,4522,8,270,1,270,
  	1,270,1,270,1,270,1,270,1,270,3,270,4530,8,270,1,270,1,270,1,270,1,270,
  	1,270,1,270,3,270,4538,8,270,1,271,1,271,1,271,3,271,4543,8,271,1,271,
  	1,271,1,271,1,271,3,271,4549,8,271,1,271,3,271,4552,8,271,3,271,4554,
  	8,271,1,272,1,272,1,273,1,273,1,273,5,273,4561,8,273,10,273,12,273,4564,
  	9,273,1,274,1,274,1,274,3,274,4569,8,274,1,274,1,274,1,274,1,274,3,274,
  	4575,8,274,3,274,4577,8,274,1,274,1,274,3,274,4581,8,274,1,274,1,274,
  	1,274,1,274,1,274,1,274,1,274,1,274,1,274,3,274,4592,8,274,1,274,1,274,
  	1,274,1,274,1,274,1,274,1,274,1,274,3,274,4602,8,274,1,274,1,274,1,274,
  	3,274,4607,8,274,1,275,1,275,1,275,3,275,4612,8,275,1,275,1,275,1,275,
  	3,275,4617,8,275,1,275,1,275,1,275,1,275,1,275,1,275,3,275,4625,8,275,
  	1,276,1,276,3,276,4629,8,276,1,276,5,276,4632,8,276,10,276,12,276,4635,
  	9,276,1,277,1,277,1,277,1,277,1,277,1,277,3,277,4643,8,277,1,278,1,278,
  	1,278,1,278,1,278,1,278,1,278,1,278,1,278,1,278,3,278,4655,8,278,1,279,
  	1,279,1,279,1,279,1,279,1,279,1,279,1,279,1,279,1,279,1,279,1,279,3,279,
  	4669,8,279,1,279,1,279,1,279,1,279,1,279,1,279,1,279,3,279,4678,8,279,
  	3,279,4680,8,279,1,280,1,280,1,280,5,280,4685,8,280,10,280,12,280,4688,
  	9,280,1,281,1,281,1,281,1,281,3,281,4694,8,281,1,282,1,282,3,282,4698,
  	8,282,1,282,1,282,1,282,1,282,3,282,4704,8,282,1,282,1,282,1,282,1,282,
  	5,282,4710,8,282,10,282,12,282,4713,9,282,1,282,1,282,1,282,1,282,3,282,
  	4719,8,282,1,282,1,282,3,282,4723,8,282,1,282,1,282,1,282,1,282,3,282,
  	4729,8,282,1,282,1,282,1,282,5,282,4734,8,282,10,282,12,282,4737,9,282,
  	3,282,4739,8,282,1,283,1,283,1,283,1,283,1,283,1,283,1,283,3,283,4748,
  	8,283,1,283,1,283,1,283,1,283,3,283,4754,8,283,1,284,1,284,1,284,3,284,
  	4759,8,284,1,285,1,285,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,
  	1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,1,286,5,286,4780,8,286,
  	10,286,12,286,4783,9,286,3,286,4785,8,286,1,287,1,287,1,287,1,288,1,288,
  	1,288,1,288,1,288,1,288,1,288,1,288,1,288,1,288,1,288,3,288,4801,8,288,
  	1,288,1,288,1,288,3,288,4806,8,288,1,288,3,288,4809,8,288,1,288,1,288,
  	3,288,4813,8,288,1,288,3,288,4816,8,288,1,288,1,288,1,288,1,288,1,288,
  	1,288,1,288,1,288,1,288,1,288,1,288,1,288,3,288,4830,8,288,1,288,1,288,
  	1,288,1,288,3,288,4836,8,288,1,288,1,288,1,288,3,288,4841,8,288,1,288,
  	3,288,4844,8,288,3,288,4846,8,288,1,289,1,289,3,289,4850,8,289,1,289,
  	1,289,1,289,3,289,4855,8,289,3,289,4857,8,289,1,290,1,290,1,290,1,291,
  	1,291,1,291,1,291,1,291,1,291,1,291,3,291,4869,8,291,1,292,1,292,5,292,
  	4873,8,292,10,292,12,292,4876,9,292,1,293,1,293,1,293,1,293,1,293,1,293,
  	1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,293,1,293,
  	1,293,3,293,4897,8,293,1,293,1,293,3,293,4901,8,293,3,293,4903,8,293,
  	1,294,1,294,1,294,1,294,1,294,1,294,3,294,4911,8,294,1,295,1,295,3,295,
  	4915,8,295,1,295,1,295,1,296,1,296,1,296,1,296,1,296,3,296,4924,8,296,
  	1,297,1,297,1,297,1,297,1,298,1,298,1,298,1,298,3,298,4934,8,298,1,299,
  	1,299,1,299,1,299,1,299,3,299,4941,8,299,1,299,3,299,4944,8,299,1,299,
  	1,299,3,299,4948,8,299,1,299,3,299,4951,8,299,1,299,3,299,4954,8,299,
  	1,299,1,299,3,299,4958,8,299,1,299,3,299,4961,8,299,1,299,1,299,3,299,
  	4965,8,299,1,299,3,299,4968,8,299,1,299,1,299,1,299,3,299,4973,8,299,
  	1,299,3,299,4976,8,299,1,299,1,299,1,299,3,299,4981,8,299,1,299,3,299,
  	4984,8,299,1,299,1,299,1,299,1,299,3,299,4990,8,299,1,299,1,299,3,299,
  	4994,8,299,1,299,1,299,1,299,1,299,3,299,5000,8,299,1,299,3,299,5003,
  	8,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,3,299,5012,8,299,3,299,
  	5014,8,299,1,299,1,299,1,299,1,299,3,299,5020,8,299,1,299,1,299,3,299,
  	5024,8,299,1,299,3,299,5027,8,299,1,299,3,299,5030,8,299,1,299,1,299,
  	3,299,5034,8,299,1,299,1,299,1,299,1,299,3,299,5040,8,299,1,299,3,299,
  	5043,8,299,1,299,3,299,5046,8,299,1,299,1,299,1,299,1,299,1,299,1,299,
  	1,299,1,299,3,299,5056,8,299,1,299,1,299,3,299,5060,8,299,1,299,1,299,
  	1,299,1,299,1,299,5,299,5067,8,299,10,299,12,299,5070,9,299,3,299,5072,
  	8,299,1,299,1,299,1,299,3,299,5077,8,299,1,299,3,299,5080,8,299,1,299,
  	3,299,5083,8,299,1,299,1,299,3,299,5087,8,299,1,299,3,299,5090,8,299,
  	1,299,1,299,1,299,3,299,5095,8,299,1,299,1,299,3,299,5099,8,299,1,299,
  	1,299,1,299,1,299,1,299,1,299,3,299,5107,8,299,1,299,1,299,1,299,1,299,
  	1,299,1,299,1,299,1,299,1,299,1,299,1,299,3,299,5120,8,299,1,299,1,299,
  	1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,1,299,
  	1,299,1,299,3,299,5138,8,299,1,299,1,299,1,299,3,299,5143,8,299,1,299,
  	1,299,1,299,3,299,5148,8,299,1,299,1,299,1,299,1,299,1,299,1,299,3,299,
  	5156,8,299,1,300,1,300,1,300,1,300,3,300,5162,8,300,3,300,5164,8,300,
  	1,301,1,301,3,301,5168,8,301,1,301,3,301,5171,8,301,1,302,1,302,1,303,
  	1,303,1,303,1,304,1,304,1,304,1,304,1,304,1,304,1,304,3,304,5185,8,304,
  	1,305,1,305,1,305,1,305,1,305,1,305,1,305,1,305,3,305,5195,8,305,1,305,
  	1,305,3,305,5199,8,305,1,305,1,305,1,305,1,305,5,305,5205,8,305,10,305,
  	12,305,5208,9,305,3,305,5210,8,305,1,305,1,305,3,305,5214,8,305,1,305,
  	1,305,1,305,1,305,1,305,1,305,1,305,1,305,3,305,5224,8,305,1,306,1,306,
  	3,306,5228,8,306,1,307,1,307,1,307,5,307,5233,8,307,10,307,12,307,5236,
  	9,307,1,308,1,308,3,308,5240,8,308,1,309,1,309,1,309,1,309,1,309,1,309,
  	3,309,5248,8,309,1,310,1,310,1,310,3,310,5253,8,310,1,310,1,310,1,311,
  	1,311,3,311,5259,8,311,1,312,1,312,1,312,5,312,5264,8,312,10,312,12,312,
  	5267,9,312,1,313,1,313,3,313,5271,8,313,1,313,1,313,1,313,1,313,3,313,
  	5277,8,313,1,313,1,313,1,313,1,313,1,313,3,313,5284,8,313,1,314,1,314,
  	1,315,1,315,1,315,1,315,1,315,1,315,3,315,5294,8,315,3,315,5296,8,315,
  	1,316,1,316,1,316,1,316,1,316,1,316,3,316,5304,8,316,1,317,1,317,1,317,
  	3,317,5309,8,317,1,317,1,317,3,317,5313,8,317,1,317,3,317,5316,8,317,
  	1,318,1,318,1,318,5,318,5321,8,318,10,318,12,318,5324,9,318,1,319,1,319,
  	3,319,5328,8,319,1,319,1,319,3,319,5332,8,319,1,320,1,320,1,320,1,320,
  	1,320,1,321,1,321,1,321,1,321,3,321,5343,8,321,1,322,1,322,1,322,1,322,
  	1,322,1,322,3,322,5351,8,322,1,322,1,322,3,322,5355,8,322,1,322,3,322,
  	5358,8,322,1,322,3,322,5361,8,322,1,323,1,323,3,323,5365,8,323,1,323,
  	1,323,3,323,5369,8,323,1,323,5,323,5372,8,323,10,323,12,323,5375,9,323,
  	1,324,1,324,1,324,3,324,5380,8,324,1,325,1,325,3,325,5384,8,325,1,325,
  	1,325,1,326,1,326,1,327,1,327,1,327,1,327,1,327,3,327,5395,8,327,1,327,
  	3,327,5398,8,327,1,327,3,327,5401,8,327,1,327,3,327,5404,8,327,1,328,
  	1,328,1,328,1,328,1,328,1,328,3,328,5412,8,328,1,329,1,329,3,329,5416,
  	8,329,1,329,5,329,5419,8,329,10,329,12,329,5422,9,329,1,330,1,330,1,330,
  	1,330,1,330,3,330,5429,8,330,1,331,1,331,1,331,1,331,1,331,1,331,3,331,
  	5437,8,331,1,332,1,332,1,332,1,332,3,332,5443,8,332,1,333,1,333,1,333,
  	1,333,1,333,1,333,1,333,1,333,1,333,1,333,1,333,1,333,1,333,1,333,1,333,
  	1,333,3,333,5461,8,333,1,333,1,333,1,334,1,334,1,334,1,334,1,334,1,334,
  	3,334,5471,8,334,1,334,1,334,1,334,1,334,3,334,5477,8,334,1,335,1,335,
  	1,335,1,336,1,336,1,336,1,337,1,337,1,338,1,338,1,338,1,338,3,338,5491,
  	8,338,1,338,3,338,5494,8,338,1,338,1,338,3,338,5498,8,338,1,338,1,338,
  	1,338,1,338,1,338,1,338,1,338,1,338,1,338,5,338,5509,8,338,10,338,12,
  	338,5512,9,338,1,339,1,339,1,339,1,339,1,339,1,339,3,339,5520,8,339,1,
  	339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,1,339,5,339,5532,
  	8,339,10,339,12,339,5535,9,339,1,340,1,340,1,341,1,341,3,341,5541,8,341,
  	1,341,1,341,1,341,1,341,3,341,5547,8,341,1,341,1,341,1,341,1,341,3,341,
  	5553,8,341,1,342,1,342,1,342,1,342,1,342,1,342,3,342,5561,8,342,1,342,
  	1,342,1,342,1,342,1,342,1,342,1,342,1,342,1,342,3,342,5572,8,342,1,342,
  	1,342,3,342,5576,8,342,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,
  	1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,1,343,
  	1,343,1,343,1,343,1,343,1,343,1,343,1,343,5,343,5605,8,343,10,343,12,
  	343,5608,9,343,1,344,1,344,1,344,1,344,1,344,3,344,5615,8,344,1,344,1,
  	344,3,344,5619,8,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,
  	1,344,1,344,1,344,1,344,1,344,1,344,1,344,3,344,5636,8,344,1,344,1,344,
  	1,344,1,344,1,344,3,344,5643,8,344,1,344,1,344,1,344,1,344,1,344,1,344,
  	1,344,1,344,1,344,1,344,1,344,1,344,3,344,5657,8,344,1,344,1,344,1,344,
  	1,344,1,344,1,344,1,344,1,344,1,344,1,344,3,344,5669,8,344,1,344,1,344,
  	1,344,1,344,3,344,5675,8,344,1,344,1,344,1,344,4,344,5680,8,344,11,344,
  	12,344,5681,1,344,3,344,5685,8,344,1,344,1,344,1,344,1,344,1,344,1,344,
  	1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,
  	1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,1,344,
  	1,344,1,344,3,344,5719,8,344,1,344,1,344,1,344,1,344,1,344,1,344,5,344,
  	5727,8,344,10,344,12,344,5730,9,344,1,345,1,345,1,345,1,346,1,346,1,346,
  	1,346,1,346,1,346,3,346,5741,8,346,1,347,1,347,1,347,3,347,5746,8,347,
  	1,347,1,347,1,347,1,347,3,347,5752,8,347,1,347,1,347,1,347,1,347,1,347,
  	1,347,3,347,5760,8,347,1,347,1,347,1,347,1,347,1,347,3,347,5767,8,347,
  	1,347,1,347,1,347,1,347,3,347,5773,8,347,1,347,1,347,1,347,3,347,5778,
  	8,347,1,347,1,347,1,347,1,347,3,347,5784,8,347,1,347,1,347,1,347,3,347,
  	5789,8,347,1,347,1,347,1,347,3,347,5794,8,347,1,347,1,347,1,347,1,347,
  	3,347,5800,8,347,1,347,1,347,1,347,3,347,5805,8,347,1,347,1,347,1,347,
  	1,347,3,347,5811,8,347,1,347,1,347,1,347,1,347,1,347,1,347,3,347,5819,
  	8,347,1,347,1,347,1,347,1,347,1,347,1,347,3,347,5827,8,347,1,347,1,347,
  	1,347,1,347,1,347,1,347,3,347,5835,8,347,1,347,1,347,1,347,1,347,1,347,
  	1,347,3,347,5843,8,347,1,347,1,347,1,347,3,347,5848,8,347,1,347,1,347,
  	1,347,1,347,3,347,5854,8,347,1,347,1,347,1,347,3,347,5859,8,347,1,347,
  	1,347,3,347,5863,8,347,1,347,1,347,3,347,5867,8,347,1,347,1,347,1,347,
  	3,347,5872,8,347,3,347,5874,8,347,1,348,1,348,1,348,1,348,1,348,1,349,
  	1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,3,349,
  	5893,8,349,1,349,1,349,3,349,5897,8,349,1,349,1,349,1,349,1,349,1,349,
  	3,349,5904,8,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,1,349,
  	1,349,3,349,5916,8,349,1,349,3,349,5919,8,349,1,349,1,349,3,349,5923,
  	8,349,1,350,1,350,1,350,3,350,5928,8,350,1,351,1,351,1,351,3,351,5933,
  	8,351,1,351,1,351,3,351,5937,8,351,1,352,1,352,1,352,1,353,1,353,1,353,
  	1,353,1,353,3,353,5947,8,353,1,353,1,353,1,353,1,353,1,353,1,353,1,353,
  	3,353,5956,8,353,3,353,5958,8,353,1,354,3,354,5961,8,354,1,354,1,354,
  	1,355,1,355,1,355,1,355,1,355,3,355,5970,8,355,1,356,1,356,1,356,5,356,
  	5975,8,356,10,356,12,356,5978,9,356,1,357,1,357,1,357,1,357,1,357,1,357,
  	1,357,1,357,1,357,1,357,3,357,5990,8,357,1,357,1,357,1,357,3,357,5995,
  	8,357,1,358,1,358,1,358,1,358,1,358,3,358,6002,8,358,1,358,1,358,1,358,
  	1,358,3,358,6008,8,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,4,358,6032,8,358,11,358,12,358,6033,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,3,358,6065,8,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,3,358,6085,
  	8,358,1,358,1,358,1,358,1,358,3,358,6091,8,358,1,358,1,358,3,358,6095,
  	8,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,3,358,6122,8,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,3,358,6134,8,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,3,358,6147,8,358,1,358,1,358,3,358,6151,
  	8,358,1,358,1,358,3,358,6155,8,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,3,358,6183,8,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,1,358,3,358,6239,8,358,1,358,1,358,1,358,1,358,
  	1,358,1,358,1,358,1,358,3,358,6249,8,358,1,358,1,358,3,358,6253,8,358,
  	1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,1,358,3,358,6265,
  	8,358,1,358,1,358,1,358,3,358,6270,8,358,1,359,1,359,1,359,1,359,1,359,
  	1,359,1,359,1,359,1,359,1,359,1,359,3,359,6283,8,359,1,359,1,359,1,359,
  	1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,359,1,359,
  	1,359,1,359,1,359,3,359,6303,8,359,1,360,1,360,3,360,6307,8,360,1,360,
  	1,360,1,361,1,361,1,361,1,362,1,362,1,362,1,362,1,362,1,362,1,362,1,362,
  	5,362,6322,8,362,10,362,12,362,6325,9,362,3,362,6327,8,362,1,363,1,363,
  	1,363,3,363,6332,8,363,1,363,3,363,6335,8,363,1,364,1,364,1,365,1,365,
  	1,365,1,365,1,365,3,365,6344,8,365,1,365,1,365,3,365,6348,8,365,1,365,
  	1,365,1,365,1,365,3,365,6354,8,365,1,365,1,365,1,365,1,365,3,365,6360,
  	8,365,1,365,1,365,3,365,6364,8,365,1,365,1,365,1,366,1,366,1,366,1,366,
  	1,366,1,366,1,366,3,366,6375,8,366,1,366,1,366,1,366,1,366,3,366,6381,
  	8,366,3,366,6383,8,366,1,366,1,366,1,367,1,367,1,367,3,367,6390,8,367,
  	1,367,1,367,1,367,1,367,1,367,3,367,6397,8,367,1,367,1,367,3,367,6401,
  	8,367,1,368,1,368,1,368,5,368,6406,8,368,10,368,12,368,6409,9,368,1,369,
  	1,369,3,369,6413,8,369,1,370,1,370,3,370,6417,8,370,1,371,1,371,1,371,
  	3,371,6422,8,371,1,372,1,372,3,372,6426,8,372,1,372,1,372,3,372,6430,
  	8,372,1,373,1,373,1,373,3,373,6435,8,373,1,373,1,373,1,373,3,373,6440,
  	8,373,3,373,6442,8,373,1,373,1,373,3,373,6446,8,373,1,374,1,374,1,374,
  	1,375,1,375,1,375,1,376,1,376,1,376,1,377,1,377,3,377,6459,8,377,1,377,
  	1,377,3,377,6463,8,377,1,377,3,377,6466,8,377,1,377,1,377,3,377,6470,
  	8,377,1,377,1,377,3,377,6474,8,377,1,377,1,377,3,377,6478,8,377,1,377,
  	1,377,1,377,3,377,6483,8,377,1,377,1,377,3,377,6487,8,377,1,377,1,377,
  	3,377,6491,8,377,1,377,1,377,1,377,1,377,1,377,1,377,1,377,3,377,6500,
  	8,377,3,377,6502,8,377,1,378,1,378,1,378,5,378,6507,8,378,10,378,12,378,
  	6510,9,378,1,379,1,379,1,379,3,379,6515,8,379,1,380,1,380,1,381,1,381,
  	1,382,1,382,3,382,6523,8,382,1,383,1,383,1,384,1,384,1,384,1,384,1,385,
  	1,385,1,385,1,385,1,386,1,386,1,386,1,386,1,387,1,387,1,387,5,387,6542,
  	8,387,10,387,12,387,6545,9,387,1,388,1,388,3,388,6549,8,388,1,389,1,389,
  	1,389,5,389,6554,8,389,10,389,12,389,6557,9,389,1,390,1,390,1,391,1,391,
  	1,391,1,391,1,391,1,392,1,392,1,392,1,392,1,392,1,392,1,392,1,392,1,392,
  	1,392,1,392,1,392,1,392,3,392,6579,8,392,1,393,1,393,1,393,1,394,1,394,
  	1,394,1,394,1,394,1,395,1,395,1,395,1,395,1,395,1,395,3,395,6595,8,395,
  	1,396,1,396,1,396,1,397,1,397,1,397,4,397,6603,8,397,11,397,12,397,6604,
  	1,398,1,398,3,398,6609,8,398,1,398,1,398,1,398,4,398,6614,8,398,11,398,
  	12,398,6615,1,398,3,398,6619,8,398,1,398,1,398,1,398,1,399,1,399,1,399,
  	1,400,1,400,1,400,3,400,6630,8,400,1,401,1,401,1,402,1,402,1,402,1,403,
  	1,403,3,403,6639,8,403,1,403,3,403,6642,8,403,1,403,1,403,1,404,1,404,
  	1,404,3,404,6649,8,404,1,405,1,405,1,405,3,405,6654,8,405,1,406,1,406,
  	1,406,1,406,1,406,1,407,1,407,1,407,1,407,1,407,1,407,1,407,1,408,1,408,
  	1,408,1,408,1,408,1,408,1,408,1,409,1,409,1,409,4,409,6678,8,409,11,409,
  	12,409,6679,1,410,1,410,1,410,1,410,3,410,6686,8,410,1,411,1,411,1,411,
  	1,411,3,411,6692,8,411,1,411,1,411,3,411,6696,8,411,1,412,1,412,1,412,
  	1,412,1,412,1,412,1,413,1,413,3,413,6706,8,413,1,414,1,414,3,414,6710,
  	8,414,1,414,1,414,1,415,1,415,1,415,1,415,1,415,1,415,1,415,5,415,6721,
  	8,415,10,415,12,415,6724,9,415,1,415,1,415,1,416,1,416,1,416,1,416,1,
  	416,1,416,1,416,3,416,6735,8,416,1,417,1,417,1,417,1,417,1,417,1,417,
  	1,418,1,418,1,418,1,419,1,419,1,419,1,420,1,420,1,420,1,420,3,420,6753,
  	8,420,1,420,1,420,1,420,1,420,5,420,6759,8,420,10,420,12,420,6762,9,420,
  	1,420,1,420,1,420,1,420,1,420,5,420,6769,8,420,10,420,12,420,6772,9,420,
  	3,420,6774,8,420,1,421,1,421,1,421,3,421,6779,8,421,1,422,1,422,3,422,
  	6783,8,422,1,422,1,422,1,422,1,423,1,423,3,423,6790,8,423,1,423,1,423,
  	1,423,3,423,6795,8,423,1,424,1,424,1,425,1,425,1,425,3,425,6802,8,425,
  	1,425,1,425,1,425,1,425,5,425,6808,8,425,10,425,12,425,6811,9,425,3,425,
  	6813,8,425,1,426,1,426,1,426,3,426,6818,8,426,1,426,1,426,1,426,1,426,
  	5,426,6824,8,426,10,426,12,426,6827,9,426,3,426,6829,8,426,1,427,1,427,
  	1,427,1,427,1,428,1,428,1,428,1,429,1,429,1,429,1,430,1,430,3,430,6843,
  	8,430,1,430,3,430,6846,8,430,1,430,1,430,1,430,1,430,1,431,1,431,1,431,
  	1,431,1,431,1,431,1,431,3,431,6859,8,431,1,431,1,431,3,431,6863,8,431,
  	3,431,6865,8,431,1,432,1,432,1,432,3,432,6870,8,432,1,433,1,433,1,433,
  	3,433,6875,8,433,1,434,1,434,1,434,1,435,3,435,6881,8,435,1,435,1,435,
  	1,436,1,436,3,436,6887,8,436,1,436,1,436,5,436,6891,8,436,10,436,12,436,
  	6894,9,436,1,436,1,436,3,436,6898,8,436,1,436,3,436,6901,8,436,1,436,
  	1,436,5,436,6905,8,436,10,436,12,436,6908,9,436,1,436,1,436,3,436,6912,
  	8,436,1,436,3,436,6915,8,436,1,436,1,436,5,436,6919,8,436,10,436,12,436,
  	6922,9,436,1,436,3,436,6925,8,436,1,436,1,436,1,436,1,436,3,436,6931,
  	8,436,3,436,6933,8,436,1,436,3,436,6936,8,436,1,436,1,436,5,436,6940,
  	8,436,10,436,12,436,6943,9,436,1,436,1,436,1,436,3,436,6948,8,436,1,436,
  	1,436,1,436,1,436,1,436,1,436,3,436,6956,8,436,3,436,6958,8,436,3,436,
  	6960,8,436,1,437,1,437,3,437,6964,8,437,1,438,1,438,5,438,6968,8,438,
  	10,438,12,438,6971,9,438,1,438,1,438,3,438,6975,8,438,1,438,1,438,3,438,
  	6979,8,438,1,438,1,438,1,438,3,438,6984,8,438,1,438,1,438,5,438,6988,
  	8,438,10,438,12,438,6991,9,438,1,438,1,438,5,438,6995,8,438,10,438,12,
  	438,6998,9,438,3,438,7000,8,438,3,438,7002,8,438,1,439,3,439,7005,8,439,
  	1,439,1,439,1,439,1,439,1,439,1,439,1,439,1,439,3,439,7015,8,439,1,439,
  	1,439,3,439,7019,8,439,1,439,1,439,1,439,1,439,3,439,7025,8,439,1,439,
  	1,439,1,439,1,439,1,439,3,439,7032,8,439,1,439,1,439,1,439,3,439,7037,
  	8,439,1,439,1,439,1,439,1,439,1,439,1,439,1,439,1,439,1,439,1,439,1,439,
  	1,439,3,439,7051,8,439,1,439,1,439,1,439,3,439,7056,8,439,1,440,1,440,
  	1,441,1,441,1,442,1,442,3,442,7064,8,442,1,442,1,442,1,442,3,442,7069,
  	8,442,1,442,1,442,3,442,7073,8,442,1,442,3,442,7076,8,442,1,443,1,443,
  	1,443,3,443,7081,8,443,1,443,1,443,3,443,7085,8,443,1,443,1,443,1,443,
  	1,443,1,443,1,443,3,443,7093,8,443,1,443,1,443,1,443,1,443,1,443,1,443,
  	3,443,7101,8,443,3,443,7103,8,443,1,444,1,444,1,444,1,444,1,444,3,444,
  	7110,8,444,1,445,1,445,1,445,1,445,5,445,7116,8,445,10,445,12,445,7119,
  	9,445,1,445,1,445,1,446,1,446,3,446,7125,8,446,1,446,3,446,7128,8,446,
  	1,447,1,447,1,447,1,447,5,447,7134,8,447,10,447,12,447,7137,9,447,1,447,
  	1,447,1,448,1,448,1,448,3,448,7144,8,448,3,448,7146,8,448,1,449,1,449,
  	1,449,1,449,3,449,7152,8,449,1,450,1,450,1,451,1,451,3,451,7158,8,451,
  	1,452,1,452,3,452,7162,8,452,1,452,1,452,1,452,1,452,1,452,3,452,7169,
  	8,452,1,453,1,453,1,454,1,454,1,454,1,455,1,455,1,455,1,455,3,455,7180,
  	8,455,1,456,1,456,1,457,1,457,1,457,1,458,1,458,3,458,7189,8,458,1,458,
  	3,458,7192,8,458,1,458,1,458,1,458,3,458,7197,8,458,3,458,7199,8,458,
  	1,458,3,458,7202,8,458,1,458,3,458,7205,8,458,1,458,1,458,3,458,7209,
  	8,458,1,458,3,458,7212,8,458,1,458,1,458,3,458,7216,8,458,1,458,1,458,
  	1,458,3,458,7221,8,458,1,458,3,458,7224,8,458,1,458,1,458,3,458,7228,
  	8,458,1,458,3,458,7231,8,458,1,458,1,458,3,458,7235,8,458,1,458,1,458,
  	1,458,3,458,7240,8,458,1,458,1,458,3,458,7244,8,458,1,458,1,458,1,458,
  	1,458,1,458,1,458,1,458,1,458,1,458,1,458,3,458,7256,8,458,1,458,1,458,
  	3,458,7260,8,458,1,458,1,458,1,458,1,458,3,458,7266,8,458,1,458,3,458,
  	7269,8,458,1,458,1,458,1,458,3,458,7274,8,458,1,458,1,458,3,458,7278,
  	8,458,1,458,1,458,3,458,7282,8,458,1,458,1,458,1,458,3,458,7287,8,458,
  	1,458,1,458,1,458,1,458,1,458,1,458,1,458,3,458,7296,8,458,1,458,3,458,
  	7299,8,458,1,458,1,458,3,458,7303,8,458,1,458,1,458,3,458,7307,8,458,
  	1,458,3,458,7310,8,458,1,458,1,458,3,458,7314,8,458,1,458,1,458,3,458,
  	7318,8,458,1,458,1,458,1,458,3,458,7323,8,458,1,458,1,458,1,458,3,458,
  	7328,8,458,1,458,1,458,1,458,1,458,3,458,7334,8,458,1,459,1,459,1,459,
  	3,459,7339,8,459,1,460,1,460,1,460,3,460,7344,8,460,3,460,7346,8,460,
  	1,461,1,461,1,461,3,461,7351,8,461,1,461,1,461,1,462,4,462,7356,8,462,
  	11,462,12,462,7357,1,463,1,463,1,463,1,463,1,463,1,463,3,463,7366,8,463,
  	1,463,1,463,1,463,1,463,3,463,7372,8,463,3,463,7374,8,463,1,464,1,464,
  	3,464,7378,8,464,1,464,1,464,3,464,7382,8,464,1,465,1,465,3,465,7386,
  	8,465,1,465,1,465,3,465,7390,8,465,1,466,1,466,1,466,1,466,1,467,1,467,
  	1,467,1,467,1,468,1,468,1,468,1,468,3,468,7404,8,468,1,469,1,469,1,469,
  	1,469,1,469,3,469,7411,8,469,1,470,1,470,3,470,7415,8,470,1,470,5,470,
  	7418,8,470,10,470,12,470,7421,9,470,1,471,4,471,7424,8,471,11,471,12,
  	471,7425,1,472,1,472,3,472,7430,8,472,1,472,1,472,1,472,1,472,3,472,7436,
  	8,472,1,472,1,472,3,472,7440,8,472,1,472,1,472,3,472,7444,8,472,1,472,
  	1,472,1,472,3,472,7449,8,472,1,472,1,472,1,472,3,472,7454,8,472,1,472,
  	1,472,1,472,3,472,7459,8,472,1,472,1,472,1,472,3,472,7464,8,472,1,472,
  	1,472,1,472,1,472,3,472,7470,8,472,1,472,1,472,1,472,1,472,3,472,7476,
  	8,472,1,472,1,472,1,472,3,472,7481,8,472,1,472,1,472,1,472,3,472,7486,
  	8,472,1,472,1,472,1,472,3,472,7491,8,472,1,472,1,472,1,472,3,472,7496,
  	8,472,1,472,1,472,1,472,3,472,7501,8,472,1,472,1,472,1,472,3,472,7506,
  	8,472,1,472,1,472,1,472,3,472,7511,8,472,1,472,1,472,1,472,1,472,1,472,
  	1,472,1,472,1,472,3,472,7521,8,472,1,472,1,472,1,472,1,472,3,472,7527,
  	8,472,1,472,1,472,1,472,1,472,3,472,7533,8,472,1,472,1,472,1,472,1,472,
  	3,472,7539,8,472,1,472,3,472,7542,8,472,1,472,1,472,1,472,1,472,1,472,
  	3,472,7549,8,472,1,472,1,472,1,472,3,472,7554,8,472,1,472,3,472,7557,
  	8,472,1,473,1,473,3,473,7561,8,473,1,474,3,474,7564,8,474,1,474,1,474,
  	3,474,7568,8,474,1,474,1,474,1,475,3,475,7573,8,475,1,475,1,475,3,475,
  	7577,8,475,1,475,1,475,1,476,3,476,7582,8,476,1,476,1,476,3,476,7586,
  	8,476,1,476,1,476,1,477,1,477,1,477,1,477,1,477,3,477,7595,8,477,1,477,
  	3,477,7598,8,477,1,477,3,477,7601,8,477,1,478,3,478,7604,8,478,1,478,
  	1,478,3,478,7608,8,478,1,478,1,478,3,478,7612,8,478,1,478,1,478,3,478,
  	7616,8,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,1,478,
  	1,478,1,478,1,478,3,478,7631,8,478,1,478,3,478,7634,8,478,3,478,7636,
  	8,478,1,479,1,479,1,479,3,479,7641,8,479,1,479,1,479,1,479,1,479,1,479,
  	1,479,1,479,3,479,7650,8,479,1,479,3,479,7653,8,479,1,479,1,479,3,479,
  	7657,8,479,1,480,1,480,1,480,1,480,1,480,1,481,1,481,1,481,1,481,5,481,
  	7668,8,481,10,481,12,481,7671,9,481,1,481,1,481,1,482,1,482,1,482,1,482,
  	1,482,1,482,1,482,3,482,7682,8,482,1,482,1,482,1,482,3,482,7687,8,482,
  	1,482,5,482,7690,8,482,10,482,12,482,7693,9,482,1,482,1,482,1,482,1,482,
  	5,482,7699,8,482,10,482,12,482,7702,9,482,1,482,1,482,3,482,7706,8,482,
  	1,483,1,483,1,483,1,483,1,483,5,483,7713,8,483,10,483,12,483,7716,9,483,
  	1,483,1,483,3,483,7720,8,483,1,484,1,484,3,484,7724,8,484,1,484,1,484,
  	3,484,7728,8,484,1,484,1,484,3,484,7732,8,484,1,484,1,484,1,484,3,484,
  	7737,8,484,1,484,1,484,1,484,3,484,7742,8,484,1,484,1,484,1,484,1,484,
  	3,484,7748,8,484,1,484,1,484,1,484,3,484,7753,8,484,1,484,3,484,7756,
  	8,484,1,485,1,485,1,485,5,485,7761,8,485,10,485,12,485,7764,9,485,1,486,
  	1,486,1,486,1,486,5,486,7770,8,486,10,486,12,486,7773,9,486,1,486,1,486,
  	1,487,1,487,3,487,7779,8,487,1,488,1,488,1,488,1,488,1,489,1,489,1,489,
  	1,490,1,490,1,490,1,490,1,491,3,491,7793,8,491,1,491,1,491,1,492,1,492,
  	1,492,1,493,1,493,1,493,1,494,1,494,3,494,7805,8,494,1,495,1,495,1,495,
  	1,495,1,495,1,495,1,496,1,496,1,496,5,496,7816,8,496,10,496,12,496,7819,
  	9,496,1,497,1,497,1,497,5,497,7824,8,497,10,497,12,497,7827,9,497,1,498,
  	1,498,1,498,1,498,3,498,7833,8,498,1,499,1,499,1,499,1,500,1,500,4,500,
  	7840,8,500,11,500,12,500,7841,1,501,1,501,1,501,1,501,3,501,7848,8,501,
  	1,501,1,501,1,501,1,501,1,501,1,501,3,501,7856,8,501,1,502,1,502,4,502,
  	7860,8,502,11,502,12,502,7861,1,503,1,503,1,503,1,503,1,504,1,504,1,504,
  	5,504,7871,8,504,10,504,12,504,7874,9,504,1,505,1,505,1,505,5,505,7879,
  	8,505,10,505,12,505,7882,9,505,1,506,1,506,1,506,5,506,7887,8,506,10,
  	506,12,506,7890,9,506,1,507,1,507,1,507,1,507,1,507,3,507,7897,8,507,
  	1,507,1,507,1,507,1,507,1,507,1,507,1,507,1,507,3,507,7907,8,507,1,507,
  	1,507,1,507,3,507,7912,8,507,1,507,1,507,1,507,3,507,7917,8,507,3,507,
  	7919,8,507,1,508,1,508,1,508,1,508,3,508,7925,8,508,1,508,1,508,1,508,
  	1,508,3,508,7931,8,508,1,508,3,508,7934,8,508,1,508,1,508,1,508,1,508,
  	1,508,3,508,7941,8,508,3,508,7943,8,508,3,508,7945,8,508,1,508,3,508,
  	7948,8,508,3,508,7950,8,508,1,509,1,509,1,509,1,509,1,510,1,510,1,510,
  	1,510,1,511,1,511,1,511,1,512,1,512,1,512,1,512,3,512,7967,8,512,1,513,
  	1,513,1,513,3,513,7972,8,513,3,513,7974,8,513,1,514,1,514,1,514,1,515,
  	1,515,3,515,7981,8,515,1,516,1,516,1,517,1,517,1,518,1,518,1,518,1,518,
  	1,519,1,519,1,519,3,519,7994,8,519,3,519,7996,8,519,1,520,1,520,1,520,
  	1,520,3,520,8002,8,520,1,521,1,521,1,522,1,522,1,522,1,522,5,522,8010,
  	8,522,10,522,12,522,8013,9,522,1,522,1,522,1,523,1,523,1,524,1,524,3,
  	524,8021,8,524,1,525,1,525,1,526,1,526,1,527,1,527,1,527,1,527,1,527,
  	3,527,8032,8,527,1,527,1,527,1,528,1,528,1,529,1,529,1,530,1,530,1,531,
  	1,531,1,532,1,532,1,533,1,533,1,534,1,534,1,535,1,535,1,536,1,536,3,536,
  	8054,8,536,1,537,1,537,3,537,8058,8,537,1,538,1,538,1,539,1,539,1,540,
  	1,540,1,541,1,541,1,542,1,542,1,543,1,543,1,544,1,544,1,545,1,545,1,546,
  	1,546,1,547,1,547,1,548,1,548,3,548,8082,8,548,1,549,1,549,1,549,1,550,
  	1,550,1,550,1,550,1,550,1,550,3,550,8093,8,550,3,550,8095,8,550,1,551,
  	1,551,3,551,8099,8,551,1,552,1,552,1,552,5,552,8104,8,552,10,552,12,552,
  	8107,9,552,1,553,1,553,1,553,5,553,8112,8,553,10,553,12,553,8115,9,553,
  	1,554,1,554,1,555,1,555,3,555,8121,8,555,1,556,1,556,1,557,1,557,3,557,
  	8127,8,557,1,558,1,558,1,559,1,559,1,560,1,560,1,561,1,561,1,562,1,562,
  	1,563,1,563,1,563,3,563,8142,8,563,1,564,1,564,3,564,8146,8,564,1,565,
  	1,565,1,565,5,565,8151,8,565,10,565,12,565,8154,9,565,1,566,1,566,1,566,
  	1,566,1,567,1,567,3,567,8162,8,567,1,568,1,568,1,568,3,568,8167,8,568,
  	3,568,8169,8,568,1,568,1,568,1,568,1,568,3,568,8175,8,568,1,569,1,569,
  	1,569,1,570,1,570,1,571,1,571,1,572,1,572,1,573,1,573,1,573,1,573,1,573,
  	3,573,8191,8,573,1,574,1,574,1,574,1,574,1,574,1,574,3,574,8199,8,574,
  	1,574,3,574,8202,8,574,1,575,1,575,1,575,1,575,1,575,3,575,8209,8,575,
  	1,576,1,576,1,576,1,576,5,576,8215,8,576,10,576,12,576,8218,9,576,1,576,
  	1,576,1,577,1,577,1,577,3,577,8225,8,577,1,578,1,578,1,578,3,578,8230,
  	8,578,1,579,1,579,1,579,3,579,8235,8,579,1,580,3,580,8238,8,580,1,580,
  	1,580,3,580,8242,8,580,1,580,5,580,8245,8,580,10,580,12,580,8248,9,580,
  	1,581,1,581,1,582,1,582,1,582,5,582,8255,8,582,10,582,12,582,8258,9,582,
  	1,583,1,583,1,584,1,584,1,585,1,585,1,586,1,586,1,586,1,586,1,586,1,586,
  	3,586,8272,8,586,1,587,1,587,3,587,8276,8,587,1,588,1,588,1,589,1,589,
  	1,589,1,589,1,589,1,589,1,590,1,590,3,590,8288,8,590,1,591,1,591,3,591,
  	8292,8,591,1,592,1,592,3,592,8296,8,592,1,593,1,593,3,593,8300,8,593,
  	1,594,1,594,1,594,1,595,1,595,1,596,1,596,1,597,1,597,1,597,1,597,1,597,
  	1,597,3,597,8315,8,597,1,598,1,598,1,598,1,598,1,598,1,598,1,598,1,598,
  	1,598,1,598,3,598,8327,8,598,1,599,1,599,1,599,1,599,1,599,1,599,1,599,
  	1,599,3,599,8337,8,599,1,599,1,599,1,599,1,599,1,599,3,599,8344,8,599,
  	3,599,8346,8,599,1,600,1,600,1,601,1,601,1,602,1,602,1,602,1,602,1,602,
  	1,602,1,602,1,602,1,602,1,602,1,602,3,602,8363,8,602,1,602,1,602,1,602,
  	3,602,8368,8,602,3,602,8370,8,602,1,603,1,603,1,604,1,604,1,604,3,604,
  	8377,8,604,1,605,1,605,1,605,3,605,8382,8,605,1,605,1,605,1,605,3,605,
  	8387,8,605,3,605,8389,8,605,1,606,1,606,1,606,1,606,3,606,8395,8,606,
  	1,607,1,607,1,608,1,608,1,608,1,608,1,608,3,608,8404,8,608,1,609,1,609,
  	1,609,1,609,1,609,1,609,1,609,1,609,1,609,3,609,8415,8,609,1,609,0,4,
  	676,678,686,688,610,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,0,146,1,0,722,723,2,0,17,17,590,590,2,0,49,49,471,471,
  	1,0,645,646,2,0,4,4,148,148,2,0,434,434,436,436,1,0,724,725,2,0,50,50,
  	284,284,2,0,232,232,458,458,4,0,126,126,249,249,437,437,556,556,2,0,130,
  	130,250,250,2,0,440,440,603,603,2,0,441,441,604,604,2,0,374,374,638,638,
  	3,0,335,335,578,578,602,602,2,0,6,6,28,28,3,0,133,133,242,242,614,614,
  	2,0,197,197,415,415,2,0,571,571,574,574,3,0,232,232,295,295,431,431,2,
  	0,191,191,367,367,4,0,191,191,268,268,367,367,419,419,2,0,750,750,753,
  	756,3,0,131,131,223,223,295,295,1,0,626,627,2,0,82,82,295,295,2,0,112,
  	112,653,653,2,0,278,278,484,484,2,0,131,131,295,295,7,0,10,10,143,143,
  	223,223,531,532,534,534,536,536,555,555,2,0,381,381,773,773,2,0,747,749,
  	787,787,3,0,432,432,484,484,683,683,2,0,18,18,134,134,2,0,272,272,478,
  	478,2,0,98,98,239,239,2,0,10,10,143,143,2,0,198,198,232,232,2,0,236,236,
  	265,265,2,0,386,386,649,649,2,0,29,29,543,543,2,0,261,261,472,472,2,0,
  	32,32,316,316,2,0,383,383,743,744,2,0,528,528,530,530,2,0,449,449,538,
  	538,2,0,543,543,552,552,2,0,123,123,148,148,3,0,369,369,539,539,650,650,
  	2,0,287,287,611,611,2,0,128,128,719,719,3,0,206,206,422,422,574,574,4,
  	0,242,242,443,443,497,497,614,614,13,0,133,133,148,148,170,170,173,173,
  	188,188,236,236,423,423,427,427,451,451,510,510,565,565,594,594,616,616,
  	4,0,483,483,572,572,618,618,636,636,2,0,65,65,514,514,2,0,97,97,148,148,
  	2,0,128,128,369,369,2,0,180,180,431,431,5,0,56,56,180,180,184,184,333,
  	333,431,431,3,0,180,180,431,431,619,619,2,0,76,76,601,601,4,0,10,10,32,
  	32,128,128,383,383,2,0,487,487,710,710,3,0,289,289,354,354,547,547,2,
  	0,203,203,251,251,2,0,33,33,446,446,2,0,235,236,263,263,2,0,166,166,639,
  	639,2,0,547,547,631,631,6,0,10,10,96,96,256,256,334,334,522,522,567,567,
  	2,0,84,84,430,430,5,0,136,136,225,225,421,421,547,547,617,617,5,0,32,
  	32,163,163,165,165,208,208,515,515,2,0,618,618,710,710,2,0,140,140,156,
  	156,2,0,134,135,178,178,3,0,183,183,596,596,610,610,2,0,15,15,767,767,
  	2,0,394,394,770,770,2,0,10,10,16,16,2,0,750,750,752,757,3,0,145,145,349,
  	349,760,762,1,0,758,759,1,0,765,766,2,0,758,759,764,764,2,0,35,36,38,
  	38,4,0,678,679,692,692,694,694,696,696,2,0,684,684,686,686,2,0,681,681,
  	685,685,2,0,191,191,268,268,2,0,232,232,695,695,2,0,5,5,558,558,1,0,114,
  	115,1,0,584,585,4,0,113,113,116,116,583,583,586,586,2,0,371,371,745,745,
  	2,0,745,745,763,763,5,0,118,121,226,228,341,342,494,494,655,655,9,0,122,
  	122,229,229,337,337,343,343,350,350,429,429,495,495,640,640,656,656,3,
  	0,92,92,175,175,605,605,2,0,377,377,485,485,10,0,53,53,64,64,73,73,87,
  	89,107,107,336,336,355,355,492,492,557,557,576,576,2,0,554,554,637,637,
  	3,0,128,128,152,152,192,192,3,0,128,128,142,142,334,334,3,0,204,204,402,
  	402,513,513,3,0,44,44,220,220,488,488,1,0,661,662,2,0,599,599,621,621,
  	5,0,31,31,249,249,331,331,516,516,588,588,4,0,126,126,192,192,195,195,
  	378,378,1,0,41,42,2,0,290,290,330,330,4,0,211,212,279,279,351,353,411,
  	412,3,0,512,512,612,612,657,657,1,0,544,546,2,0,61,61,575,575,6,0,78,
  	78,80,80,128,128,152,152,192,192,442,442,3,0,191,191,268,268,373,373,
  	2,0,142,142,334,334,2,0,280,280,432,432,2,0,323,323,344,344,2,0,112,112,
  	236,236,3,0,240,240,251,251,397,397,2,0,541,541,579,579,2,0,380,380,385,
  	385,2,0,284,284,375,375,2,0,795,795,797,797,3,0,747,749,788,788,790,791,
  	2,0,747,749,788,788,2,0,747,749,790,791,1,0,788,789,2,0,183,183,596,596,
  	2,0,376,376,786,786,1,0,750,751,5,0,214,214,284,284,502,502,658,658,673,
  	673,3,0,173,173,510,510,714,714,32,0,19,19,29,29,46,47,58,58,61,61,75,
  	75,77,77,90,90,123,123,147,147,159,159,196,197,219,219,222,222,234,234,
  	245,245,267,267,373,373,415,415,417,417,455,455,468,468,480,480,489,489,
  	512,512,514,514,543,543,552,552,597,597,606,607,651,651,677,677,9,0,170,
  	170,188,188,369,369,423,423,427,427,451,451,459,459,565,565,709,709,161,
  	0,2,3,5,9,12,12,16,16,21,21,23,27,33,33,37,37,40,42,44,44,50,50,53,54,
  	56,57,63,68,70,71,73,74,76,76,78,82,84,85,87,89,91,91,96,96,101,101,107,
  	107,111,113,116,116,122,122,129,130,132,132,138,142,150,152,156,156,158,
  	158,160,160,162,166,168,169,171,172,176,177,179,181,184,185,189,192,201,
  	202,204,204,208,208,210,213,216,216,220,220,224,225,229,230,233,233,235,
  	235,238,238,243,244,250,250,255,256,258,259,262,262,264,264,268,268,270,
  	270,273,274,279,280,286,286,288,289,296,296,298,314,316,319,321,324,327,
  	328,333,337,340,340,343,344,346,346,348,348,350,358,361,361,363,363,365,
  	368,374,374,377,377,379,379,381,381,384,384,386,387,390,390,398,404,406,
  	413,418,419,421,421,424,426,429,431,434,434,438,439,441,442,445,449,452,
  	452,454,454,456,456,460,466,470,470,472,474,476,476,481,483,485,486,488,
  	488,490,490,492,492,495,496,500,501,503,503,508,508,513,513,515,515,517,
  	517,519,522,528,530,532,532,535,535,538,538,540,540,542,542,544,547,553,
  	553,556,561,566,568,571,572,575,578,580,581,583,586,592,593,598,599,601,
  	604,610,610,613,613,615,615,617,619,625,625,627,627,631,631,636,636,638,
  	641,646,648,650,650,652,653,656,656,659,662,664,664,669,671,674,675,680,
  	680,682,682,689,690,693,693,695,695,697,698,702,708,711,713,715,725,727,
  	730,732,732,735,738,4,0,583,583,586,586,731,731,733,744,54,0,2,2,12,12,
  	19,19,27,27,29,29,46,47,58,58,61,61,66,66,75,75,77,77,90,90,123,123,147,
  	147,159,159,196,197,201,201,210,210,219,219,222,222,224,224,245,245,267,
  	267,373,373,387,387,390,390,398,398,401,401,405,405,413,413,415,415,417,
  	417,452,452,455,455,468,468,470,470,480,480,489,489,496,496,503,503,512,
  	512,514,514,519,520,543,543,552,552,597,597,606,607,615,615,648,648,651,
  	651,659,659,661,662,677,677,720,723,155,0,3,3,5,9,13,13,16,16,21,26,33,
  	33,37,37,40,42,44,44,50,50,53,54,56,57,63,65,67,68,70,71,73,74,76,76,
  	78,82,84,85,87,89,91,91,93,93,96,96,101,101,107,107,111,113,116,116,122,
  	122,129,130,132,132,136,136,138,142,150,152,156,156,158,158,160,160,162,
  	166,168,169,171,171,176,176,179,181,184,185,189,192,202,202,204,204,208,
  	208,211,214,216,216,220,220,225,225,229,230,233,233,235,235,238,238,243,
  	244,250,250,255,256,258,259,262,262,264,264,268,268,270,270,273,274,279,
  	280,284,284,286,286,288,289,296,296,298,314,316,319,321,325,327,328,333,
  	337,340,340,343,344,346,346,348,348,350,358,361,361,363,363,365,368,374,
  	374,377,377,379,379,381,382,384,384,399,400,402,404,406,412,418,419,421,
  	421,424,426,429,431,434,434,438,442,445,449,454,454,456,456,460,466,472,
  	474,476,476,481,483,485,486,488,488,490,490,492,492,495,495,500,502,508,
  	508,513,513,515,515,517,517,521,522,528,530,532,533,535,535,538,538,540,
  	540,542,542,544,547,553,553,556,561,565,568,571,572,575,578,580,581,583,
  	586,592,593,598,604,610,610,613,613,617,619,627,627,631,631,636,636,638,
  	641,647,647,650,650,652,653,656,656,664,664,669,671,674,676,680,680,682,
  	682,689,690,693,693,695,695,697,698,702,708,711,712,716,717,719,719,724,
  	725,727,728,5,0,99,99,206,206,234,234,484,484,487,487,6,0,172,172,177,
  	177,386,386,565,565,625,625,646,646,9536,0,1232,1,0,0,0,2,1268,1,0,0,
  	0,4,1270,1,0,0,0,6,1299,1,0,0,0,8,1314,1,0,0,0,10,1352,1,0,0,0,12,1361,
  	1,0,0,0,14,1374,1,0,0,0,16,1376,1,0,0,0,18,1381,1,0,0,0,20,1405,1,0,0,
  	0,22,1414,1,0,0,0,24,1416,1,0,0,0,26,1431,1,0,0,0,28,1529,1,0,0,0,30,
  	1533,1,0,0,0,32,1549,1,0,0,0,34,1696,1,0,0,0,36,1701,1,0,0,0,38,1703,
  	1,0,0,0,40,1705,1,0,0,0,42,1719,1,0,0,0,44,1727,1,0,0,0,46,1743,1,0,0,
  	0,48,1745,1,0,0,0,50,1749,1,0,0,0,52,1754,1,0,0,0,54,1756,1,0,0,0,56,
  	1793,1,0,0,0,58,1801,1,0,0,0,60,1811,1,0,0,0,62,1813,1,0,0,0,64,1833,
  	1,0,0,0,66,1842,1,0,0,0,68,1845,1,0,0,0,70,1858,1,0,0,0,72,1863,1,0,0,
  	0,74,1867,1,0,0,0,76,1874,1,0,0,0,78,1895,1,0,0,0,80,1910,1,0,0,0,82,
  	1913,1,0,0,0,84,1944,1,0,0,0,86,1954,1,0,0,0,88,1957,1,0,0,0,90,1966,
  	1,0,0,0,92,1968,1,0,0,0,94,1980,1,0,0,0,96,2005,1,0,0,0,98,2032,1,0,0,
  	0,100,2046,1,0,0,0,102,2049,1,0,0,0,104,2070,1,0,0,0,106,2073,1,0,0,0,
  	108,2130,1,0,0,0,110,2132,1,0,0,0,112,2136,1,0,0,0,114,2145,1,0,0,0,116,
  	2161,1,0,0,0,118,2163,1,0,0,0,120,2171,1,0,0,0,122,2197,1,0,0,0,124,2199,
  	1,0,0,0,126,2211,1,0,0,0,128,2226,1,0,0,0,130,2228,1,0,0,0,132,2231,1,
  	0,0,0,134,2253,1,0,0,0,136,2255,1,0,0,0,138,2261,1,0,0,0,140,2267,1,0,
  	0,0,142,2273,1,0,0,0,144,2279,1,0,0,0,146,2285,1,0,0,0,148,2292,1,0,0,
  	0,150,2300,1,0,0,0,152,2302,1,0,0,0,154,2308,1,0,0,0,156,2314,1,0,0,0,
  	158,2321,1,0,0,0,160,2339,1,0,0,0,162,2341,1,0,0,0,164,2345,1,0,0,0,166,
  	2350,1,0,0,0,168,2366,1,0,0,0,170,2371,1,0,0,0,172,2404,1,0,0,0,174,2435,
  	1,0,0,0,176,2452,1,0,0,0,178,2454,1,0,0,0,180,2474,1,0,0,0,182,2480,1,
  	0,0,0,184,2486,1,0,0,0,186,2492,1,0,0,0,188,2499,1,0,0,0,190,2508,1,0,
  	0,0,192,2525,1,0,0,0,194,2527,1,0,0,0,196,2534,1,0,0,0,198,2544,1,0,0,
  	0,200,2558,1,0,0,0,202,2564,1,0,0,0,204,2572,1,0,0,0,206,2578,1,0,0,0,
  	208,2586,1,0,0,0,210,2592,1,0,0,0,212,2602,1,0,0,0,214,2606,1,0,0,0,216,
  	2612,1,0,0,0,218,2617,1,0,0,0,220,2628,1,0,0,0,222,2671,1,0,0,0,224,2677,
  	1,0,0,0,226,2679,1,0,0,0,228,2686,1,0,0,0,230,2716,1,0,0,0,232,2718,1,
  	0,0,0,234,2749,1,0,0,0,236,2756,1,0,0,0,238,2760,1,0,0,0,240,2768,1,0,
  	0,0,242,2778,1,0,0,0,244,2780,1,0,0,0,246,2798,1,0,0,0,248,2810,1,0,0,
  	0,250,2815,1,0,0,0,252,2821,1,0,0,0,254,2854,1,0,0,0,256,2856,1,0,0,0,
  	258,2864,1,0,0,0,260,2873,1,0,0,0,262,2881,1,0,0,0,264,2893,1,0,0,0,266,
  	2916,1,0,0,0,268,2930,1,0,0,0,270,2934,1,0,0,0,272,2966,1,0,0,0,274,2981,
  	1,0,0,0,276,2996,1,0,0,0,278,2998,1,0,0,0,280,3025,1,0,0,0,282,3027,1,
  	0,0,0,284,3029,1,0,0,0,286,3032,1,0,0,0,288,3035,1,0,0,0,290,3042,1,0,
  	0,0,292,3044,1,0,0,0,294,3074,1,0,0,0,296,3086,1,0,0,0,298,3089,1,0,0,
  	0,300,3098,1,0,0,0,302,3102,1,0,0,0,304,3107,1,0,0,0,306,3120,1,0,0,0,
  	308,3125,1,0,0,0,310,3129,1,0,0,0,312,3145,1,0,0,0,314,3147,1,0,0,0,316,
  	3165,1,0,0,0,318,3167,1,0,0,0,320,3176,1,0,0,0,322,3188,1,0,0,0,324,3195,
  	1,0,0,0,326,3206,1,0,0,0,328,3208,1,0,0,0,330,3212,1,0,0,0,332,3214,1,
  	0,0,0,334,3219,1,0,0,0,336,3227,1,0,0,0,338,3236,1,0,0,0,340,3239,1,0,
  	0,0,342,3254,1,0,0,0,344,3257,1,0,0,0,346,3276,1,0,0,0,348,3281,1,0,0,
  	0,350,3286,1,0,0,0,352,3290,1,0,0,0,354,3304,1,0,0,0,356,3307,1,0,0,0,
  	358,3313,1,0,0,0,360,3326,1,0,0,0,362,3334,1,0,0,0,364,3360,1,0,0,0,366,
  	3373,1,0,0,0,368,3380,1,0,0,0,370,3382,1,0,0,0,372,3394,1,0,0,0,374,3396,
  	1,0,0,0,376,3406,1,0,0,0,378,3430,1,0,0,0,380,3432,1,0,0,0,382,3439,1,
  	0,0,0,384,3449,1,0,0,0,386,3484,1,0,0,0,388,3494,1,0,0,0,390,3496,1,0,
  	0,0,392,3500,1,0,0,0,394,3508,1,0,0,0,396,3510,1,0,0,0,398,3515,1,0,0,
  	0,400,3519,1,0,0,0,402,3547,1,0,0,0,404,3549,1,0,0,0,406,3551,1,0,0,0,
  	408,3559,1,0,0,0,410,3561,1,0,0,0,412,3569,1,0,0,0,414,3579,1,0,0,0,416,
  	3583,1,0,0,0,418,3608,1,0,0,0,420,3635,1,0,0,0,422,3637,1,0,0,0,424,3647,
  	1,0,0,0,426,3678,1,0,0,0,428,3702,1,0,0,0,430,3704,1,0,0,0,432,3718,1,
  	0,0,0,434,3720,1,0,0,0,436,3755,1,0,0,0,438,3757,1,0,0,0,440,3799,1,0,
  	0,0,442,3815,1,0,0,0,444,3817,1,0,0,0,446,3825,1,0,0,0,448,3834,1,0,0,
  	0,450,3841,1,0,0,0,452,3940,1,0,0,0,454,3944,1,0,0,0,456,3946,1,0,0,0,
  	458,3950,1,0,0,0,460,3964,1,0,0,0,462,3966,1,0,0,0,464,3979,1,0,0,0,466,
  	4043,1,0,0,0,468,4045,1,0,0,0,470,4053,1,0,0,0,472,4061,1,0,0,0,474,4069,
  	1,0,0,0,476,4071,1,0,0,0,478,4100,1,0,0,0,480,4109,1,0,0,0,482,4140,1,
  	0,0,0,484,4142,1,0,0,0,486,4150,1,0,0,0,488,4152,1,0,0,0,490,4166,1,0,
  	0,0,492,4168,1,0,0,0,494,4174,1,0,0,0,496,4182,1,0,0,0,498,4219,1,0,0,
  	0,500,4221,1,0,0,0,502,4236,1,0,0,0,504,4238,1,0,0,0,506,4300,1,0,0,0,
  	508,4302,1,0,0,0,510,4305,1,0,0,0,512,4330,1,0,0,0,514,4339,1,0,0,0,516,
  	4341,1,0,0,0,518,4346,1,0,0,0,520,4392,1,0,0,0,522,4394,1,0,0,0,524,4402,
  	1,0,0,0,526,4451,1,0,0,0,528,4464,1,0,0,0,530,4466,1,0,0,0,532,4469,1,
  	0,0,0,534,4480,1,0,0,0,536,4485,1,0,0,0,538,4488,1,0,0,0,540,4503,1,0,
  	0,0,542,4553,1,0,0,0,544,4555,1,0,0,0,546,4557,1,0,0,0,548,4606,1,0,0,
  	0,550,4624,1,0,0,0,552,4626,1,0,0,0,554,4642,1,0,0,0,556,4654,1,0,0,0,
  	558,4679,1,0,0,0,560,4681,1,0,0,0,562,4689,1,0,0,0,564,4738,1,0,0,0,566,
  	4753,1,0,0,0,568,4758,1,0,0,0,570,4760,1,0,0,0,572,4784,1,0,0,0,574,4786,
  	1,0,0,0,576,4845,1,0,0,0,578,4856,1,0,0,0,580,4858,1,0,0,0,582,4861,1,
  	0,0,0,584,4874,1,0,0,0,586,4902,1,0,0,0,588,4910,1,0,0,0,590,4912,1,0,
  	0,0,592,4923,1,0,0,0,594,4925,1,0,0,0,596,4933,1,0,0,0,598,4935,1,0,0,
  	0,600,5163,1,0,0,0,602,5170,1,0,0,0,604,5172,1,0,0,0,606,5174,1,0,0,0,
  	608,5184,1,0,0,0,610,5223,1,0,0,0,612,5227,1,0,0,0,614,5229,1,0,0,0,616,
  	5237,1,0,0,0,618,5241,1,0,0,0,620,5249,1,0,0,0,622,5258,1,0,0,0,624,5260,
  	1,0,0,0,626,5283,1,0,0,0,628,5285,1,0,0,0,630,5287,1,0,0,0,632,5303,1,
  	0,0,0,634,5315,1,0,0,0,636,5317,1,0,0,0,638,5325,1,0,0,0,640,5333,1,0,
  	0,0,642,5342,1,0,0,0,644,5344,1,0,0,0,646,5362,1,0,0,0,648,5376,1,0,0,
  	0,650,5381,1,0,0,0,652,5387,1,0,0,0,654,5389,1,0,0,0,656,5405,1,0,0,0,
  	658,5413,1,0,0,0,660,5423,1,0,0,0,662,5436,1,0,0,0,664,5438,1,0,0,0,666,
  	5444,1,0,0,0,668,5476,1,0,0,0,670,5478,1,0,0,0,672,5481,1,0,0,0,674,5484,
  	1,0,0,0,676,5497,1,0,0,0,678,5513,1,0,0,0,680,5536,1,0,0,0,682,5538,1,
  	0,0,0,684,5575,1,0,0,0,686,5577,1,0,0,0,688,5718,1,0,0,0,690,5731,1,0,
  	0,0,692,5740,1,0,0,0,694,5873,1,0,0,0,696,5875,1,0,0,0,698,5922,1,0,0,
  	0,700,5924,1,0,0,0,702,5929,1,0,0,0,704,5938,1,0,0,0,706,5957,1,0,0,0,
  	708,5960,1,0,0,0,710,5969,1,0,0,0,712,5971,1,0,0,0,714,5994,1,0,0,0,716,
  	6269,1,0,0,0,718,6302,1,0,0,0,720,6304,1,0,0,0,722,6310,1,0,0,0,724,6313,
  	1,0,0,0,726,6328,1,0,0,0,728,6336,1,0,0,0,730,6338,1,0,0,0,732,6367,1,
  	0,0,0,734,6400,1,0,0,0,736,6402,1,0,0,0,738,6410,1,0,0,0,740,6416,1,0,
  	0,0,742,6421,1,0,0,0,744,6423,1,0,0,0,746,6445,1,0,0,0,748,6447,1,0,0,
  	0,750,6450,1,0,0,0,752,6453,1,0,0,0,754,6501,1,0,0,0,756,6503,1,0,0,0,
  	758,6514,1,0,0,0,760,6516,1,0,0,0,762,6518,1,0,0,0,764,6522,1,0,0,0,766,
  	6524,1,0,0,0,768,6526,1,0,0,0,770,6530,1,0,0,0,772,6534,1,0,0,0,774,6538,
  	1,0,0,0,776,6546,1,0,0,0,778,6550,1,0,0,0,780,6558,1,0,0,0,782,6560,1,
  	0,0,0,784,6578,1,0,0,0,786,6580,1,0,0,0,788,6583,1,0,0,0,790,6588,1,0,
  	0,0,792,6596,1,0,0,0,794,6602,1,0,0,0,796,6606,1,0,0,0,798,6623,1,0,0,
  	0,800,6626,1,0,0,0,802,6631,1,0,0,0,804,6633,1,0,0,0,806,6636,1,0,0,0,
  	808,6645,1,0,0,0,810,6653,1,0,0,0,812,6655,1,0,0,0,814,6660,1,0,0,0,816,
  	6667,1,0,0,0,818,6677,1,0,0,0,820,6685,1,0,0,0,822,6687,1,0,0,0,824,6697,
  	1,0,0,0,826,6705,1,0,0,0,828,6707,1,0,0,0,830,6713,1,0,0,0,832,6734,1,
  	0,0,0,834,6736,1,0,0,0,836,6742,1,0,0,0,838,6745,1,0,0,0,840,6748,1,0,
  	0,0,842,6778,1,0,0,0,844,6782,1,0,0,0,846,6789,1,0,0,0,848,6796,1,0,0,
  	0,850,6798,1,0,0,0,852,6814,1,0,0,0,854,6830,1,0,0,0,856,6834,1,0,0,0,
  	858,6837,1,0,0,0,860,6840,1,0,0,0,862,6864,1,0,0,0,864,6866,1,0,0,0,866,
  	6874,1,0,0,0,868,6876,1,0,0,0,870,6880,1,0,0,0,872,6959,1,0,0,0,874,6961,
  	1,0,0,0,876,6965,1,0,0,0,878,7055,1,0,0,0,880,7057,1,0,0,0,882,7059,1,
  	0,0,0,884,7075,1,0,0,0,886,7077,1,0,0,0,888,7109,1,0,0,0,890,7111,1,0,
  	0,0,892,7122,1,0,0,0,894,7129,1,0,0,0,896,7145,1,0,0,0,898,7151,1,0,0,
  	0,900,7153,1,0,0,0,902,7157,1,0,0,0,904,7168,1,0,0,0,906,7170,1,0,0,0,
  	908,7172,1,0,0,0,910,7179,1,0,0,0,912,7181,1,0,0,0,914,7183,1,0,0,0,916,
  	7333,1,0,0,0,918,7338,1,0,0,0,920,7345,1,0,0,0,922,7347,1,0,0,0,924,7355,
  	1,0,0,0,926,7373,1,0,0,0,928,7381,1,0,0,0,930,7389,1,0,0,0,932,7391,1,
  	0,0,0,934,7395,1,0,0,0,936,7403,1,0,0,0,938,7410,1,0,0,0,940,7412,1,0,
  	0,0,942,7423,1,0,0,0,944,7556,1,0,0,0,946,7560,1,0,0,0,948,7563,1,0,0,
  	0,950,7572,1,0,0,0,952,7581,1,0,0,0,954,7589,1,0,0,0,956,7635,1,0,0,0,
  	958,7637,1,0,0,0,960,7658,1,0,0,0,962,7663,1,0,0,0,964,7674,1,0,0,0,966,
  	7719,1,0,0,0,968,7755,1,0,0,0,970,7757,1,0,0,0,972,7765,1,0,0,0,974,7778,
  	1,0,0,0,976,7780,1,0,0,0,978,7784,1,0,0,0,980,7787,1,0,0,0,982,7792,1,
  	0,0,0,984,7796,1,0,0,0,986,7799,1,0,0,0,988,7802,1,0,0,0,990,7806,1,0,
  	0,0,992,7812,1,0,0,0,994,7820,1,0,0,0,996,7828,1,0,0,0,998,7834,1,0,0,
  	0,1000,7837,1,0,0,0,1002,7855,1,0,0,0,1004,7857,1,0,0,0,1006,7863,1,0,
  	0,0,1008,7867,1,0,0,0,1010,7875,1,0,0,0,1012,7883,1,0,0,0,1014,7891,1,
  	0,0,0,1016,7920,1,0,0,0,1018,7951,1,0,0,0,1020,7955,1,0,0,0,1022,7959,
  	1,0,0,0,1024,7962,1,0,0,0,1026,7973,1,0,0,0,1028,7975,1,0,0,0,1030,7980,
  	1,0,0,0,1032,7982,1,0,0,0,1034,7984,1,0,0,0,1036,7986,1,0,0,0,1038,7995,
  	1,0,0,0,1040,8001,1,0,0,0,1042,8003,1,0,0,0,1044,8005,1,0,0,0,1046,8016,
  	1,0,0,0,1048,8020,1,0,0,0,1050,8022,1,0,0,0,1052,8024,1,0,0,0,1054,8026,
  	1,0,0,0,1056,8035,1,0,0,0,1058,8037,1,0,0,0,1060,8039,1,0,0,0,1062,8041,
  	1,0,0,0,1064,8043,1,0,0,0,1066,8045,1,0,0,0,1068,8047,1,0,0,0,1070,8049,
  	1,0,0,0,1072,8053,1,0,0,0,1074,8057,1,0,0,0,1076,8059,1,0,0,0,1078,8061,
  	1,0,0,0,1080,8063,1,0,0,0,1082,8065,1,0,0,0,1084,8067,1,0,0,0,1086,8069,
  	1,0,0,0,1088,8071,1,0,0,0,1090,8073,1,0,0,0,1092,8075,1,0,0,0,1094,8077,
  	1,0,0,0,1096,8081,1,0,0,0,1098,8083,1,0,0,0,1100,8086,1,0,0,0,1102,8098,
  	1,0,0,0,1104,8100,1,0,0,0,1106,8108,1,0,0,0,1108,8116,1,0,0,0,1110,8120,
  	1,0,0,0,1112,8122,1,0,0,0,1114,8126,1,0,0,0,1116,8128,1,0,0,0,1118,8130,
  	1,0,0,0,1120,8132,1,0,0,0,1122,8134,1,0,0,0,1124,8136,1,0,0,0,1126,8141,
  	1,0,0,0,1128,8145,1,0,0,0,1130,8147,1,0,0,0,1132,8155,1,0,0,0,1134,8159,
  	1,0,0,0,1136,8174,1,0,0,0,1138,8176,1,0,0,0,1140,8179,1,0,0,0,1142,8181,
  	1,0,0,0,1144,8183,1,0,0,0,1146,8190,1,0,0,0,1148,8201,1,0,0,0,1150,8208,
  	1,0,0,0,1152,8210,1,0,0,0,1154,8224,1,0,0,0,1156,8229,1,0,0,0,1158,8234,
  	1,0,0,0,1160,8241,1,0,0,0,1162,8249,1,0,0,0,1164,8251,1,0,0,0,1166,8259,
  	1,0,0,0,1168,8261,1,0,0,0,1170,8263,1,0,0,0,1172,8271,1,0,0,0,1174,8275,
  	1,0,0,0,1176,8277,1,0,0,0,1178,8279,1,0,0,0,1180,8287,1,0,0,0,1182,8291,
  	1,0,0,0,1184,8295,1,0,0,0,1186,8299,1,0,0,0,1188,8301,1,0,0,0,1190,8304,
  	1,0,0,0,1192,8306,1,0,0,0,1194,8314,1,0,0,0,1196,8326,1,0,0,0,1198,8345,
  	1,0,0,0,1200,8347,1,0,0,0,1202,8349,1,0,0,0,1204,8369,1,0,0,0,1206,8371,
  	1,0,0,0,1208,8376,1,0,0,0,1210,8388,1,0,0,0,1212,8394,1,0,0,0,1214,8396,
  	1,0,0,0,1216,8403,1,0,0,0,1218,8414,1,0,0,0,1220,1233,5,0,0,1,1221,1224,
  	3,2,1,0,1222,1224,3,422,211,0,1223,1221,1,0,0,0,1223,1222,1,0,0,0,1224,
  	1230,1,0,0,0,1225,1227,5,774,0,0,1226,1228,5,0,0,1,1227,1226,1,0,0,0,
  	1227,1228,1,0,0,0,1228,1231,1,0,0,0,1229,1231,5,0,0,1,1230,1225,1,0,0,
  	0,1230,1229,1,0,0,0,1231,1233,1,0,0,0,1232,1220,1,0,0,0,1232,1223,1,0,
  	0,0,1233,1,1,0,0,0,1234,1269,3,4,2,0,1235,1269,3,76,38,0,1236,1269,3,
  	178,89,0,1237,1269,3,210,105,0,1238,1269,3,214,107,0,1239,1240,4,1,0,
  	0,1240,1269,3,216,108,0,1241,1269,3,218,109,0,1242,1269,3,220,110,0,1243,
  	1269,3,226,113,0,1244,1269,3,228,114,0,1245,1269,3,232,116,0,1246,1269,
  	3,252,126,0,1247,1269,3,264,132,0,1248,1269,3,266,133,0,1249,1269,3,416,
  	208,0,1250,1269,3,418,209,0,1251,1269,3,440,220,0,1252,1269,3,490,245,
  	0,1253,1254,4,1,1,0,1254,1269,3,496,248,0,1255,1269,3,502,251,0,1256,
  	1269,3,564,282,0,1257,1269,3,572,286,0,1258,1269,3,574,287,0,1259,1269,
  	3,598,299,0,1260,1261,4,1,2,0,1261,1269,3,642,321,0,1262,1269,3,610,305,
  	0,1263,1269,3,662,331,0,1264,1265,4,1,3,0,1265,1269,3,840,420,0,1266,
  	1269,3,850,425,0,1267,1269,3,852,426,0,1268,1234,1,0,0,0,1268,1235,1,
  	0,0,0,1268,1236,1,0,0,0,1268,1237,1,0,0,0,1268,1238,1,0,0,0,1268,1239,
  	1,0,0,0,1268,1241,1,0,0,0,1268,1242,1,0,0,0,1268,1243,1,0,0,0,1268,1244,
  	1,0,0,0,1268,1245,1,0,0,0,1268,1246,1,0,0,0,1268,1247,1,0,0,0,1268,1248,
  	1,0,0,0,1268,1249,1,0,0,0,1268,1250,1,0,0,0,1268,1251,1,0,0,0,1268,1252,
  	1,0,0,0,1268,1253,1,0,0,0,1268,1255,1,0,0,0,1268,1256,1,0,0,0,1268,1257,
  	1,0,0,0,1268,1258,1,0,0,0,1268,1259,1,0,0,0,1268,1260,1,0,0,0,1268,1262,
  	1,0,0,0,1268,1263,1,0,0,0,1268,1264,1,0,0,0,1268,1266,1,0,0,0,1268,1267,
  	1,0,0,0,1269,3,1,0,0,0,1270,1297,5,11,0,0,1271,1298,3,18,9,0,1272,1298,
  	3,6,3,0,1273,1274,5,422,0,0,1274,1276,3,1062,531,0,1275,1277,3,102,51,
  	0,1276,1275,1,0,0,0,1276,1277,1,0,0,0,1277,1298,1,0,0,0,1278,1279,5,206,
  	0,0,1279,1281,3,1066,533,0,1280,1282,3,102,51,0,1281,1280,1,0,0,0,1281,
  	1282,1,0,0,0,1282,1298,1,0,0,0,1283,1298,3,68,34,0,1284,1298,3,8,4,0,
  	1285,1298,3,54,27,0,1286,1287,4,2,4,0,1287,1298,3,56,28,0,1288,1298,3,
  	10,5,0,1289,1298,3,16,8,0,1290,1291,4,2,5,0,1291,1292,5,244,0,0,1292,
  	1293,5,482,0,0,1293,1294,3,1180,590,0,1294,1295,5,316,0,0,1295,1296,5,
  	265,0,0,1296,1298,1,0,0,0,1297,1271,1,0,0,0,1297,1272,1,0,0,0,1297,1273,
  	1,0,0,0,1297,1278,1,0,0,0,1297,1283,1,0,0,0,1297,1284,1,0,0,0,1297,1285,
  	1,0,0,0,1297,1286,1,0,0,0,1297,1288,1,0,0,0,1297,1289,1,0,0,0,1297,1290,
  	1,0,0,0,1298,5,1,0,0,0,1299,1300,5,109,0,0,1300,1311,3,1058,529,0,1301,
  	1303,3,80,40,0,1302,1301,1,0,0,0,1303,1304,1,0,0,0,1304,1302,1,0,0,0,
  	1304,1305,1,0,0,0,1305,1312,1,0,0,0,1306,1307,4,3,6,0,1307,1308,5,615,
  	0,0,1308,1309,5,112,0,0,1309,1310,5,139,0,0,1310,1312,5,357,0,0,1311,
  	1302,1,0,0,0,1311,1306,1,0,0,0,1312,7,1,0,0,0,1313,1315,3,976,488,0,1314,
  	1313,1,0,0,0,1314,1315,1,0,0,0,1315,1316,1,0,0,0,1316,1317,5,170,0,0,
  	1317,1321,3,1086,543,0,1318,1319,5,383,0,0,1319,1320,5,490,0,0,1320,1322,
  	3,862,431,0,1321,1318,1,0,0,0,1321,1322,1,0,0,0,1322,1329,1,0,0,0,1323,
  	1324,5,383,0,0,1324,1326,5,79,0,0,1325,1327,5,371,0,0,1326,1325,1,0,0,
  	0,1326,1327,1,0,0,0,1327,1328,1,0,0,0,1328,1330,5,418,0,0,1329,1323,1,
  	0,0,0,1329,1330,1,0,0,0,1330,1334,1,0,0,0,1331,1332,5,453,0,0,1332,1333,
  	5,590,0,0,1333,1335,3,1128,564,0,1334,1331,1,0,0,0,1334,1335,1,0,0,0,
  	1335,1342,1,0,0,0,1336,1343,5,156,0,0,1337,1340,5,140,0,0,1338,1339,5,
  	383,0,0,1339,1341,5,514,0,0,1340,1338,1,0,0,0,1340,1341,1,0,0,0,1341,
  	1343,1,0,0,0,1342,1336,1,0,0,0,1342,1337,1,0,0,0,1342,1343,1,0,0,0,1343,
  	1346,1,0,0,0,1344,1345,5,75,0,0,1345,1347,3,1160,580,0,1346,1344,1,0,
  	0,0,1346,1347,1,0,0,0,1347,1350,1,0,0,0,1348,1349,5,147,0,0,1349,1351,
  	3,784,392,0,1350,1348,1,0,0,0,1350,1351,1,0,0,0,1351,9,1,0,0,0,1352,1353,
  	5,288,0,0,1353,1354,5,217,0,0,1354,1355,3,1082,541,0,1355,1356,5,4,0,
  	0,1356,1357,5,603,0,0,1357,1359,3,1160,580,0,1358,1360,3,12,6,0,1359,
  	1358,1,0,0,0,1359,1360,1,0,0,0,1360,11,1,0,0,0,1361,1368,3,14,7,0,1362,
  	1364,5,773,0,0,1363,1362,1,0,0,0,1363,1364,1,0,0,0,1364,1365,1,0,0,0,
  	1365,1367,3,14,7,0,1366,1363,1,0,0,0,1367,1370,1,0,0,0,1368,1366,1,0,
  	0,0,1368,1369,1,0,0,0,1369,13,1,0,0,0,1370,1368,1,0,0,0,1371,1375,3,136,
  	68,0,1372,1375,3,148,74,0,1373,1375,3,150,75,0,1374,1371,1,0,0,0,1374,
  	1372,1,0,0,0,1374,1373,1,0,0,0,1375,15,1,0,0,0,1376,1377,5,503,0,0,1377,
  	1378,3,1092,546,0,1378,1379,3,120,60,0,1379,17,1,0,0,0,1380,1382,3,1032,
  	516,0,1381,1380,1,0,0,0,1381,1382,1,0,0,0,1382,1385,1,0,0,0,1383,1384,
  	4,9,7,0,1384,1386,5,232,0,0,1385,1383,1,0,0,0,1385,1386,1,0,0,0,1386,
  	1387,1,0,0,0,1387,1388,5,574,0,0,1388,1390,3,1102,551,0,1389,1391,3,20,
  	10,0,1390,1389,1,0,0,0,1390,1391,1,0,0,0,1391,19,1,0,0,0,1392,1395,3,
  	22,11,0,1393,1396,3,954,477,0,1394,1396,3,50,25,0,1395,1393,1,0,0,0,1395,
  	1394,1,0,0,0,1395,1396,1,0,0,0,1396,1406,1,0,0,0,1397,1406,3,954,477,
  	0,1398,1406,3,50,25,0,1399,1400,3,24,12,0,1400,1401,5,773,0,0,1401,1403,
  	1,0,0,0,1402,1399,1,0,0,0,1402,1403,1,0,0,0,1403,1404,1,0,0,0,1404,1406,
  	3,26,13,0,1405,1392,1,0,0,0,1405,1397,1,0,0,0,1405,1398,1,0,0,0,1405,
  	1402,1,0,0,0,1406,21,1,0,0,0,1407,1415,3,24,12,0,1408,1409,3,24,12,0,
  	1409,1410,5,773,0,0,1410,1412,1,0,0,0,1411,1408,1,0,0,0,1411,1412,1,0,
  	0,0,1412,1413,1,0,0,0,1413,1415,3,30,15,0,1414,1407,1,0,0,0,1414,1411,
  	1,0,0,0,1415,23,1,0,0,0,1416,1421,3,32,16,0,1417,1418,5,773,0,0,1418,
  	1420,3,32,16,0,1419,1417,1,0,0,0,1420,1423,1,0,0,0,1421,1419,1,0,0,0,
  	1421,1422,1,0,0,0,1422,25,1,0,0,0,1423,1421,1,0,0,0,1424,1425,5,141,0,
  	0,1425,1432,5,572,0,0,1426,1427,5,234,0,0,1427,1432,5,572,0,0,1428,1432,
  	3,28,14,0,1429,1430,4,13,8,0,1430,1432,7,0,0,0,1431,1424,1,0,0,0,1431,
  	1426,1,0,0,0,1431,1428,1,0,0,0,1431,1429,1,0,0,0,1432,27,1,0,0,0,1433,
  	1434,5,4,0,0,1434,1436,5,405,0,0,1435,1437,3,1034,517,0,1436,1435,1,0,
  	0,0,1436,1437,1,0,0,0,1437,1441,1,0,0,0,1438,1442,3,962,481,0,1439,1440,
  	5,404,0,0,1440,1442,3,1142,571,0,1441,1438,1,0,0,0,1441,1439,1,0,0,0,
  	1442,1530,1,0,0,0,1443,1444,5,148,0,0,1444,1445,5,405,0,0,1445,1530,3,
  	1130,565,0,1446,1447,5,438,0,0,1447,1449,5,405,0,0,1448,1450,3,1034,517,
  	0,1449,1448,1,0,0,0,1449,1450,1,0,0,0,1450,1451,1,0,0,0,1451,1530,3,52,
  	26,0,1452,1453,5,388,0,0,1453,1455,5,405,0,0,1454,1456,3,1034,517,0,1455,
  	1454,1,0,0,0,1455,1456,1,0,0,0,1456,1457,1,0,0,0,1457,1459,3,52,26,0,
  	1458,1460,3,1034,517,0,1459,1458,1,0,0,0,1459,1460,1,0,0,0,1460,1530,
  	1,0,0,0,1461,1462,5,14,0,0,1462,1464,5,405,0,0,1463,1465,3,1034,517,0,
  	1464,1463,1,0,0,0,1464,1465,1,0,0,0,1465,1466,1,0,0,0,1466,1530,3,52,
  	26,0,1467,1468,5,62,0,0,1468,1469,5,405,0,0,1469,1473,3,52,26,0,1470,
  	1472,3,568,284,0,1471,1470,1,0,0,0,1472,1475,1,0,0,0,1473,1471,1,0,0,
  	0,1473,1474,1,0,0,0,1474,1530,1,0,0,0,1475,1473,1,0,0,0,1476,1477,5,455,
  	0,0,1477,1479,5,405,0,0,1478,1480,3,1034,517,0,1479,1478,1,0,0,0,1479,
  	1480,1,0,0,0,1480,1481,1,0,0,0,1481,1485,3,52,26,0,1482,1484,3,570,285,
  	0,1483,1482,1,0,0,0,1484,1487,1,0,0,0,1485,1483,1,0,0,0,1485,1486,1,0,
  	0,0,1486,1530,1,0,0,0,1487,1485,1,0,0,0,1488,1489,5,67,0,0,1489,1491,
  	5,405,0,0,1490,1492,3,1034,517,0,1491,1490,1,0,0,0,1491,1492,1,0,0,0,
  	1492,1493,1,0,0,0,1493,1530,3,1142,571,0,1494,1495,5,597,0,0,1495,1496,
  	5,405,0,0,1496,1530,3,52,26,0,1497,1498,5,454,0,0,1498,1500,5,405,0,0,
  	1499,1501,3,1034,517,0,1500,1499,1,0,0,0,1500,1501,1,0,0,0,1501,1506,
  	1,0,0,0,1502,1503,3,1130,565,0,1503,1504,5,248,0,0,1504,1505,3,962,481,
  	0,1505,1507,1,0,0,0,1506,1502,1,0,0,0,1506,1507,1,0,0,0,1507,1530,1,0,
  	0,0,1508,1509,5,172,0,0,1509,1510,5,405,0,0,1510,1511,3,1128,564,0,1511,
  	1512,5,645,0,0,1512,1513,5,574,0,0,1513,1515,3,1102,551,0,1514,1516,3,
  	48,24,0,1515,1514,1,0,0,0,1515,1516,1,0,0,0,1516,1530,1,0,0,0,1517,1518,
  	4,14,9,0,1518,1519,5,141,0,0,1519,1520,5,405,0,0,1520,1521,3,52,26,0,
  	1521,1522,5,572,0,0,1522,1530,1,0,0,0,1523,1524,4,14,10,0,1524,1525,5,
  	234,0,0,1525,1526,5,405,0,0,1526,1527,3,52,26,0,1527,1528,5,572,0,0,1528,
  	1530,1,0,0,0,1529,1433,1,0,0,0,1529,1443,1,0,0,0,1529,1446,1,0,0,0,1529,
  	1452,1,0,0,0,1529,1461,1,0,0,0,1529,1467,1,0,0,0,1529,1476,1,0,0,0,1529,
  	1488,1,0,0,0,1529,1494,1,0,0,0,1529,1497,1,0,0,0,1529,1508,1,0,0,0,1529,
  	1517,1,0,0,0,1529,1523,1,0,0,0,1530,29,1,0,0,0,1531,1534,3,34,17,0,1532,
  	1534,3,942,471,0,1533,1531,1,0,0,0,1533,1532,1,0,0,0,1534,1543,1,0,0,
  	0,1535,1539,5,773,0,0,1536,1540,3,34,17,0,1537,1540,3,32,16,0,1538,1540,
  	3,942,471,0,1539,1536,1,0,0,0,1539,1537,1,0,0,0,1539,1538,1,0,0,0,1540,
  	1542,1,0,0,0,1541,1535,1,0,0,0,1542,1545,1,0,0,0,1543,1541,1,0,0,0,1543,
  	1544,1,0,0,0,1544,31,1,0,0,0,1545,1543,1,0,0,0,1546,1550,3,42,21,0,1547,
  	1550,3,44,22,0,1548,1550,3,48,24,0,1549,1546,1,0,0,0,1549,1547,1,0,0,
  	0,1549,1548,1,0,0,0,1550,33,1,0,0,0,1551,1553,5,4,0,0,1552,1554,5,72,
  	0,0,1553,1552,1,0,0,0,1553,1554,1,0,0,0,1554,1567,1,0,0,0,1555,1556,3,
  	1128,564,0,1556,1558,3,876,438,0,1557,1559,3,866,433,0,1558,1557,1,0,
  	0,0,1558,1559,1,0,0,0,1559,1561,1,0,0,0,1560,1562,3,36,18,0,1561,1560,
  	1,0,0,0,1561,1562,1,0,0,0,1562,1568,1,0,0,0,1563,1564,5,776,0,0,1564,
  	1565,3,84,42,0,1565,1566,5,777,0,0,1566,1568,1,0,0,0,1567,1555,1,0,0,
  	0,1567,1563,1,0,0,0,1568,1697,1,0,0,0,1569,1570,5,4,0,0,1570,1697,3,872,
  	436,0,1571,1573,5,55,0,0,1572,1574,5,72,0,0,1573,1572,1,0,0,0,1573,1574,
  	1,0,0,0,1574,1575,1,0,0,0,1575,1576,3,1042,521,0,1576,1577,3,1128,564,
  	0,1577,1579,3,876,438,0,1578,1580,3,36,18,0,1579,1578,1,0,0,0,1579,1580,
  	1,0,0,0,1580,1697,1,0,0,0,1581,1583,5,348,0,0,1582,1584,5,72,0,0,1583,
  	1582,1,0,0,0,1583,1584,1,0,0,0,1584,1585,1,0,0,0,1585,1586,3,1042,521,
  	0,1586,1588,3,876,438,0,1587,1589,3,36,18,0,1588,1587,1,0,0,0,1588,1589,
  	1,0,0,0,1589,1697,1,0,0,0,1590,1619,5,148,0,0,1591,1593,5,72,0,0,1592,
  	1591,1,0,0,0,1592,1593,1,0,0,0,1593,1594,1,0,0,0,1594,1596,3,1042,521,
  	0,1595,1597,3,38,19,0,1596,1595,1,0,0,0,1596,1597,1,0,0,0,1597,1620,1,
  	0,0,0,1598,1599,5,199,0,0,1599,1606,5,265,0,0,1600,1601,4,17,11,0,1601,
  	1607,3,1042,521,0,1602,1604,4,17,12,0,1603,1605,3,1042,521,0,1604,1603,
  	1,0,0,0,1604,1605,1,0,0,0,1605,1607,1,0,0,0,1606,1600,1,0,0,0,1606,1602,
  	1,0,0,0,1607,1620,1,0,0,0,1608,1609,5,420,0,0,1609,1620,5,265,0,0,1610,
  	1611,3,406,203,0,1611,1612,3,1052,526,0,1612,1620,1,0,0,0,1613,1614,4,
  	17,13,0,1614,1615,5,62,0,0,1615,1620,3,1128,564,0,1616,1617,4,17,14,0,
  	1617,1618,5,86,0,0,1618,1620,3,1128,564,0,1619,1592,1,0,0,0,1619,1598,
  	1,0,0,0,1619,1608,1,0,0,0,1619,1610,1,0,0,0,1619,1613,1,0,0,0,1619,1616,
  	1,0,0,0,1620,1697,1,0,0,0,1621,1622,5,140,0,0,1622,1697,5,263,0,0,1623,
  	1624,5,156,0,0,1624,1697,5,263,0,0,1625,1627,5,11,0,0,1626,1628,5,72,
  	0,0,1627,1626,1,0,0,0,1627,1628,1,0,0,0,1628,1629,1,0,0,0,1629,1639,3,
  	1042,521,0,1630,1631,5,506,0,0,1631,1635,5,128,0,0,1632,1633,4,17,15,
  	0,1633,1636,3,770,385,0,1634,1636,3,1150,575,0,1635,1632,1,0,0,0,1635,
  	1634,1,0,0,0,1636,1640,1,0,0,0,1637,1638,5,148,0,0,1638,1640,5,128,0,
  	0,1639,1630,1,0,0,0,1639,1637,1,0,0,0,1640,1697,1,0,0,0,1641,1642,4,17,
  	16,0,1642,1643,5,11,0,0,1643,1644,5,236,0,0,1644,1645,3,1052,526,0,1645,
  	1646,3,906,453,0,1646,1697,1,0,0,0,1647,1648,4,17,17,0,1648,1649,5,11,
  	0,0,1649,1650,5,62,0,0,1650,1651,3,1128,564,0,1651,1652,3,870,435,0,1652,
  	1697,1,0,0,0,1653,1654,4,17,18,0,1654,1655,5,11,0,0,1655,1656,5,86,0,
  	0,1656,1657,3,1128,564,0,1657,1658,3,870,435,0,1658,1697,1,0,0,0,1659,
  	1660,4,17,19,0,1660,1661,5,453,0,0,1661,1662,5,72,0,0,1662,1663,3,1042,
  	521,0,1663,1664,5,590,0,0,1664,1665,3,1128,564,0,1665,1697,1,0,0,0,1666,
  	1668,5,453,0,0,1667,1669,7,1,0,0,1668,1667,1,0,0,0,1668,1669,1,0,0,0,
  	1669,1670,1,0,0,0,1670,1697,3,1096,548,0,1671,1672,4,17,20,0,1672,1673,
  	5,453,0,0,1673,1674,3,406,203,0,1674,1675,3,1052,526,0,1675,1676,5,590,
  	0,0,1676,1677,3,1050,525,0,1677,1697,1,0,0,0,1678,1679,5,94,0,0,1679,
  	1680,5,590,0,0,1680,1684,3,758,379,0,1681,1682,4,17,21,0,1682,1685,5,
  	128,0,0,1683,1685,3,936,468,0,1684,1681,1,0,0,0,1684,1683,1,0,0,0,1685,
  	1687,1,0,0,0,1686,1688,3,986,493,0,1687,1686,1,0,0,0,1687,1688,1,0,0,
  	0,1688,1697,1,0,0,0,1689,1697,5,198,0,0,1690,1691,5,393,0,0,1691,1692,
  	5,45,0,0,1692,1697,3,40,20,0,1693,1694,4,17,22,0,1694,1695,5,615,0,0,
  	1695,1697,5,403,0,0,1696,1551,1,0,0,0,1696,1569,1,0,0,0,1696,1571,1,0,
  	0,0,1696,1581,1,0,0,0,1696,1590,1,0,0,0,1696,1621,1,0,0,0,1696,1623,1,
  	0,0,0,1696,1625,1,0,0,0,1696,1641,1,0,0,0,1696,1647,1,0,0,0,1696,1653,
  	1,0,0,0,1696,1659,1,0,0,0,1696,1666,1,0,0,0,1696,1671,1,0,0,0,1696,1678,
  	1,0,0,0,1696,1689,1,0,0,0,1696,1690,1,0,0,0,1696,1693,1,0,0,0,1697,35,
  	1,0,0,0,1698,1699,5,6,0,0,1699,1702,3,1128,564,0,1700,1702,5,191,0,0,
  	1701,1698,1,0,0,0,1701,1700,1,0,0,0,1702,37,1,0,0,0,1703,1704,7,2,0,0,
  	1704,39,1,0,0,0,1705,1707,3,1128,564,0,1706,1708,3,330,165,0,1707,1706,
  	1,0,0,0,1707,1708,1,0,0,0,1708,1716,1,0,0,0,1709,1710,5,773,0,0,1710,
  	1712,3,1128,564,0,1711,1713,3,330,165,0,1712,1711,1,0,0,0,1712,1713,1,
  	0,0,0,1713,1715,1,0,0,0,1714,1709,1,0,0,0,1715,1718,1,0,0,0,1716,1714,
  	1,0,0,0,1716,1717,1,0,0,0,1717,41,1,0,0,0,1718,1716,1,0,0,0,1719,1721,
  	5,9,0,0,1720,1722,5,750,0,0,1721,1720,1,0,0,0,1721,1722,1,0,0,0,1722,
  	1725,1,0,0,0,1723,1726,5,128,0,0,1724,1726,3,1128,564,0,1725,1723,1,0,
  	0,0,1725,1724,1,0,0,0,1726,43,1,0,0,0,1727,1729,5,287,0,0,1728,1730,5,
  	750,0,0,1729,1728,1,0,0,0,1729,1730,1,0,0,0,1730,1733,1,0,0,0,1731,1734,
  	5,128,0,0,1732,1734,3,1128,564,0,1733,1731,1,0,0,0,1733,1732,1,0,0,0,
  	1734,45,1,0,0,0,1735,1737,3,42,21,0,1736,1738,3,44,22,0,1737,1736,1,0,
  	0,0,1737,1738,1,0,0,0,1738,1744,1,0,0,0,1739,1741,3,44,22,0,1740,1742,
  	3,42,21,0,1741,1740,1,0,0,0,1741,1742,1,0,0,0,1742,1744,1,0,0,0,1743,
  	1735,1,0,0,0,1743,1739,1,0,0,0,1744,47,1,0,0,0,1745,1746,4,24,23,0,1746,
  	1747,7,3,0,0,1747,1748,5,625,0,0,1748,49,1,0,0,0,1749,1750,5,452,0,0,
  	1750,1751,5,403,0,0,1751,51,1,0,0,0,1752,1755,5,10,0,0,1753,1755,3,1130,
  	565,0,1754,1752,1,0,0,0,1754,1753,1,0,0,0,1755,53,1,0,0,0,1756,1757,5,
  	572,0,0,1757,1791,3,1078,539,0,1758,1759,7,4,0,0,1759,1760,5,111,0,0,
  	1760,1762,3,1160,580,0,1761,1763,3,62,31,0,1762,1761,1,0,0,0,1762,1763,
  	1,0,0,0,1763,1792,1,0,0,0,1764,1784,4,27,24,0,1765,1785,1,0,0,0,1766,
  	1767,5,55,0,0,1767,1768,5,111,0,0,1768,1779,3,1160,580,0,1769,1776,3,
  	66,33,0,1770,1772,5,773,0,0,1771,1770,1,0,0,0,1771,1772,1,0,0,0,1772,
  	1773,1,0,0,0,1773,1775,3,66,33,0,1774,1771,1,0,0,0,1775,1778,1,0,0,0,
  	1776,1774,1,0,0,0,1776,1777,1,0,0,0,1777,1780,1,0,0,0,1778,1776,1,0,0,
  	0,1779,1769,1,0,0,0,1779,1780,1,0,0,0,1780,1785,1,0,0,0,1781,1785,7,5,
  	0,0,1782,1783,5,371,0,0,1783,1785,5,1,0,0,1784,1765,1,0,0,0,1784,1766,
  	1,0,0,0,1784,1781,1,0,0,0,1784,1782,1,0,0,0,1785,1792,1,0,0,0,1786,1787,
  	5,453,0,0,1787,1788,5,590,0,0,1788,1792,3,1128,564,0,1789,1790,4,27,25,
  	0,1790,1792,3,62,31,0,1791,1758,1,0,0,0,1791,1764,1,0,0,0,1791,1786,1,
  	0,0,0,1791,1789,1,0,0,0,1792,55,1,0,0,0,1793,1794,5,605,0,0,1794,1795,
  	5,572,0,0,1795,1796,3,1078,539,0,1796,1797,5,506,0,0,1797,1799,7,6,0,
  	0,1798,1800,3,58,29,0,1799,1798,1,0,0,0,1799,1800,1,0,0,0,1800,57,1,0,
  	0,0,1801,1808,3,60,30,0,1802,1804,5,773,0,0,1803,1802,1,0,0,0,1803,1804,
  	1,0,0,0,1804,1805,1,0,0,0,1805,1807,3,60,30,0,1806,1803,1,0,0,0,1807,
  	1810,1,0,0,0,1808,1806,1,0,0,0,1808,1809,1,0,0,0,1809,59,1,0,0,0,1810,
  	1808,1,0,0,0,1811,1812,3,148,74,0,1812,61,1,0,0,0,1813,1820,3,64,32,0,
  	1814,1816,5,773,0,0,1815,1814,1,0,0,0,1815,1816,1,0,0,0,1816,1817,1,0,
  	0,0,1817,1819,3,64,32,0,1818,1815,1,0,0,0,1819,1822,1,0,0,0,1820,1818,
  	1,0,0,0,1820,1821,1,0,0,0,1821,63,1,0,0,0,1822,1820,1,0,0,0,1823,1825,
  	5,238,0,0,1824,1826,5,750,0,0,1825,1824,1,0,0,0,1825,1826,1,0,0,0,1826,
  	1827,1,0,0,0,1827,1834,3,1186,593,0,1828,1834,3,140,70,0,1829,1834,3,
  	142,71,0,1830,1834,3,148,74,0,1831,1834,3,150,75,0,1832,1834,3,156,78,
  	0,1833,1823,1,0,0,0,1833,1828,1,0,0,0,1833,1829,1,0,0,0,1833,1830,1,0,
  	0,0,1833,1831,1,0,0,0,1833,1832,1,0,0,0,1834,65,1,0,0,0,1835,1837,5,238,
  	0,0,1836,1838,5,750,0,0,1837,1836,1,0,0,0,1837,1838,1,0,0,0,1838,1839,
  	1,0,0,0,1839,1843,3,1186,593,0,1840,1843,3,140,70,0,1841,1843,3,142,71,
  	0,1842,1835,1,0,0,0,1842,1840,1,0,0,0,1842,1841,1,0,0,0,1843,67,1,0,0,
  	0,1844,1846,3,162,81,0,1845,1844,1,0,0,0,1845,1846,1,0,0,0,1846,1848,
  	1,0,0,0,1847,1849,3,976,488,0,1848,1847,1,0,0,0,1848,1849,1,0,0,0,1849,
  	1851,1,0,0,0,1850,1852,3,164,82,0,1851,1850,1,0,0,0,1851,1852,1,0,0,0,
  	1852,1853,1,0,0,0,1853,1854,5,636,0,0,1854,1855,3,1074,537,0,1855,1856,
  	3,70,35,0,1856,69,1,0,0,0,1857,1859,3,1044,522,0,1858,1857,1,0,0,0,1858,
  	1859,1,0,0,0,1859,1860,1,0,0,0,1860,1861,5,17,0,0,1861,1862,3,72,36,0,
  	1862,71,1,0,0,0,1863,1865,3,90,45,0,1864,1866,3,74,37,0,1865,1864,1,0,
  	0,0,1865,1866,1,0,0,0,1866,73,1,0,0,0,1867,1869,5,645,0,0,1868,1870,7,
  	7,0,0,1869,1868,1,0,0,0,1869,1870,1,0,0,0,1870,1871,1,0,0,0,1871,1872,
  	5,62,0,0,1872,1873,5,391,0,0,1873,75,1,0,0,0,1874,1893,5,97,0,0,1875,
  	1894,3,78,39,0,1876,1894,3,82,41,0,1877,1894,3,96,48,0,1878,1894,3,94,
  	47,0,1879,1894,3,98,49,0,1880,1894,3,112,56,0,1881,1894,3,158,79,0,1882,
  	1894,3,166,83,0,1883,1894,3,106,53,0,1884,1894,3,118,59,0,1885,1894,3,
  	124,62,0,1886,1894,3,170,85,0,1887,1888,4,38,26,0,1888,1894,3,172,86,
  	0,1889,1890,4,38,27,0,1890,1894,3,174,87,0,1891,1892,4,38,28,0,1892,1894,
  	3,126,63,0,1893,1875,1,0,0,0,1893,1876,1,0,0,0,1893,1877,1,0,0,0,1893,
  	1878,1,0,0,0,1893,1879,1,0,0,0,1893,1880,1,0,0,0,1893,1881,1,0,0,0,1893,
  	1882,1,0,0,0,1893,1883,1,0,0,0,1893,1884,1,0,0,0,1893,1885,1,0,0,0,1893,
  	1886,1,0,0,0,1893,1887,1,0,0,0,1893,1889,1,0,0,0,1893,1891,1,0,0,0,1894,
  	77,1,0,0,0,1895,1897,5,109,0,0,1896,1898,3,980,490,0,1897,1896,1,0,0,
  	0,1897,1898,1,0,0,0,1898,1899,1,0,0,0,1899,1903,3,1056,528,0,1900,1902,
  	3,80,40,0,1901,1900,1,0,0,0,1902,1905,1,0,0,0,1903,1901,1,0,0,0,1903,
  	1904,1,0,0,0,1904,79,1,0,0,0,1905,1903,1,0,0,0,1906,1911,3,952,476,0,
  	1907,1911,3,948,474,0,1908,1909,4,40,29,0,1909,1911,3,950,475,0,1910,
  	1906,1,0,0,0,1910,1907,1,0,0,0,1910,1908,1,0,0,0,1911,81,1,0,0,0,1912,
  	1914,5,577,0,0,1913,1912,1,0,0,0,1913,1914,1,0,0,0,1914,1915,1,0,0,0,
  	1915,1917,5,574,0,0,1916,1918,3,980,490,0,1917,1916,1,0,0,0,1917,1918,
  	1,0,0,0,1918,1919,1,0,0,0,1919,1942,3,1096,548,0,1920,1921,5,776,0,0,
  	1921,1922,3,84,42,0,1922,1923,5,777,0,0,1923,1925,1,0,0,0,1924,1920,1,
  	0,0,0,1924,1925,1,0,0,0,1925,1927,1,0,0,0,1926,1928,3,940,470,0,1927,
  	1926,1,0,0,0,1927,1928,1,0,0,0,1928,1930,1,0,0,0,1929,1931,3,954,477,
  	0,1930,1929,1,0,0,0,1930,1931,1,0,0,0,1931,1933,1,0,0,0,1932,1934,3,88,
  	44,0,1933,1932,1,0,0,0,1933,1934,1,0,0,0,1934,1943,1,0,0,0,1935,1936,
  	5,275,0,0,1936,1943,3,1102,551,0,1937,1938,5,776,0,0,1938,1939,5,275,
  	0,0,1939,1940,3,1102,551,0,1940,1941,5,777,0,0,1941,1943,1,0,0,0,1942,
  	1924,1,0,0,0,1942,1935,1,0,0,0,1942,1937,1,0,0,0,1943,83,1,0,0,0,1944,
  	1949,3,86,43,0,1945,1946,5,773,0,0,1946,1948,3,86,43,0,1947,1945,1,0,
  	0,0,1948,1951,1,0,0,0,1949,1947,1,0,0,0,1949,1950,1,0,0,0,1950,85,1,0,
  	0,0,1951,1949,1,0,0,0,1952,1955,3,864,432,0,1953,1955,3,872,436,0,1954,
  	1952,1,0,0,0,1954,1953,1,0,0,0,1955,87,1,0,0,0,1956,1958,7,8,0,0,1957,
  	1956,1,0,0,0,1957,1958,1,0,0,0,1958,1960,1,0,0,0,1959,1961,5,17,0,0,1960,
  	1959,1,0,0,0,1960,1961,1,0,0,0,1961,1962,1,0,0,0,1962,1963,3,90,45,0,
  	1963,89,1,0,0,0,1964,1967,3,270,135,0,1965,1967,3,274,137,0,1966,1964,
  	1,0,0,0,1966,1965,1,0,0,0,1967,91,1,0,0,0,1968,1972,5,97,0,0,1969,1973,
  	3,94,47,0,1970,1973,3,96,48,0,1971,1973,3,98,49,0,1972,1969,1,0,0,0,1972,
  	1970,1,0,0,0,1972,1971,1,0,0,0,1973,1975,1,0,0,0,1974,1976,5,774,0,0,
  	1975,1974,1,0,0,0,1975,1976,1,0,0,0,1976,1977,1,0,0,0,1977,1978,5,0,0,
  	1,1978,93,1,0,0,0,1979,1981,3,976,488,0,1980,1979,1,0,0,0,1980,1981,1,
  	0,0,0,1981,1982,1,0,0,0,1982,1983,5,422,0,0,1983,1984,3,1060,530,0,1984,
  	1993,5,776,0,0,1985,1990,3,982,491,0,1986,1987,5,773,0,0,1987,1989,3,
  	982,491,0,1988,1986,1,0,0,0,1989,1992,1,0,0,0,1990,1988,1,0,0,0,1990,
  	1991,1,0,0,0,1991,1994,1,0,0,0,1992,1990,1,0,0,0,1993,1985,1,0,0,0,1993,
  	1994,1,0,0,0,1994,1995,1,0,0,0,1995,1999,5,777,0,0,1996,1998,3,100,50,
  	0,1997,1996,1,0,0,0,1998,2001,1,0,0,0,1999,1997,1,0,0,0,1999,2000,1,0,
  	0,0,2000,2002,1,0,0,0,2001,1999,1,0,0,0,2002,2003,3,784,392,0,2003,95,
  	1,0,0,0,2004,2006,3,976,488,0,2005,2004,1,0,0,0,2005,2006,1,0,0,0,2006,
  	2007,1,0,0,0,2007,2008,5,206,0,0,2008,2009,3,1064,532,0,2009,2018,5,776,
  	0,0,2010,2015,3,984,492,0,2011,2012,5,773,0,0,2012,2014,3,984,492,0,2013,
  	2011,1,0,0,0,2014,2017,1,0,0,0,2015,2013,1,0,0,0,2015,2016,1,0,0,0,2016,
  	2019,1,0,0,0,2017,2015,1,0,0,0,2018,2010,1,0,0,0,2018,2019,1,0,0,0,2019,
  	2020,1,0,0,0,2020,2021,5,777,0,0,2021,2022,5,474,0,0,2022,2026,3,988,
  	494,0,2023,2025,3,100,50,0,2024,2023,1,0,0,0,2025,2028,1,0,0,0,2026,2024,
  	1,0,0,0,2026,2027,1,0,0,0,2027,2029,1,0,0,0,2028,2026,1,0,0,0,2029,2030,
  	3,784,392,0,2030,97,1,0,0,0,2031,2033,5,8,0,0,2032,2031,1,0,0,0,2032,
  	2033,1,0,0,0,2033,2034,1,0,0,0,2034,2035,5,206,0,0,2035,2036,3,1088,544,
  	0,2036,2037,5,474,0,0,2037,2038,7,9,0,0,2038,2039,5,520,0,0,2039,2040,
  	3,1160,580,0,2040,99,1,0,0,0,2041,2047,3,104,52,0,2042,2044,5,371,0,0,
  	2043,2042,1,0,0,0,2043,2044,1,0,0,0,2044,2045,1,0,0,0,2045,2047,5,137,
  	0,0,2046,2041,1,0,0,0,2046,2043,1,0,0,0,2047,101,1,0,0,0,2048,2050,3,
  	100,50,0,2049,2048,1,0,0,0,2050,2051,1,0,0,0,2051,2049,1,0,0,0,2051,2052,
  	1,0,0,0,2052,103,1,0,0,0,2053,2054,5,75,0,0,2054,2071,3,1160,580,0,2055,
  	2056,5,267,0,0,2056,2071,5,537,0,0,2057,2058,5,373,0,0,2058,2071,5,537,
  	0,0,2059,2060,5,90,0,0,2060,2071,5,537,0,0,2061,2062,5,433,0,0,2062,2063,
  	5,537,0,0,2063,2071,5,112,0,0,2064,2065,5,347,0,0,2065,2066,5,537,0,0,
  	2066,2071,5,112,0,0,2067,2068,5,537,0,0,2068,2069,5,496,0,0,2069,2071,
  	7,10,0,0,2070,2053,1,0,0,0,2070,2055,1,0,0,0,2070,2057,1,0,0,0,2070,2059,
  	1,0,0,0,2070,2061,1,0,0,0,2070,2064,1,0,0,0,2070,2067,1,0,0,0,2071,105,
  	1,0,0,0,2072,2074,3,1032,516,0,2073,2072,1,0,0,0,2073,2074,1,0,0,0,2074,
  	2116,1,0,0,0,2075,2077,5,609,0,0,2076,2075,1,0,0,0,2076,2077,1,0,0,0,
  	2077,2078,1,0,0,0,2078,2087,5,236,0,0,2079,2080,4,53,30,0,2080,2082,3,
  	1050,525,0,2081,2083,3,908,454,0,2082,2081,1,0,0,0,2082,2083,1,0,0,0,
  	2083,2088,1,0,0,0,2084,2086,3,108,54,0,2085,2084,1,0,0,0,2085,2086,1,
  	0,0,0,2086,2088,1,0,0,0,2087,2079,1,0,0,0,2087,2085,1,0,0,0,2088,2089,
  	1,0,0,0,2089,2093,3,110,55,0,2090,2092,3,902,451,0,2091,2090,1,0,0,0,
  	2092,2095,1,0,0,0,2093,2091,1,0,0,0,2093,2094,1,0,0,0,2094,2117,1,0,0,
  	0,2095,2093,1,0,0,0,2096,2097,5,205,0,0,2097,2098,5,236,0,0,2098,2099,
  	3,1050,525,0,2099,2103,3,110,55,0,2100,2102,3,910,455,0,2101,2100,1,0,
  	0,0,2102,2105,1,0,0,0,2103,2101,1,0,0,0,2103,2104,1,0,0,0,2104,2117,1,
  	0,0,0,2105,2103,1,0,0,0,2106,2107,5,523,0,0,2107,2108,5,236,0,0,2108,
  	2109,3,1050,525,0,2109,2113,3,110,55,0,2110,2112,3,912,456,0,2111,2110,
  	1,0,0,0,2112,2115,1,0,0,0,2113,2111,1,0,0,0,2113,2114,1,0,0,0,2114,2117,
  	1,0,0,0,2115,2113,1,0,0,0,2116,2076,1,0,0,0,2116,2096,1,0,0,0,2116,2106,
  	1,0,0,0,2117,2119,1,0,0,0,2118,2120,3,46,23,0,2119,2118,1,0,0,0,2119,
  	2120,1,0,0,0,2120,107,1,0,0,0,2121,2124,3,1050,525,0,2122,2123,5,621,
  	0,0,2123,2125,3,900,450,0,2124,2122,1,0,0,0,2124,2125,1,0,0,0,2125,2131,
  	1,0,0,0,2126,2127,3,1050,525,0,2127,2128,5,599,0,0,2128,2129,3,900,450,
  	0,2129,2131,1,0,0,0,2130,2121,1,0,0,0,2130,2126,1,0,0,0,2131,109,1,0,
  	0,0,2132,2133,5,383,0,0,2133,2134,3,1102,551,0,2134,2135,3,898,449,0,
  	2135,111,1,0,0,0,2136,2137,5,288,0,0,2137,2138,5,217,0,0,2138,2139,3,
  	1080,540,0,2139,2140,5,4,0,0,2140,2141,7,11,0,0,2141,2143,3,1160,580,
  	0,2142,2144,3,114,57,0,2143,2142,1,0,0,0,2143,2144,1,0,0,0,2144,113,1,
  	0,0,0,2145,2152,3,116,58,0,2146,2148,5,773,0,0,2147,2146,1,0,0,0,2147,
  	2148,1,0,0,0,2148,2149,1,0,0,0,2149,2151,3,116,58,0,2150,2147,1,0,0,0,
  	2151,2154,1,0,0,0,2152,2150,1,0,0,0,2152,2153,1,0,0,0,2153,115,1,0,0,
  	0,2154,2152,1,0,0,0,2155,2162,3,136,68,0,2156,2162,3,138,69,0,2157,2162,
  	3,146,73,0,2158,2162,3,148,74,0,2159,2162,3,150,75,0,2160,2162,3,152,
  	76,0,2161,2155,1,0,0,0,2161,2156,1,0,0,0,2161,2157,1,0,0,0,2161,2158,
  	1,0,0,0,2161,2159,1,0,0,0,2161,2160,1,0,0,0,2162,117,1,0,0,0,2163,2164,
  	5,503,0,0,2164,2165,3,1090,545,0,2165,2166,5,199,0,0,2166,2167,5,112,
  	0,0,2167,2168,5,648,0,0,2168,2169,3,1180,590,0,2169,2170,3,120,60,0,2170,
  	119,1,0,0,0,2171,2172,5,390,0,0,2172,2173,5,776,0,0,2173,2178,3,122,61,
  	0,2174,2175,5,773,0,0,2175,2177,3,122,61,0,2176,2174,1,0,0,0,2177,2180,
  	1,0,0,0,2178,2176,1,0,0,0,2178,2179,1,0,0,0,2179,2181,1,0,0,0,2180,2178,
  	1,0,0,0,2181,2182,5,777,0,0,2182,121,1,0,0,0,2183,2184,5,224,0,0,2184,
  	2198,3,1160,580,0,2185,2186,5,109,0,0,2186,2198,3,1160,580,0,2187,2188,
  	5,618,0,0,2188,2198,3,1160,580,0,2189,2190,5,406,0,0,2190,2198,3,1160,
  	580,0,2191,2192,5,519,0,0,2192,2198,3,1160,580,0,2193,2194,5,398,0,0,
  	2194,2198,3,1160,580,0,2195,2196,5,413,0,0,2196,2198,3,1140,570,0,2197,
  	2183,1,0,0,0,2197,2185,1,0,0,0,2197,2187,1,0,0,0,2197,2189,1,0,0,0,2197,
  	2191,1,0,0,0,2197,2193,1,0,0,0,2197,2195,1,0,0,0,2198,123,1,0,0,0,2199,
  	2200,5,572,0,0,2200,2201,3,1076,538,0,2201,2206,3,128,64,0,2202,2203,
  	5,620,0,0,2203,2204,5,288,0,0,2204,2205,5,217,0,0,2205,2207,3,1082,541,
  	0,2206,2202,1,0,0,0,2206,2207,1,0,0,0,2207,2209,1,0,0,0,2208,2210,3,132,
  	66,0,2209,2208,1,0,0,0,2209,2210,1,0,0,0,2210,125,1,0,0,0,2211,2212,5,
  	605,0,0,2212,2213,5,572,0,0,2213,2214,3,1076,538,0,2214,2215,5,4,0,0,
  	2215,2217,3,130,65,0,2216,2218,3,58,29,0,2217,2216,1,0,0,0,2217,2218,
  	1,0,0,0,2218,127,1,0,0,0,2219,2222,4,64,31,0,2220,2221,5,4,0,0,2221,2223,
  	3,130,65,0,2222,2220,1,0,0,0,2222,2223,1,0,0,0,2223,2227,1,0,0,0,2224,
  	2225,5,4,0,0,2225,2227,3,130,65,0,2226,2219,1,0,0,0,2226,2224,1,0,0,0,
  	2227,129,1,0,0,0,2228,2229,5,111,0,0,2229,2230,3,1160,580,0,2230,131,
  	1,0,0,0,2231,2238,3,134,67,0,2232,2234,5,773,0,0,2233,2232,1,0,0,0,2233,
  	2234,1,0,0,0,2234,2235,1,0,0,0,2235,2237,3,134,67,0,2236,2233,1,0,0,0,
  	2237,2240,1,0,0,0,2238,2236,1,0,0,0,2238,2239,1,0,0,0,2239,133,1,0,0,
  	0,2240,2238,1,0,0,0,2241,2254,3,136,68,0,2242,2254,3,140,70,0,2243,2254,
  	3,142,71,0,2244,2254,3,144,72,0,2245,2254,3,146,73,0,2246,2254,3,148,
  	74,0,2247,2254,3,150,75,0,2248,2254,3,152,76,0,2249,2250,4,67,32,0,2250,
  	2254,3,154,77,0,2251,2252,4,67,33,0,2252,2254,3,156,78,0,2253,2241,1,
  	0,0,0,2253,2242,1,0,0,0,2253,2243,1,0,0,0,2253,2244,1,0,0,0,2253,2245,
  	1,0,0,0,2253,2246,1,0,0,0,2253,2247,1,0,0,0,2253,2248,1,0,0,0,2253,2249,
  	1,0,0,0,2253,2251,1,0,0,0,2254,135,1,0,0,0,2255,2257,5,238,0,0,2256,2258,
  	5,750,0,0,2257,2256,1,0,0,0,2257,2258,1,0,0,0,2258,2259,1,0,0,0,2259,
  	2260,3,1186,593,0,2260,137,1,0,0,0,2261,2263,7,12,0,0,2262,2264,5,750,
  	0,0,2263,2262,1,0,0,0,2263,2264,1,0,0,0,2264,2265,1,0,0,0,2265,2266,3,
  	1186,593,0,2266,139,1,0,0,0,2267,2269,5,23,0,0,2268,2270,5,750,0,0,2269,
  	2268,1,0,0,0,2269,2270,1,0,0,0,2270,2271,1,0,0,0,2271,2272,3,1186,593,
  	0,2272,141,1,0,0,0,2273,2275,5,324,0,0,2274,2276,5,750,0,0,2275,2274,
  	1,0,0,0,2275,2276,1,0,0,0,2276,2277,1,0,0,0,2277,2278,3,1186,593,0,2278,
  	143,1,0,0,0,2279,2281,5,181,0,0,2280,2282,5,750,0,0,2281,2280,1,0,0,0,
  	2281,2282,1,0,0,0,2282,2283,1,0,0,0,2283,2284,3,1186,593,0,2284,145,1,
  	0,0,0,2285,2287,5,368,0,0,2286,2288,5,750,0,0,2287,2286,1,0,0,0,2287,
  	2288,1,0,0,0,2288,2289,1,0,0,0,2289,2290,3,1142,571,0,2290,147,1,0,0,
  	0,2291,2293,5,553,0,0,2292,2291,1,0,0,0,2292,2293,1,0,0,0,2293,2294,1,
  	0,0,0,2294,2296,5,163,0,0,2295,2297,5,750,0,0,2296,2295,1,0,0,0,2296,
  	2297,1,0,0,0,2297,2298,1,0,0,0,2298,2299,3,1094,547,0,2299,149,1,0,0,
  	0,2300,2301,7,13,0,0,2301,151,1,0,0,0,2302,2304,5,75,0,0,2303,2305,5,
  	750,0,0,2304,2303,1,0,0,0,2304,2305,1,0,0,0,2305,2306,1,0,0,0,2306,2307,
  	3,1160,580,0,2307,153,1,0,0,0,2308,2310,5,189,0,0,2309,2311,5,750,0,0,
  	2310,2309,1,0,0,0,2310,2311,1,0,0,0,2311,2312,1,0,0,0,2312,2313,3,1186,
  	593,0,2313,155,1,0,0,0,2314,2316,5,158,0,0,2315,2317,5,750,0,0,2316,2315,
  	1,0,0,0,2316,2317,1,0,0,0,2317,2318,1,0,0,0,2318,2319,3,1154,577,0,2319,
  	157,1,0,0,0,2320,2322,3,160,80,0,2321,2320,1,0,0,0,2321,2322,1,0,0,0,
  	2322,2324,1,0,0,0,2323,2325,3,976,488,0,2324,2323,1,0,0,0,2324,2325,1,
  	0,0,0,2325,2327,1,0,0,0,2326,2328,3,164,82,0,2327,2326,1,0,0,0,2327,2328,
  	1,0,0,0,2328,2329,1,0,0,0,2329,2330,5,636,0,0,2330,2331,3,1072,536,0,
  	2331,2332,3,70,35,0,2332,159,1,0,0,0,2333,2334,5,394,0,0,2334,2336,5,
  	458,0,0,2335,2337,3,162,81,0,2336,2335,1,0,0,0,2336,2337,1,0,0,0,2337,
  	2340,1,0,0,0,2338,2340,3,162,81,0,2339,2333,1,0,0,0,2339,2338,1,0,0,0,
  	2340,161,1,0,0,0,2341,2342,5,9,0,0,2342,2343,5,750,0,0,2343,2344,7,14,
  	0,0,2344,163,1,0,0,0,2345,2346,5,537,0,0,2346,2347,5,496,0,0,2347,2348,
  	7,10,0,0,2348,165,1,0,0,0,2349,2351,3,976,488,0,2350,2349,1,0,0,0,2350,
  	2351,1,0,0,0,2351,2352,1,0,0,0,2352,2353,5,594,0,0,2353,2354,3,1068,534,
  	0,2354,2355,7,15,0,0,2355,2356,7,16,0,0,2356,2357,5,383,0,0,2357,2358,
  	3,1102,551,0,2358,2359,5,200,0,0,2359,2360,5,153,0,0,2360,2362,5,487,
  	0,0,2361,2363,3,168,84,0,2362,2361,1,0,0,0,2362,2363,1,0,0,0,2363,2364,
  	1,0,0,0,2364,2365,3,784,392,0,2365,167,1,0,0,0,2366,2367,4,84,34,0,2367,
  	2368,7,17,0,0,2368,2369,3,1180,590,0,2369,169,1,0,0,0,2370,2372,3,976,
  	488,0,2371,2370,1,0,0,0,2371,2372,1,0,0,0,2372,2373,1,0,0,0,2373,2375,
  	5,170,0,0,2374,2376,3,980,490,0,2375,2374,1,0,0,0,2375,2376,1,0,0,0,2376,
  	2377,1,0,0,0,2377,2378,3,1084,542,0,2378,2379,5,383,0,0,2379,2380,5,490,
  	0,0,2380,2387,3,862,431,0,2381,2382,5,383,0,0,2382,2384,5,79,0,0,2383,
  	2385,5,371,0,0,2384,2383,1,0,0,0,2384,2385,1,0,0,0,2385,2386,1,0,0,0,
  	2386,2388,5,418,0,0,2387,2381,1,0,0,0,2387,2388,1,0,0,0,2388,2395,1,0,
  	0,0,2389,2396,5,156,0,0,2390,2393,5,140,0,0,2391,2392,5,383,0,0,2392,
  	2394,5,514,0,0,2393,2391,1,0,0,0,2393,2394,1,0,0,0,2394,2396,1,0,0,0,
  	2395,2389,1,0,0,0,2395,2390,1,0,0,0,2395,2396,1,0,0,0,2396,2399,1,0,0,
  	0,2397,2398,5,75,0,0,2398,2400,3,1160,580,0,2399,2397,1,0,0,0,2399,2400,
  	1,0,0,0,2400,2401,1,0,0,0,2401,2402,5,147,0,0,2402,2403,3,784,392,0,2403,
  	171,1,0,0,0,2404,2406,5,659,0,0,2405,2407,3,980,490,0,2406,2405,1,0,0,
  	0,2406,2407,1,0,0,0,2407,2408,1,0,0,0,2408,2409,3,560,280,0,2409,173,
  	1,0,0,0,2410,2411,5,394,0,0,2411,2412,5,458,0,0,2412,2413,5,523,0,0,2413,
  	2414,5,718,0,0,2414,2415,5,710,0,0,2415,2419,3,1146,573,0,2416,2418,3,
  	176,88,0,2417,2416,1,0,0,0,2418,2421,1,0,0,0,2419,2417,1,0,0,0,2419,2420,
  	1,0,0,0,2420,2436,1,0,0,0,2421,2419,1,0,0,0,2422,2423,5,523,0,0,2423,
  	2424,5,718,0,0,2424,2426,5,710,0,0,2425,2427,3,980,490,0,2426,2425,1,
  	0,0,0,2426,2427,1,0,0,0,2427,2428,1,0,0,0,2428,2432,3,1146,573,0,2429,
  	2431,3,176,88,0,2430,2429,1,0,0,0,2431,2434,1,0,0,0,2432,2430,1,0,0,0,
  	2432,2433,1,0,0,0,2433,2436,1,0,0,0,2434,2432,1,0,0,0,2435,2410,1,0,0,
  	0,2435,2422,1,0,0,0,2436,175,1,0,0,0,2437,2438,5,357,0,0,2438,2439,5,
  	580,0,0,2439,2453,3,1162,581,0,2440,2441,5,715,0,0,2441,2442,5,580,0,
  	0,2442,2453,3,1162,581,0,2443,2444,5,717,0,0,2444,2445,3,1162,581,0,2445,
  	2446,5,230,0,0,2446,2447,5,45,0,0,2447,2448,3,1146,573,0,2448,2453,1,
  	0,0,0,2449,2450,5,716,0,0,2450,2451,5,580,0,0,2451,2453,3,1162,581,0,
  	2452,2437,1,0,0,0,2452,2440,1,0,0,0,2452,2443,1,0,0,0,2452,2449,1,0,0,
  	0,2453,177,1,0,0,0,2454,2472,5,148,0,0,2455,2473,3,180,90,0,2456,2473,
  	3,182,91,0,2457,2473,3,184,92,0,2458,2473,3,186,93,0,2459,2473,3,188,
  	94,0,2460,2473,3,190,95,0,2461,2473,3,194,97,0,2462,2473,3,196,98,0,2463,
  	2473,3,198,99,0,2464,2473,3,200,100,0,2465,2473,3,202,101,0,2466,2467,
  	4,89,35,0,2467,2473,3,204,102,0,2468,2469,4,89,36,0,2469,2473,3,206,103,
  	0,2470,2471,4,89,37,0,2471,2473,3,208,104,0,2472,2455,1,0,0,0,2472,2456,
  	1,0,0,0,2472,2457,1,0,0,0,2472,2458,1,0,0,0,2472,2459,1,0,0,0,2472,2460,
  	1,0,0,0,2472,2461,1,0,0,0,2472,2462,1,0,0,0,2472,2463,1,0,0,0,2472,2464,
  	1,0,0,0,2472,2465,1,0,0,0,2472,2466,1,0,0,0,2472,2468,1,0,0,0,2472,2470,
  	1,0,0,0,2473,179,1,0,0,0,2474,2476,5,109,0,0,2475,2477,3,978,489,0,2476,
  	2475,1,0,0,0,2476,2477,1,0,0,0,2477,2478,1,0,0,0,2478,2479,3,1058,529,
  	0,2479,181,1,0,0,0,2480,2482,5,170,0,0,2481,2483,3,978,489,0,2482,2481,
  	1,0,0,0,2482,2483,1,0,0,0,2483,2484,1,0,0,0,2484,2485,3,1086,543,0,2485,
  	183,1,0,0,0,2486,2488,5,206,0,0,2487,2489,3,978,489,0,2488,2487,1,0,0,
  	0,2488,2489,1,0,0,0,2489,2490,1,0,0,0,2490,2491,3,1066,533,0,2491,185,
  	1,0,0,0,2492,2494,5,422,0,0,2493,2495,3,978,489,0,2494,2493,1,0,0,0,2494,
  	2495,1,0,0,0,2495,2496,1,0,0,0,2496,2497,3,1062,531,0,2497,187,1,0,0,
  	0,2498,2500,3,1032,516,0,2499,2498,1,0,0,0,2499,2500,1,0,0,0,2500,2501,
  	1,0,0,0,2501,2502,5,236,0,0,2502,2503,3,1052,526,0,2503,2504,5,383,0,
  	0,2504,2506,3,1102,551,0,2505,2507,3,46,23,0,2506,2505,1,0,0,0,2506,2507,
  	1,0,0,0,2507,189,1,0,0,0,2508,2509,5,288,0,0,2509,2510,5,217,0,0,2510,
  	2521,3,1082,541,0,2511,2518,3,192,96,0,2512,2514,5,773,0,0,2513,2512,
  	1,0,0,0,2513,2514,1,0,0,0,2514,2515,1,0,0,0,2515,2517,3,192,96,0,2516,
  	2513,1,0,0,0,2517,2520,1,0,0,0,2518,2516,1,0,0,0,2518,2519,1,0,0,0,2519,
  	2522,1,0,0,0,2520,2518,1,0,0,0,2521,2511,1,0,0,0,2521,2522,1,0,0,0,2522,
  	191,1,0,0,0,2523,2526,3,150,75,0,2524,2526,3,148,74,0,2525,2523,1,0,0,
  	0,2525,2524,1,0,0,0,2526,193,1,0,0,0,2527,2529,5,503,0,0,2528,2530,3,
  	978,489,0,2529,2528,1,0,0,0,2529,2530,1,0,0,0,2530,2531,1,0,0,0,2531,
  	2532,3,1092,546,0,2532,195,1,0,0,0,2533,2535,5,577,0,0,2534,2533,1,0,
  	0,0,2534,2535,1,0,0,0,2535,2536,1,0,0,0,2536,2538,7,18,0,0,2537,2539,
  	3,978,489,0,2538,2537,1,0,0,0,2538,2539,1,0,0,0,2539,2540,1,0,0,0,2540,
  	2542,3,1104,552,0,2541,2543,7,2,0,0,2542,2541,1,0,0,0,2542,2543,1,0,0,
  	0,2543,197,1,0,0,0,2544,2545,5,572,0,0,2545,2556,3,1078,539,0,2546,2553,
  	3,192,96,0,2547,2549,5,773,0,0,2548,2547,1,0,0,0,2548,2549,1,0,0,0,2549,
  	2550,1,0,0,0,2550,2552,3,192,96,0,2551,2548,1,0,0,0,2552,2555,1,0,0,0,
  	2553,2551,1,0,0,0,2553,2554,1,0,0,0,2554,2557,1,0,0,0,2555,2553,1,0,0,
  	0,2556,2546,1,0,0,0,2556,2557,1,0,0,0,2557,199,1,0,0,0,2558,2560,5,594,
  	0,0,2559,2561,3,978,489,0,2560,2559,1,0,0,0,2560,2561,1,0,0,0,2561,2562,
  	1,0,0,0,2562,2563,3,1070,535,0,2563,201,1,0,0,0,2564,2566,5,636,0,0,2565,
  	2567,3,978,489,0,2566,2565,1,0,0,0,2566,2567,1,0,0,0,2567,2568,1,0,0,
  	0,2568,2570,3,992,496,0,2569,2571,7,2,0,0,2570,2569,1,0,0,0,2570,2571,
  	1,0,0,0,2571,203,1,0,0,0,2572,2574,5,659,0,0,2573,2575,3,978,489,0,2574,
  	2573,1,0,0,0,2574,2575,1,0,0,0,2575,2576,1,0,0,0,2576,2577,3,560,280,
  	0,2577,205,1,0,0,0,2578,2579,5,523,0,0,2579,2580,5,718,0,0,2580,2582,
  	5,710,0,0,2581,2583,3,978,489,0,2582,2581,1,0,0,0,2582,2583,1,0,0,0,2583,
  	2584,1,0,0,0,2584,2585,3,1146,573,0,2585,207,1,0,0,0,2586,2587,5,605,
  	0,0,2587,2588,5,572,0,0,2588,2590,3,1078,539,0,2589,2591,3,58,29,0,2590,
  	2589,1,0,0,0,2590,2591,1,0,0,0,2591,209,1,0,0,0,2592,2593,5,453,0,0,2593,
  	2594,7,18,0,0,2594,2599,3,212,106,0,2595,2596,5,773,0,0,2596,2598,3,212,
  	106,0,2597,2595,1,0,0,0,2598,2601,1,0,0,0,2599,2597,1,0,0,0,2599,2600,
  	1,0,0,0,2600,211,1,0,0,0,2601,2599,1,0,0,0,2602,2603,3,1102,551,0,2603,
  	2604,5,590,0,0,2604,2605,3,1096,548,0,2605,213,1,0,0,0,2606,2608,5,597,
  	0,0,2607,2609,5,574,0,0,2608,2607,1,0,0,0,2608,2609,1,0,0,0,2609,2610,
  	1,0,0,0,2610,2611,3,1102,551,0,2611,215,1,0,0,0,2612,2613,5,234,0,0,2613,
  	2614,5,574,0,0,2614,2615,5,203,0,0,2615,2616,3,1164,582,0,2616,217,1,
  	0,0,0,2617,2618,5,48,0,0,2618,2624,3,1062,531,0,2619,2621,5,776,0,0,2620,
  	2622,3,756,378,0,2621,2620,1,0,0,0,2621,2622,1,0,0,0,2622,2623,1,0,0,
  	0,2623,2625,5,777,0,0,2624,2619,1,0,0,0,2624,2625,1,0,0,0,2625,219,1,
  	0,0,0,2626,2627,4,110,38,0,2627,2629,3,320,160,0,2628,2626,1,0,0,0,2628,
  	2629,1,0,0,0,2629,2630,1,0,0,0,2630,2634,5,133,0,0,2631,2633,3,224,112,
  	0,2632,2631,1,0,0,0,2633,2636,1,0,0,0,2634,2632,1,0,0,0,2634,2635,1,0,
  	0,0,2635,2669,1,0,0,0,2636,2634,1,0,0,0,2637,2661,5,203,0,0,2638,2639,
  	3,1106,553,0,2639,2640,5,621,0,0,2640,2642,3,334,167,0,2641,2643,3,358,
  	179,0,2642,2641,1,0,0,0,2642,2643,1,0,0,0,2643,2662,1,0,0,0,2644,2647,
  	3,1102,551,0,2645,2646,4,110,39,0,2646,2648,3,398,199,0,2647,2645,1,0,
  	0,0,2647,2648,1,0,0,0,2648,2650,1,0,0,0,2649,2651,3,222,111,0,2650,2649,
  	1,0,0,0,2650,2651,1,0,0,0,2651,2653,1,0,0,0,2652,2654,3,358,179,0,2653,
  	2652,1,0,0,0,2653,2654,1,0,0,0,2654,2656,1,0,0,0,2655,2657,3,328,164,
  	0,2656,2655,1,0,0,0,2656,2657,1,0,0,0,2657,2659,1,0,0,0,2658,2660,3,286,
  	143,0,2659,2658,1,0,0,0,2659,2660,1,0,0,0,2660,2662,1,0,0,0,2661,2638,
  	1,0,0,0,2661,2644,1,0,0,0,2662,2670,1,0,0,0,2663,2664,3,1106,553,0,2664,
  	2665,5,203,0,0,2665,2667,3,334,167,0,2666,2668,3,358,179,0,2667,2666,
  	1,0,0,0,2667,2668,1,0,0,0,2668,2670,1,0,0,0,2669,2637,1,0,0,0,2669,2663,
  	1,0,0,0,2670,221,1,0,0,0,2671,2672,4,111,40,0,2672,2673,5,405,0,0,2673,
  	2674,5,776,0,0,2674,2675,3,1130,565,0,2675,2676,5,777,0,0,2676,223,1,
  	0,0,0,2677,2678,7,19,0,0,2678,225,1,0,0,0,2679,2684,5,147,0,0,2680,2681,
  	4,113,41,0,2681,2685,3,756,378,0,2682,2683,4,113,42,0,2683,2685,3,352,
  	176,0,2684,2680,1,0,0,0,2684,2682,1,0,0,0,2685,227,1,0,0,0,2686,2704,
  	5,219,0,0,2687,2688,3,1102,551,0,2688,2690,5,387,0,0,2689,2691,3,398,
  	199,0,2690,2689,1,0,0,0,2690,2691,1,0,0,0,2691,2705,1,0,0,0,2692,2702,
  	3,1128,564,0,2693,2703,5,66,0,0,2694,2695,5,435,0,0,2695,2697,3,230,115,
  	0,2696,2698,3,358,179,0,2697,2696,1,0,0,0,2697,2698,1,0,0,0,2698,2700,
  	1,0,0,0,2699,2701,3,284,142,0,2700,2699,1,0,0,0,2700,2701,1,0,0,0,2701,
  	2703,1,0,0,0,2702,2693,1,0,0,0,2702,2694,1,0,0,0,2703,2705,1,0,0,0,2704,
  	2687,1,0,0,0,2704,2692,1,0,0,0,2705,229,1,0,0,0,2706,2717,7,20,0,0,2707,
  	2714,3,1128,564,0,2708,2715,7,21,0,0,2709,2710,7,22,0,0,2710,2711,5,776,
  	0,0,2711,2712,3,246,123,0,2712,2713,5,777,0,0,2713,2715,1,0,0,0,2714,
  	2708,1,0,0,0,2714,2709,1,0,0,0,2715,2717,1,0,0,0,2716,2706,1,0,0,0,2716,
  	2707,1,0,0,0,2717,231,1,0,0,0,2718,2720,5,242,0,0,2719,2721,3,234,117,
  	0,2720,2719,1,0,0,0,2720,2721,1,0,0,0,2721,2723,1,0,0,0,2722,2724,5,232,
  	0,0,2723,2722,1,0,0,0,2723,2724,1,0,0,0,2724,2726,1,0,0,0,2725,2727,5,
  	248,0,0,2726,2725,1,0,0,0,2726,2727,1,0,0,0,2727,2728,1,0,0,0,2728,2730,
  	3,1102,551,0,2729,2731,3,1036,518,0,2730,2729,1,0,0,0,2730,2731,1,0,0,
  	0,2731,2744,1,0,0,0,2732,2735,3,236,118,0,2733,2734,4,116,43,0,2734,2736,
  	3,248,124,0,2735,2733,1,0,0,0,2735,2736,1,0,0,0,2736,2745,1,0,0,0,2737,
  	2738,5,506,0,0,2738,2741,3,994,497,0,2739,2740,4,116,44,0,2740,2742,3,
  	248,124,0,2741,2739,1,0,0,0,2741,2742,1,0,0,0,2742,2745,1,0,0,0,2743,
  	2745,3,242,121,0,2744,2732,1,0,0,0,2744,2737,1,0,0,0,2744,2743,1,0,0,
  	0,2745,2747,1,0,0,0,2746,2748,3,250,125,0,2747,2746,1,0,0,0,2747,2748,
  	1,0,0,0,2748,233,1,0,0,0,2749,2750,7,23,0,0,2750,235,1,0,0,0,2751,2753,
  	5,776,0,0,2752,2754,3,238,119,0,2753,2752,1,0,0,0,2753,2754,1,0,0,0,2754,
  	2755,1,0,0,0,2755,2757,5,777,0,0,2756,2751,1,0,0,0,2756,2757,1,0,0,0,
  	2757,2758,1,0,0,0,2758,2759,3,240,120,0,2759,237,1,0,0,0,2760,2765,3,
  	1048,524,0,2761,2762,5,773,0,0,2762,2764,3,1048,524,0,2763,2761,1,0,0,
  	0,2764,2767,1,0,0,0,2765,2763,1,0,0,0,2765,2766,1,0,0,0,2766,239,1,0,
  	0,0,2767,2765,1,0,0,0,2768,2769,7,24,0,0,2769,2770,3,244,122,0,2770,241,
  	1,0,0,0,2771,2779,3,90,45,0,2772,2774,5,776,0,0,2773,2775,3,238,119,0,
  	2774,2773,1,0,0,0,2774,2775,1,0,0,0,2775,2776,1,0,0,0,2776,2777,5,777,
  	0,0,2777,2779,3,90,45,0,2778,2771,1,0,0,0,2778,2772,1,0,0,0,2779,243,
  	1,0,0,0,2780,2782,5,776,0,0,2781,2783,3,246,123,0,2782,2781,1,0,0,0,2782,
  	2783,1,0,0,0,2783,2784,1,0,0,0,2784,2793,5,777,0,0,2785,2786,5,773,0,
  	0,2786,2788,5,776,0,0,2787,2789,3,246,123,0,2788,2787,1,0,0,0,2788,2789,
  	1,0,0,0,2789,2790,1,0,0,0,2790,2792,5,777,0,0,2791,2785,1,0,0,0,2792,
  	2795,1,0,0,0,2793,2791,1,0,0,0,2793,2794,1,0,0,0,2794,245,1,0,0,0,2795,
  	2793,1,0,0,0,2796,2799,3,676,338,0,2797,2799,5,128,0,0,2798,2796,1,0,
  	0,0,2798,2797,1,0,0,0,2799,2807,1,0,0,0,2800,2803,5,773,0,0,2801,2804,
  	3,676,338,0,2802,2804,5,128,0,0,2803,2801,1,0,0,0,2803,2802,1,0,0,0,2804,
  	2806,1,0,0,0,2805,2800,1,0,0,0,2806,2809,1,0,0,0,2807,2805,1,0,0,0,2807,
  	2808,1,0,0,0,2808,247,1,0,0,0,2809,2807,1,0,0,0,2810,2811,5,17,0,0,2811,
  	2813,3,1128,564,0,2812,2814,3,1044,522,0,2813,2812,1,0,0,0,2813,2814,
  	1,0,0,0,2814,249,1,0,0,0,2815,2816,5,383,0,0,2816,2817,5,151,0,0,2817,
  	2818,5,265,0,0,2818,2819,5,614,0,0,2819,2820,3,994,497,0,2820,251,1,0,
  	0,0,2821,2822,5,281,0,0,2822,2824,3,254,127,0,2823,2825,7,25,0,0,2824,
  	2823,1,0,0,0,2824,2825,1,0,0,0,2825,2827,1,0,0,0,2826,2828,5,284,0,0,
  	2827,2826,1,0,0,0,2827,2828,1,0,0,0,2828,2829,1,0,0,0,2829,2830,5,237,
  	0,0,2830,2832,3,1160,580,0,2831,2833,7,8,0,0,2832,2831,1,0,0,0,2832,2833,
  	1,0,0,0,2833,2834,1,0,0,0,2834,2835,5,248,0,0,2835,2836,5,574,0,0,2836,
  	2838,3,1102,551,0,2837,2839,3,1036,518,0,2838,2837,1,0,0,0,2838,2839,
  	1,0,0,0,2839,2841,1,0,0,0,2840,2842,3,998,499,0,2841,2840,1,0,0,0,2841,
  	2842,1,0,0,0,2842,2844,1,0,0,0,2843,2845,3,256,128,0,2844,2843,1,0,0,
  	0,2844,2845,1,0,0,0,2845,2847,1,0,0,0,2846,2848,3,1000,500,0,2847,2846,
  	1,0,0,0,2847,2848,1,0,0,0,2848,2850,1,0,0,0,2849,2851,3,1004,502,0,2850,
  	2849,1,0,0,0,2850,2851,1,0,0,0,2851,2852,1,0,0,0,2852,2853,3,258,129,
  	0,2853,253,1,0,0,0,2854,2855,7,26,0,0,2855,255,1,0,0,0,2856,2857,5,484,
  	0,0,2857,2858,5,230,0,0,2858,2859,5,45,0,0,2859,2860,3,1156,578,0,2860,
  	257,1,0,0,0,2861,2862,5,232,0,0,2862,2863,5,747,0,0,2863,2865,7,27,0,
  	0,2864,2861,1,0,0,0,2864,2865,1,0,0,0,2865,2867,1,0,0,0,2866,2868,3,260,
  	130,0,2867,2866,1,0,0,0,2867,2868,1,0,0,0,2868,2871,1,0,0,0,2869,2870,
  	5,506,0,0,2870,2872,3,994,497,0,2871,2869,1,0,0,0,2871,2872,1,0,0,0,2872,
  	259,1,0,0,0,2873,2875,5,776,0,0,2874,2876,3,262,131,0,2875,2874,1,0,0,
  	0,2875,2876,1,0,0,0,2876,2877,1,0,0,0,2877,2878,5,777,0,0,2878,261,1,
  	0,0,0,2879,2882,3,1046,523,0,2880,2882,3,742,371,0,2881,2879,1,0,0,0,
  	2881,2880,1,0,0,0,2882,2890,1,0,0,0,2883,2886,5,773,0,0,2884,2887,3,1046,
  	523,0,2885,2887,3,742,371,0,2886,2884,1,0,0,0,2886,2885,1,0,0,0,2887,
  	2889,1,0,0,0,2888,2883,1,0,0,0,2889,2892,1,0,0,0,2890,2888,1,0,0,0,2890,
  	2891,1,0,0,0,2891,263,1,0,0,0,2892,2890,1,0,0,0,2893,2895,5,458,0,0,2894,
  	2896,7,28,0,0,2895,2894,1,0,0,0,2895,2896,1,0,0,0,2896,2898,1,0,0,0,2897,
  	2899,5,248,0,0,2898,2897,1,0,0,0,2898,2899,1,0,0,0,2899,2900,1,0,0,0,
  	2900,2902,3,1102,551,0,2901,2903,3,1036,518,0,2902,2901,1,0,0,0,2902,
  	2903,1,0,0,0,2903,2908,1,0,0,0,2904,2909,3,236,118,0,2905,2906,5,506,
  	0,0,2906,2909,3,994,497,0,2907,2909,3,242,121,0,2908,2904,1,0,0,0,2908,
  	2905,1,0,0,0,2908,2907,1,0,0,0,2909,265,1,0,0,0,2910,2912,3,270,135,0,
  	2911,2913,3,344,172,0,2912,2911,1,0,0,0,2912,2913,1,0,0,0,2913,2917,1,
  	0,0,0,2914,2917,3,274,137,0,2915,2917,3,268,134,0,2916,2910,1,0,0,0,2916,
  	2914,1,0,0,0,2916,2915,1,0,0,0,2917,267,1,0,0,0,2918,2919,5,776,0,0,2919,
  	2920,3,268,134,0,2920,2921,5,777,0,0,2921,2931,1,0,0,0,2922,2923,3,270,
  	135,0,2923,2925,3,292,146,0,2924,2926,3,344,172,0,2925,2924,1,0,0,0,2925,
  	2926,1,0,0,0,2926,2931,1,0,0,0,2927,2928,3,344,172,0,2928,2929,3,292,
  	146,0,2929,2931,1,0,0,0,2930,2918,1,0,0,0,2930,2922,1,0,0,0,2930,2927,
  	1,0,0,0,2931,269,1,0,0,0,2932,2933,4,135,45,0,2933,2935,3,320,160,0,2934,
  	2932,1,0,0,0,2934,2935,1,0,0,0,2935,2950,1,0,0,0,2936,2938,3,272,136,
  	0,2937,2939,3,328,164,0,2938,2937,1,0,0,0,2938,2939,1,0,0,0,2939,2941,
  	1,0,0,0,2940,2942,3,284,142,0,2941,2940,1,0,0,0,2941,2942,1,0,0,0,2942,
  	2951,1,0,0,0,2943,2945,3,274,137,0,2944,2946,3,328,164,0,2945,2944,1,
  	0,0,0,2945,2946,1,0,0,0,2946,2948,1,0,0,0,2947,2949,3,284,142,0,2948,
  	2947,1,0,0,0,2948,2949,1,0,0,0,2949,2951,1,0,0,0,2950,2936,1,0,0,0,2950,
  	2943,1,0,0,0,2951,2954,1,0,0,0,2952,2953,4,135,46,0,2953,2955,3,294,147,
  	0,2954,2952,1,0,0,0,2954,2955,1,0,0,0,2955,271,1,0,0,0,2956,2967,3,276,
  	138,0,2957,2958,3,274,137,0,2958,2960,5,608,0,0,2959,2961,3,396,198,0,
  	2960,2959,1,0,0,0,2960,2961,1,0,0,0,2961,2964,1,0,0,0,2962,2965,3,276,
  	138,0,2963,2965,3,274,137,0,2964,2962,1,0,0,0,2964,2963,1,0,0,0,2965,
  	2967,1,0,0,0,2966,2956,1,0,0,0,2966,2957,1,0,0,0,2967,2978,1,0,0,0,2968,
  	2970,5,608,0,0,2969,2971,3,396,198,0,2970,2969,1,0,0,0,2970,2971,1,0,
  	0,0,2971,2974,1,0,0,0,2972,2975,3,276,138,0,2973,2975,3,274,137,0,2974,
  	2972,1,0,0,0,2974,2973,1,0,0,0,2975,2977,1,0,0,0,2976,2968,1,0,0,0,2977,
  	2980,1,0,0,0,2978,2976,1,0,0,0,2978,2979,1,0,0,0,2979,273,1,0,0,0,2980,
  	2978,1,0,0,0,2981,2987,5,776,0,0,2982,2988,3,274,137,0,2983,2985,3,270,
  	135,0,2984,2986,3,344,172,0,2985,2984,1,0,0,0,2985,2986,1,0,0,0,2986,
  	2988,1,0,0,0,2987,2982,1,0,0,0,2987,2983,1,0,0,0,2988,2989,1,0,0,0,2989,
  	2990,5,777,0,0,2990,275,1,0,0,0,2991,2997,3,278,139,0,2992,2993,4,138,
  	47,0,2993,2997,3,336,168,0,2994,2995,4,138,48,0,2995,2997,3,338,169,0,
  	2996,2991,1,0,0,0,2996,2992,1,0,0,0,2996,2994,1,0,0,0,2997,277,1,0,0,
  	0,2998,3002,5,497,0,0,2999,3001,3,342,171,0,3000,2999,1,0,0,0,3001,3004,
  	1,0,0,0,3002,3000,1,0,0,0,3002,3003,1,0,0,0,3003,3005,1,0,0,0,3004,3002,
  	1,0,0,0,3005,3007,3,352,176,0,3006,3008,3,292,146,0,3007,3006,1,0,0,0,
  	3007,3008,1,0,0,0,3008,3010,1,0,0,0,3009,3011,3,332,166,0,3010,3009,1,
  	0,0,0,3010,3011,1,0,0,0,3011,3013,1,0,0,0,3012,3014,3,358,179,0,3013,
  	3012,1,0,0,0,3013,3014,1,0,0,0,3014,3016,1,0,0,0,3015,3017,3,324,162,
  	0,3016,3015,1,0,0,0,3016,3017,1,0,0,0,3017,3019,1,0,0,0,3018,3020,3,296,
  	148,0,3019,3018,1,0,0,0,3019,3020,1,0,0,0,3020,3023,1,0,0,0,3021,3022,
  	4,139,49,0,3022,3024,3,298,149,0,3023,3021,1,0,0,0,3023,3024,1,0,0,0,
  	3024,279,1,0,0,0,3025,3026,3,274,137,0,3026,281,1,0,0,0,3027,3028,7,29,
  	0,0,3028,283,1,0,0,0,3029,3030,5,276,0,0,3030,3031,3,288,144,0,3031,285,
  	1,0,0,0,3032,3033,5,276,0,0,3033,3034,3,290,145,0,3034,287,1,0,0,0,3035,
  	3038,3,290,145,0,3036,3037,7,30,0,0,3037,3039,3,290,145,0,3038,3036,1,
  	0,0,0,3038,3039,1,0,0,0,3039,289,1,0,0,0,3040,3043,3,1128,564,0,3041,
  	3043,7,31,0,0,3042,3040,1,0,0,0,3042,3041,1,0,0,0,3043,291,1,0,0,0,3044,
  	3072,5,248,0,0,3045,3046,5,396,0,0,3046,3048,3,1154,577,0,3047,3049,3,
  	998,499,0,3048,3047,1,0,0,0,3048,3049,1,0,0,0,3049,3051,1,0,0,0,3050,
  	3052,3,1000,500,0,3051,3050,1,0,0,0,3051,3052,1,0,0,0,3052,3054,1,0,0,
  	0,3053,3055,3,1004,502,0,3054,3053,1,0,0,0,3054,3055,1,0,0,0,3055,3073,
  	1,0,0,0,3056,3057,5,150,0,0,3057,3073,3,1154,577,0,3058,3061,3,1180,590,
  	0,3059,3061,3,742,371,0,3060,3058,1,0,0,0,3060,3059,1,0,0,0,3061,3069,
  	1,0,0,0,3062,3065,5,773,0,0,3063,3066,3,1180,590,0,3064,3066,3,742,371,
  	0,3065,3063,1,0,0,0,3065,3064,1,0,0,0,3066,3068,1,0,0,0,3067,3062,1,0,
  	0,0,3068,3071,1,0,0,0,3069,3067,1,0,0,0,3069,3070,1,0,0,0,3070,3073,1,
  	0,0,0,3071,3069,1,0,0,0,3072,3045,1,0,0,0,3072,3056,1,0,0,0,3072,3060,
  	1,0,0,0,3073,293,1,0,0,0,3074,3075,5,422,0,0,3075,3076,5,13,0,0,3076,
  	3082,5,776,0,0,3077,3080,5,747,0,0,3078,3079,5,773,0,0,3079,3081,5,747,
  	0,0,3080,3078,1,0,0,0,3080,3081,1,0,0,0,3081,3083,1,0,0,0,3082,3077,1,
  	0,0,0,3082,3083,1,0,0,0,3083,3084,1,0,0,0,3084,3085,5,777,0,0,3085,295,
  	1,0,0,0,3086,3087,5,221,0,0,3087,3088,3,676,338,0,3088,297,1,0,0,0,3089,
  	3090,5,699,0,0,3090,3095,3,300,150,0,3091,3092,5,773,0,0,3092,3094,3,
  	300,150,0,3093,3091,1,0,0,0,3094,3097,1,0,0,0,3095,3093,1,0,0,0,3095,
  	3096,1,0,0,0,3096,299,1,0,0,0,3097,3095,1,0,0,0,3098,3099,3,1124,562,
  	0,3099,3100,5,17,0,0,3100,3101,3,302,151,0,3101,301,1,0,0,0,3102,3103,
  	5,776,0,0,3103,3104,3,304,152,0,3104,3105,5,777,0,0,3105,303,1,0,0,0,
  	3106,3108,3,1124,562,0,3107,3106,1,0,0,0,3107,3108,1,0,0,0,3108,3112,
  	1,0,0,0,3109,3110,5,405,0,0,3110,3111,5,45,0,0,3111,3113,3,774,387,0,
  	3112,3109,1,0,0,0,3112,3113,1,0,0,0,3113,3115,1,0,0,0,3114,3116,3,328,
  	164,0,3115,3114,1,0,0,0,3115,3116,1,0,0,0,3116,3118,1,0,0,0,3117,3119,
  	3,306,153,0,3118,3117,1,0,0,0,3118,3119,1,0,0,0,3119,305,1,0,0,0,3120,
  	3121,3,308,154,0,3121,3123,3,310,155,0,3122,3124,3,318,159,0,3123,3122,
  	1,0,0,0,3123,3124,1,0,0,0,3124,307,1,0,0,0,3125,3126,7,32,0,0,3126,309,
  	1,0,0,0,3127,3130,3,312,156,0,3128,3130,3,314,157,0,3129,3127,1,0,0,0,
  	3129,3128,1,0,0,0,3130,311,1,0,0,0,3131,3132,5,698,0,0,3132,3146,5,693,
  	0,0,3133,3134,3,1144,572,0,3134,3135,5,693,0,0,3135,3146,1,0,0,0,3136,
  	3137,5,787,0,0,3137,3146,5,693,0,0,3138,3139,5,247,0,0,3139,3140,3,676,
  	338,0,3140,3141,3,764,382,0,3141,3142,5,693,0,0,3142,3146,1,0,0,0,3143,
  	3144,5,101,0,0,3144,3146,5,487,0,0,3145,3131,1,0,0,0,3145,3133,1,0,0,
  	0,3145,3136,1,0,0,0,3145,3138,1,0,0,0,3145,3143,1,0,0,0,3146,313,1,0,
  	0,0,3147,3148,5,30,0,0,3148,3149,3,316,158,0,3149,3150,5,15,0,0,3150,
  	3151,3,316,158,0,3151,315,1,0,0,0,3152,3166,3,312,156,0,3153,3154,5,698,
  	0,0,3154,3166,5,682,0,0,3155,3156,3,1144,572,0,3156,3157,5,682,0,0,3157,
  	3166,1,0,0,0,3158,3159,5,787,0,0,3159,3166,5,682,0,0,3160,3161,5,247,
  	0,0,3161,3162,3,676,338,0,3162,3163,3,764,382,0,3163,3164,5,682,0,0,3164,
  	3166,1,0,0,0,3165,3152,1,0,0,0,3165,3153,1,0,0,0,3165,3155,1,0,0,0,3165,
  	3158,1,0,0,0,3165,3160,1,0,0,0,3166,317,1,0,0,0,3167,3174,5,680,0,0,3168,
  	3169,5,101,0,0,3169,3175,5,487,0,0,3170,3175,5,217,0,0,3171,3175,5,697,
  	0,0,3172,3173,5,373,0,0,3173,3175,5,690,0,0,3174,3168,1,0,0,0,3174,3170,
  	1,0,0,0,3174,3171,1,0,0,0,3174,3172,1,0,0,0,3175,319,1,0,0,0,3176,3178,
  	5,645,0,0,3177,3179,5,665,0,0,3178,3177,1,0,0,0,3178,3179,1,0,0,0,3179,
  	3180,1,0,0,0,3180,3185,3,322,161,0,3181,3182,5,773,0,0,3182,3184,3,322,
  	161,0,3183,3181,1,0,0,0,3184,3187,1,0,0,0,3185,3183,1,0,0,0,3185,3186,
  	1,0,0,0,3186,321,1,0,0,0,3187,3185,1,0,0,0,3188,3190,3,1128,564,0,3189,
  	3191,3,1044,522,0,3190,3189,1,0,0,0,3190,3191,1,0,0,0,3191,3192,1,0,0,
  	0,3192,3193,5,17,0,0,3193,3194,3,280,140,0,3194,323,1,0,0,0,3195,3196,
  	5,217,0,0,3196,3197,5,45,0,0,3197,3199,3,774,387,0,3198,3200,3,326,163,
  	0,3199,3198,1,0,0,0,3199,3200,1,0,0,0,3200,325,1,0,0,0,3201,3202,5,645,
  	0,0,3202,3207,5,481,0,0,3203,3204,4,163,50,0,3204,3205,5,645,0,0,3205,
  	3207,5,99,0,0,3206,3201,1,0,0,0,3206,3203,1,0,0,0,3207,327,1,0,0,0,3208,
  	3209,5,393,0,0,3209,3210,5,45,0,0,3210,3211,3,774,387,0,3211,329,1,0,
  	0,0,3212,3213,7,33,0,0,3213,331,1,0,0,0,3214,3217,5,203,0,0,3215,3218,
  	5,149,0,0,3216,3218,3,334,167,0,3217,3215,1,0,0,0,3217,3216,1,0,0,0,3218,
  	333,1,0,0,0,3219,3224,3,360,180,0,3220,3221,5,773,0,0,3221,3223,3,360,
  	180,0,3222,3220,1,0,0,0,3223,3226,1,0,0,0,3224,3222,1,0,0,0,3224,3225,
  	1,0,0,0,3225,335,1,0,0,0,3226,3224,1,0,0,0,3227,3228,5,626,0,0,3228,3233,
  	3,340,170,0,3229,3230,5,773,0,0,3230,3232,3,340,170,0,3231,3229,1,0,0,
  	0,3232,3235,1,0,0,0,3233,3231,1,0,0,0,3233,3234,1,0,0,0,3234,337,1,0,
  	0,0,3235,3233,1,0,0,0,3236,3237,5,574,0,0,3237,3238,3,1102,551,0,3238,
  	339,1,0,0,0,3239,3240,5,487,0,0,3240,3242,5,776,0,0,3241,3243,3,246,123,
  	0,3242,3241,1,0,0,0,3242,3243,1,0,0,0,3243,3244,1,0,0,0,3244,3245,5,777,
  	0,0,3245,341,1,0,0,0,3246,3255,3,282,141,0,3247,3255,5,535,0,0,3248,3249,
  	4,171,51,0,3249,3255,5,533,0,0,3250,3251,4,171,52,0,3251,3252,5,325,0,
  	0,3252,3253,5,750,0,0,3253,3255,3,1142,571,0,3254,3246,1,0,0,0,3254,3247,
  	1,0,0,0,3254,3248,1,0,0,0,3254,3250,1,0,0,0,3255,343,1,0,0,0,3256,3258,
  	3,346,173,0,3257,3256,1,0,0,0,3258,3259,1,0,0,0,3259,3257,1,0,0,0,3259,
  	3260,1,0,0,0,3260,345,1,0,0,0,3261,3262,5,200,0,0,3262,3266,3,348,174,
  	0,3263,3264,4,173,53,0,3264,3265,5,668,0,0,3265,3267,3,1106,553,0,3266,
  	3263,1,0,0,0,3266,3267,1,0,0,0,3267,3270,1,0,0,0,3268,3269,4,173,54,0,
  	3269,3271,3,350,175,0,3270,3268,1,0,0,0,3270,3271,1,0,0,0,3271,3277,1,
  	0,0,0,3272,3273,5,287,0,0,3273,3274,5,251,0,0,3274,3275,5,508,0,0,3275,
  	3277,5,346,0,0,3276,3261,1,0,0,0,3276,3272,1,0,0,0,3277,347,1,0,0,0,3278,
  	3282,5,614,0,0,3279,3280,4,174,55,0,3280,3282,5,508,0,0,3281,3278,1,0,
  	0,0,3281,3279,1,0,0,0,3282,349,1,0,0,0,3283,3284,5,669,0,0,3284,3287,
  	5,670,0,0,3285,3287,5,671,0,0,3286,3283,1,0,0,0,3286,3285,1,0,0,0,3287,
  	351,1,0,0,0,3288,3291,3,354,177,0,3289,3291,5,760,0,0,3290,3288,1,0,0,
  	0,3290,3289,1,0,0,0,3291,3296,1,0,0,0,3292,3293,5,773,0,0,3293,3295,3,
  	354,177,0,3294,3292,1,0,0,0,3295,3298,1,0,0,0,3296,3294,1,0,0,0,3296,
  	3297,1,0,0,0,3297,353,1,0,0,0,3298,3296,1,0,0,0,3299,3305,3,1054,527,
  	0,3300,3302,3,676,338,0,3301,3303,3,356,178,0,3302,3301,1,0,0,0,3302,
  	3303,1,0,0,0,3303,3305,1,0,0,0,3304,3299,1,0,0,0,3304,3300,1,0,0,0,3305,
  	355,1,0,0,0,3306,3308,5,17,0,0,3307,3306,1,0,0,0,3307,3308,1,0,0,0,3308,
  	3311,1,0,0,0,3309,3312,3,1128,564,0,3310,3312,3,1154,577,0,3311,3309,
  	1,0,0,0,3311,3310,1,0,0,0,3312,357,1,0,0,0,3313,3314,5,643,0,0,3314,3315,
  	3,676,338,0,3315,359,1,0,0,0,3316,3327,3,372,186,0,3317,3321,5,778,0,
  	0,3318,3319,4,180,56,0,3319,3322,3,1128,564,0,3320,3322,5,732,0,0,3321,
  	3318,1,0,0,0,3321,3320,1,0,0,0,3322,3323,1,0,0,0,3323,3324,3,362,181,
  	0,3324,3325,5,779,0,0,3325,3327,1,0,0,0,3326,3316,1,0,0,0,3326,3317,1,
  	0,0,0,3327,3331,1,0,0,0,3328,3330,3,364,182,0,3329,3328,1,0,0,0,3330,
  	3333,1,0,0,0,3331,3329,1,0,0,0,3331,3332,1,0,0,0,3332,361,1,0,0,0,3333,
  	3331,1,0,0,0,3334,3338,3,372,186,0,3335,3337,3,364,182,0,3336,3335,1,
  	0,0,0,3337,3340,1,0,0,0,3338,3336,1,0,0,0,3338,3339,1,0,0,0,3339,363,
  	1,0,0,0,3340,3338,1,0,0,0,3341,3342,3,368,184,0,3342,3347,3,360,180,0,
  	3343,3344,5,383,0,0,3344,3348,3,676,338,0,3345,3346,5,621,0,0,3346,3348,
  	3,1132,566,0,3347,3343,1,0,0,0,3347,3345,1,0,0,0,3347,3348,1,0,0,0,3348,
  	3361,1,0,0,0,3349,3350,3,370,185,0,3350,3355,3,360,180,0,3351,3352,5,
  	383,0,0,3352,3356,3,676,338,0,3353,3354,5,621,0,0,3354,3356,3,1132,566,
  	0,3355,3351,1,0,0,0,3355,3353,1,0,0,0,3356,3361,1,0,0,0,3357,3358,3,366,
  	183,0,3358,3359,3,372,186,0,3359,3361,1,0,0,0,3360,3341,1,0,0,0,3360,
  	3349,1,0,0,0,3360,3357,1,0,0,0,3361,365,1,0,0,0,3362,3364,5,359,0,0,3363,
  	3365,5,239,0,0,3364,3363,1,0,0,0,3364,3365,1,0,0,0,3365,3366,1,0,0,0,
  	3366,3374,5,261,0,0,3367,3368,5,359,0,0,3368,3370,7,34,0,0,3369,3371,
  	5,395,0,0,3370,3369,1,0,0,0,3370,3371,1,0,0,0,3371,3372,1,0,0,0,3372,
  	3374,5,261,0,0,3373,3362,1,0,0,0,3373,3367,1,0,0,0,3374,367,1,0,0,0,3375,
  	3377,7,35,0,0,3376,3375,1,0,0,0,3376,3377,1,0,0,0,3377,3378,1,0,0,0,3378,
  	3381,5,261,0,0,3379,3381,5,555,0,0,3380,3376,1,0,0,0,3380,3379,1,0,0,
  	0,3381,369,1,0,0,0,3382,3384,7,34,0,0,3383,3385,5,395,0,0,3384,3383,1,
  	0,0,0,3384,3385,1,0,0,0,3385,3386,1,0,0,0,3386,3387,5,261,0,0,3387,371,
  	1,0,0,0,3388,3395,3,374,187,0,3389,3395,3,376,188,0,3390,3395,3,378,189,
  	0,3391,3395,3,380,190,0,3392,3393,4,186,57,0,3393,3395,3,382,191,0,3394,
  	3388,1,0,0,0,3394,3389,1,0,0,0,3394,3390,1,0,0,0,3394,3391,1,0,0,0,3394,
  	3392,1,0,0,0,3395,373,1,0,0,0,3396,3398,3,1102,551,0,3397,3399,3,1036,
  	518,0,3398,3397,1,0,0,0,3398,3399,1,0,0,0,3399,3401,1,0,0,0,3400,3402,
  	3,398,199,0,3401,3400,1,0,0,0,3401,3402,1,0,0,0,3402,3404,1,0,0,0,3403,
  	3405,3,400,200,0,3404,3403,1,0,0,0,3404,3405,1,0,0,0,3405,375,1,0,0,0,
  	3406,3409,5,776,0,0,3407,3410,3,374,187,0,3408,3410,3,376,188,0,3409,
  	3407,1,0,0,0,3409,3408,1,0,0,0,3410,3411,1,0,0,0,3411,3412,5,777,0,0,
  	3412,377,1,0,0,0,3413,3415,3,280,140,0,3414,3416,3,398,199,0,3415,3414,
  	1,0,0,0,3415,3416,1,0,0,0,3416,3419,1,0,0,0,3417,3418,4,189,58,0,3418,
  	3420,3,1044,522,0,3419,3417,1,0,0,0,3419,3420,1,0,0,0,3420,3431,1,0,0,
  	0,3421,3422,4,189,59,0,3422,3423,5,726,0,0,3423,3425,3,280,140,0,3424,
  	3426,3,398,199,0,3425,3424,1,0,0,0,3425,3426,1,0,0,0,3426,3428,1,0,0,
  	0,3427,3429,3,1044,522,0,3428,3427,1,0,0,0,3428,3429,1,0,0,0,3429,3431,
  	1,0,0,0,3430,3413,1,0,0,0,3430,3421,1,0,0,0,3431,379,1,0,0,0,3432,3435,
  	5,776,0,0,3433,3436,3,334,167,0,3434,3436,3,380,190,0,3435,3433,1,0,0,
  	0,3435,3434,1,0,0,0,3436,3437,1,0,0,0,3437,3438,5,777,0,0,3438,381,1,
  	0,0,0,3439,3440,5,701,0,0,3440,3441,5,776,0,0,3441,3442,3,676,338,0,3442,
  	3443,5,773,0,0,3443,3444,3,1154,577,0,3444,3445,3,384,192,0,3445,3447,
  	5,777,0,0,3446,3448,3,398,199,0,3447,3446,1,0,0,0,3447,3448,1,0,0,0,3448,
  	383,1,0,0,0,3449,3450,5,71,0,0,3450,3451,5,776,0,0,3451,3456,3,386,193,
  	0,3452,3453,5,773,0,0,3453,3455,3,386,193,0,3454,3452,1,0,0,0,3455,3458,
  	1,0,0,0,3456,3454,1,0,0,0,3456,3457,1,0,0,0,3457,3459,1,0,0,0,3458,3456,
  	1,0,0,0,3459,3460,5,777,0,0,3460,385,1,0,0,0,3461,3462,3,1128,564,0,3462,
  	3463,5,200,0,0,3463,3464,5,703,0,0,3464,3485,1,0,0,0,3465,3466,3,1128,
  	564,0,3466,3469,3,916,458,0,3467,3468,4,193,60,0,3468,3470,3,986,493,
  	0,3469,3467,1,0,0,0,3469,3470,1,0,0,0,3470,3472,1,0,0,0,3471,3473,5,174,
  	0,0,3472,3471,1,0,0,0,3472,3473,1,0,0,0,3473,3474,1,0,0,0,3474,3475,5,
  	704,0,0,3475,3477,3,1154,577,0,3476,3478,3,388,194,0,3477,3476,1,0,0,
  	0,3477,3478,1,0,0,0,3478,3485,1,0,0,0,3479,3480,5,702,0,0,3480,3481,5,
  	704,0,0,3481,3482,3,1154,577,0,3482,3483,3,384,192,0,3483,3485,1,0,0,
  	0,3484,3461,1,0,0,0,3484,3465,1,0,0,0,3484,3479,1,0,0,0,3485,387,1,0,
  	0,0,3486,3488,3,390,195,0,3487,3489,3,392,196,0,3488,3487,1,0,0,0,3488,
  	3489,1,0,0,0,3489,3495,1,0,0,0,3490,3492,3,392,196,0,3491,3493,3,390,
  	195,0,3492,3491,1,0,0,0,3492,3493,1,0,0,0,3493,3495,1,0,0,0,3494,3486,
  	1,0,0,0,3494,3490,1,0,0,0,3495,389,1,0,0,0,3496,3497,3,394,197,0,3497,
  	3498,5,383,0,0,3498,3499,5,700,0,0,3499,391,1,0,0,0,3500,3501,3,394,197,
  	0,3501,3502,5,383,0,0,3502,3503,5,165,0,0,3503,393,1,0,0,0,3504,3509,
  	5,165,0,0,3505,3509,5,376,0,0,3506,3507,5,128,0,0,3507,3509,3,1154,577,
  	0,3508,3504,1,0,0,0,3508,3505,1,0,0,0,3508,3506,1,0,0,0,3509,395,1,0,
  	0,0,3510,3511,7,36,0,0,3511,397,1,0,0,0,3512,3516,5,17,0,0,3513,3514,
  	4,199,61,0,3514,3516,5,750,0,0,3515,3512,1,0,0,0,3515,3513,1,0,0,0,3515,
  	3516,1,0,0,0,3516,3517,1,0,0,0,3517,3518,3,1128,564,0,3518,399,1,0,0,
  	0,3519,3524,3,402,201,0,3520,3521,5,773,0,0,3521,3523,3,402,201,0,3522,
  	3520,1,0,0,0,3523,3526,1,0,0,0,3524,3522,1,0,0,0,3524,3525,1,0,0,0,3525,
  	401,1,0,0,0,3526,3524,1,0,0,0,3527,3528,3,404,202,0,3528,3530,3,406,203,
  	0,3529,3531,3,410,205,0,3530,3529,1,0,0,0,3530,3531,1,0,0,0,3531,3532,
  	1,0,0,0,3532,3533,5,776,0,0,3533,3534,3,412,206,0,3534,3535,5,777,0,0,
  	3535,3548,1,0,0,0,3536,3537,5,620,0,0,3537,3539,3,406,203,0,3538,3540,
  	3,410,205,0,3539,3538,1,0,0,0,3539,3540,1,0,0,0,3540,3541,1,0,0,0,3541,
  	3543,5,776,0,0,3542,3544,3,412,206,0,3543,3542,1,0,0,0,3543,3544,1,0,
  	0,0,3544,3545,1,0,0,0,3545,3546,5,777,0,0,3546,3548,1,0,0,0,3547,3527,
  	1,0,0,0,3547,3536,1,0,0,0,3548,403,1,0,0,0,3549,3550,7,37,0,0,3550,405,
  	1,0,0,0,3551,3552,7,38,0,0,3552,407,1,0,0,0,3553,3554,5,420,0,0,3554,
  	3560,5,265,0,0,3555,3557,5,609,0,0,3556,3558,3,406,203,0,3557,3556,1,
  	0,0,0,3557,3558,1,0,0,0,3558,3560,1,0,0,0,3559,3553,1,0,0,0,3559,3555,
  	1,0,0,0,3560,409,1,0,0,0,3561,3567,5,200,0,0,3562,3568,5,261,0,0,3563,
  	3564,5,393,0,0,3564,3568,5,45,0,0,3565,3566,5,217,0,0,3566,3568,5,45,
  	0,0,3567,3562,1,0,0,0,3567,3563,1,0,0,0,3567,3565,1,0,0,0,3568,411,1,
  	0,0,0,3569,3574,3,414,207,0,3570,3571,5,773,0,0,3571,3573,3,414,207,0,
  	3572,3570,1,0,0,0,3573,3576,1,0,0,0,3574,3572,1,0,0,0,3574,3575,1,0,0,
  	0,3575,413,1,0,0,0,3576,3574,1,0,0,0,3577,3580,3,1128,564,0,3578,3580,
  	5,420,0,0,3579,3577,1,0,0,0,3579,3578,1,0,0,0,3580,415,1,0,0,0,3581,3582,
  	4,208,62,0,3582,3584,3,320,160,0,3583,3581,1,0,0,0,3583,3584,1,0,0,0,
  	3584,3585,1,0,0,0,3585,3587,5,614,0,0,3586,3588,5,295,0,0,3587,3586,1,
  	0,0,0,3587,3588,1,0,0,0,3588,3590,1,0,0,0,3589,3591,5,232,0,0,3590,3589,
  	1,0,0,0,3590,3591,1,0,0,0,3591,3592,1,0,0,0,3592,3593,3,334,167,0,3593,
  	3594,5,506,0,0,3594,3596,3,994,497,0,3595,3597,3,358,179,0,3596,3595,
  	1,0,0,0,3596,3597,1,0,0,0,3597,3599,1,0,0,0,3598,3600,3,328,164,0,3599,
  	3598,1,0,0,0,3599,3600,1,0,0,0,3600,3602,1,0,0,0,3601,3603,3,286,143,
  	0,3602,3601,1,0,0,0,3602,3603,1,0,0,0,3603,417,1,0,0,0,3604,3609,3,420,
  	210,0,3605,3609,3,426,213,0,3606,3609,3,428,214,0,3607,3609,3,434,217,
  	0,3608,3604,1,0,0,0,3608,3605,1,0,0,0,3608,3606,1,0,0,0,3608,3607,1,0,
  	0,0,3609,419,1,0,0,0,3610,3611,5,543,0,0,3611,3615,5,592,0,0,3612,3614,
  	3,424,212,0,3613,3612,1,0,0,0,3614,3617,1,0,0,0,3615,3613,1,0,0,0,3615,
  	3616,1,0,0,0,3616,3636,1,0,0,0,3617,3615,1,0,0,0,3618,3620,5,77,0,0,3619,
  	3621,5,647,0,0,3620,3619,1,0,0,0,3620,3621,1,0,0,0,3621,3627,1,0,0,0,
  	3622,3624,5,15,0,0,3623,3625,5,373,0,0,3624,3623,1,0,0,0,3624,3625,1,
  	0,0,0,3625,3626,1,0,0,0,3626,3628,5,54,0,0,3627,3622,1,0,0,0,3627,3628,
  	1,0,0,0,3628,3633,1,0,0,0,3629,3631,5,373,0,0,3630,3629,1,0,0,0,3630,
  	3631,1,0,0,0,3631,3632,1,0,0,0,3632,3634,5,450,0,0,3633,3630,1,0,0,0,
  	3633,3634,1,0,0,0,3634,3636,1,0,0,0,3635,3610,1,0,0,0,3635,3618,1,0,0,
  	0,3636,421,1,0,0,0,3637,3639,5,29,0,0,3638,3640,5,647,0,0,3639,3638,1,
  	0,0,0,3639,3640,1,0,0,0,3640,423,1,0,0,0,3641,3642,5,645,0,0,3642,3643,
  	5,85,0,0,3643,3648,5,517,0,0,3644,3645,4,212,63,0,3645,3646,5,435,0,0,
  	3646,3648,7,39,0,0,3647,3641,1,0,0,0,3647,3644,1,0,0,0,3648,425,1,0,0,
  	0,3649,3650,5,489,0,0,3650,3679,3,1128,564,0,3651,3653,5,480,0,0,3652,
  	3654,5,647,0,0,3653,3652,1,0,0,0,3653,3654,1,0,0,0,3654,3673,1,0,0,0,
  	3655,3657,5,590,0,0,3656,3658,5,489,0,0,3657,3656,1,0,0,0,3657,3658,1,
  	0,0,0,3658,3659,1,0,0,0,3659,3674,3,1128,564,0,3660,3662,5,15,0,0,3661,
  	3663,5,373,0,0,3662,3661,1,0,0,0,3662,3663,1,0,0,0,3663,3664,1,0,0,0,
  	3664,3666,5,54,0,0,3665,3660,1,0,0,0,3665,3666,1,0,0,0,3666,3671,1,0,
  	0,0,3667,3669,5,373,0,0,3668,3667,1,0,0,0,3668,3669,1,0,0,0,3669,3670,
  	1,0,0,0,3670,3672,5,450,0,0,3671,3668,1,0,0,0,3671,3672,1,0,0,0,3672,
  	3674,1,0,0,0,3673,3655,1,0,0,0,3673,3665,1,0,0,0,3674,3679,1,0,0,0,3675,
  	3676,5,450,0,0,3676,3677,5,489,0,0,3677,3679,3,1128,564,0,3678,3649,1,
  	0,0,0,3678,3651,1,0,0,0,3678,3675,1,0,0,0,3679,427,1,0,0,0,3680,3681,
  	5,287,0,0,3681,3682,7,18,0,0,3682,3687,3,430,215,0,3683,3684,5,773,0,
  	0,3684,3686,3,430,215,0,3685,3683,1,0,0,0,3686,3689,1,0,0,0,3687,3685,
  	1,0,0,0,3687,3688,1,0,0,0,3688,3703,1,0,0,0,3689,3687,1,0,0,0,3690,3691,
  	4,214,64,0,3691,3692,5,287,0,0,3692,3693,5,244,0,0,3693,3694,5,200,0,
  	0,3694,3703,5,27,0,0,3695,3700,5,611,0,0,3696,3701,5,571,0,0,3697,3701,
  	5,574,0,0,3698,3699,4,214,65,0,3699,3701,5,244,0,0,3700,3696,1,0,0,0,
  	3700,3697,1,0,0,0,3700,3698,1,0,0,0,3701,3703,1,0,0,0,3702,3680,1,0,0,
  	0,3702,3690,1,0,0,0,3702,3695,1,0,0,0,3703,429,1,0,0,0,3704,3706,3,1102,
  	551,0,3705,3707,3,398,199,0,3706,3705,1,0,0,0,3706,3707,1,0,0,0,3707,
  	3708,1,0,0,0,3708,3709,3,432,216,0,3709,431,1,0,0,0,3710,3712,5,435,0,
  	0,3711,3713,5,284,0,0,3712,3711,1,0,0,0,3712,3713,1,0,0,0,3713,3719,1,
  	0,0,0,3714,3716,5,295,0,0,3715,3714,1,0,0,0,3715,3716,1,0,0,0,3716,3717,
  	1,0,0,0,3717,3719,5,649,0,0,3718,3710,1,0,0,0,3718,3715,1,0,0,0,3719,
  	433,1,0,0,0,3720,3747,5,651,0,0,3721,3722,7,40,0,0,3722,3724,3,438,219,
  	0,3723,3725,7,41,0,0,3724,3723,1,0,0,0,3724,3725,1,0,0,0,3725,3748,1,
  	0,0,0,3726,3727,5,159,0,0,3727,3733,3,438,219,0,3728,3731,5,566,0,0,3729,
  	3730,5,200,0,0,3730,3732,5,340,0,0,3731,3729,1,0,0,0,3731,3732,1,0,0,
  	0,3732,3734,1,0,0,0,3733,3728,1,0,0,0,3733,3734,1,0,0,0,3734,3748,1,0,
  	0,0,3735,3736,5,417,0,0,3736,3748,3,438,219,0,3737,3738,5,77,0,0,3738,
  	3741,3,438,219,0,3739,3740,5,384,0,0,3740,3742,5,407,0,0,3741,3739,1,
  	0,0,0,3741,3742,1,0,0,0,3742,3748,1,0,0,0,3743,3744,5,480,0,0,3744,3748,
  	3,438,219,0,3745,3746,5,439,0,0,3746,3748,3,436,218,0,3747,3721,1,0,0,
  	0,3747,3726,1,0,0,0,3747,3735,1,0,0,0,3747,3737,1,0,0,0,3747,3743,1,0,
  	0,0,3747,3745,1,0,0,0,3748,435,1,0,0,0,3749,3752,4,218,66,0,3750,3751,
  	5,94,0,0,3751,3753,5,652,0,0,3752,3750,1,0,0,0,3752,3753,1,0,0,0,3753,
  	3756,1,0,0,0,3754,3756,1,0,0,0,3755,3749,1,0,0,0,3755,3754,1,0,0,0,3756,
  	437,1,0,0,0,3757,3764,3,1156,578,0,3758,3759,5,773,0,0,3759,3762,3,1156,
  	578,0,3760,3761,5,773,0,0,3761,3763,3,1140,570,0,3762,3760,1,0,0,0,3762,
  	3763,1,0,0,0,3763,3765,1,0,0,0,3764,3758,1,0,0,0,3764,3765,1,0,0,0,3765,
  	439,1,0,0,0,3766,3767,5,428,0,0,3767,3768,7,42,0,0,3768,3773,5,289,0,
  	0,3769,3770,5,590,0,0,3770,3774,3,1160,580,0,3771,3772,5,28,0,0,3772,
  	3774,3,676,338,0,3773,3769,1,0,0,0,3773,3771,1,0,0,0,3774,3800,1,0,0,
  	0,3775,3800,3,448,224,0,3776,3777,5,468,0,0,3777,3782,3,442,221,0,3778,
  	3779,5,773,0,0,3779,3781,3,442,221,0,3780,3778,1,0,0,0,3781,3784,1,0,
  	0,0,3782,3780,1,0,0,0,3782,3783,1,0,0,0,3783,3800,1,0,0,0,3784,3782,1,
  	0,0,0,3785,3786,4,220,67,0,3786,3787,5,468,0,0,3787,3791,5,658,0,0,3788,
  	3789,3,978,489,0,3789,3790,3,1128,564,0,3790,3792,1,0,0,0,3791,3788,1,
  	0,0,0,3791,3792,1,0,0,0,3792,3800,1,0,0,0,3793,3800,3,478,239,0,3794,
  	3795,4,220,68,0,3795,3800,3,464,232,0,3796,3800,3,446,223,0,3797,3798,
  	4,220,69,0,3798,3800,3,488,244,0,3799,3766,1,0,0,0,3799,3775,1,0,0,0,
  	3799,3776,1,0,0,0,3799,3785,1,0,0,0,3799,3793,1,0,0,0,3799,3794,1,0,0,
  	0,3799,3796,1,0,0,0,3799,3797,1,0,0,0,3800,441,1,0,0,0,3801,3803,5,316,
  	0,0,3802,3804,3,444,222,0,3803,3802,1,0,0,0,3803,3804,1,0,0,0,3804,3816,
  	1,0,0,0,3805,3806,4,221,70,0,3806,3807,5,430,0,0,3807,3816,5,47,0,0,3808,
  	3810,5,514,0,0,3809,3811,5,10,0,0,3810,3809,1,0,0,0,3810,3811,1,0,0,0,
  	3811,3813,1,0,0,0,3812,3814,3,782,391,0,3813,3812,1,0,0,0,3813,3814,1,
  	0,0,0,3814,3816,1,0,0,0,3815,3801,1,0,0,0,3815,3805,1,0,0,0,3815,3808,
  	1,0,0,0,3816,443,1,0,0,0,3817,3818,4,222,71,0,3818,3823,5,590,0,0,3819,
  	3820,4,222,72,0,3820,3824,3,1142,571,0,3821,3822,4,222,73,0,3822,3824,
  	3,1146,573,0,3823,3819,1,0,0,0,3823,3821,1,0,0,0,3824,445,1,0,0,0,3825,
  	3829,5,281,0,0,3826,3830,5,112,0,0,3827,3828,5,574,0,0,3828,3830,3,1102,
  	551,0,3829,3826,1,0,0,0,3829,3827,1,0,0,0,3830,3831,1,0,0,0,3831,3832,
  	5,203,0,0,3832,3833,5,316,0,0,3833,447,1,0,0,0,3834,3835,5,55,0,0,3835,
  	3836,5,316,0,0,3836,3837,5,590,0,0,3837,3839,3,450,225,0,3838,3840,3,
  	782,391,0,3839,3838,1,0,0,0,3839,3840,1,0,0,0,3840,449,1,0,0,0,3841,3846,
  	3,452,226,0,3842,3843,5,773,0,0,3843,3845,3,452,226,0,3844,3842,1,0,0,
  	0,3845,3848,1,0,0,0,3846,3844,1,0,0,0,3846,3847,1,0,0,0,3847,451,1,0,
  	0,0,3848,3846,1,0,0,0,3849,3850,5,300,0,0,3850,3851,5,750,0,0,3851,3941,
  	3,1162,581,0,3852,3853,5,729,0,0,3853,3854,5,750,0,0,3854,3941,3,1162,
  	581,0,3855,3856,5,297,0,0,3856,3857,5,750,0,0,3857,3941,3,1162,581,0,
  	3858,3859,5,318,0,0,3859,3860,5,750,0,0,3860,3941,3,1162,581,0,3861,3862,
  	5,303,0,0,3862,3863,5,750,0,0,3863,3941,3,1162,581,0,3864,3865,5,304,
  	0,0,3865,3866,5,750,0,0,3866,3941,3,1140,570,0,3867,3868,5,298,0,0,3868,
  	3869,5,750,0,0,3869,3941,3,1140,570,0,3870,3871,5,305,0,0,3871,3872,5,
  	750,0,0,3872,3941,3,1140,570,0,3873,3874,5,299,0,0,3874,3875,5,750,0,
  	0,3875,3941,3,1140,570,0,3876,3877,5,314,0,0,3877,3878,5,750,0,0,3878,
  	3941,3,1140,570,0,3879,3880,5,308,0,0,3880,3881,5,750,0,0,3881,3941,3,
  	1162,581,0,3882,3883,5,307,0,0,3883,3884,5,750,0,0,3884,3941,3,1162,581,
  	0,3885,3886,5,317,0,0,3886,3887,5,750,0,0,3887,3941,3,1162,581,0,3888,
  	3889,5,309,0,0,3889,3890,5,750,0,0,3890,3941,3,1162,581,0,3891,3892,5,
  	738,0,0,3892,3893,5,750,0,0,3893,3941,3,458,229,0,3894,3895,5,310,0,0,
  	3895,3896,5,750,0,0,3896,3941,3,1162,581,0,3897,3898,5,313,0,0,3898,3899,
  	5,750,0,0,3899,3941,3,1162,581,0,3900,3901,5,315,0,0,3901,3902,5,750,
  	0,0,3902,3941,3,1140,570,0,3903,3904,5,311,0,0,3904,3905,5,750,0,0,3905,
  	3941,3,1160,580,0,3906,3907,5,312,0,0,3907,3908,5,750,0,0,3908,3941,3,
  	1162,581,0,3909,3910,5,712,0,0,3910,3911,5,750,0,0,3911,3941,3,1162,581,
  	0,3912,3913,5,713,0,0,3913,3914,5,750,0,0,3914,3941,3,1140,570,0,3915,
  	3916,5,319,0,0,3916,3917,5,750,0,0,3917,3941,3,1140,570,0,3918,3919,5,
  	233,0,0,3919,3920,5,750,0,0,3920,3941,3,462,231,0,3921,3922,5,735,0,0,
  	3922,3923,5,750,0,0,3923,3941,3,1154,577,0,3924,3925,5,736,0,0,3925,3926,
  	5,750,0,0,3926,3941,3,1140,570,0,3927,3928,5,296,0,0,3928,3929,5,750,
  	0,0,3929,3941,3,1140,570,0,3930,3931,5,737,0,0,3931,3932,5,750,0,0,3932,
  	3941,3,454,227,0,3933,3934,5,739,0,0,3934,3935,5,750,0,0,3935,3941,3,
  	1140,570,0,3936,3937,5,742,0,0,3937,3938,5,750,0,0,3938,3941,3,456,228,
  	0,3939,3941,3,460,230,0,3940,3849,1,0,0,0,3940,3852,1,0,0,0,3940,3855,
  	1,0,0,0,3940,3858,1,0,0,0,3940,3861,1,0,0,0,3940,3864,1,0,0,0,3940,3867,
  	1,0,0,0,3940,3870,1,0,0,0,3940,3873,1,0,0,0,3940,3876,1,0,0,0,3940,3879,
  	1,0,0,0,3940,3882,1,0,0,0,3940,3885,1,0,0,0,3940,3888,1,0,0,0,3940,3891,
  	1,0,0,0,3940,3894,1,0,0,0,3940,3897,1,0,0,0,3940,3900,1,0,0,0,3940,3903,
  	1,0,0,0,3940,3906,1,0,0,0,3940,3909,1,0,0,0,3940,3912,1,0,0,0,3940,3915,
  	1,0,0,0,3940,3918,1,0,0,0,3940,3921,1,0,0,0,3940,3924,1,0,0,0,3940,3927,
  	1,0,0,0,3940,3930,1,0,0,0,3940,3933,1,0,0,0,3940,3936,1,0,0,0,3940,3939,
  	1,0,0,0,3941,453,1,0,0,0,3942,3945,3,1024,512,0,3943,3945,5,376,0,0,3944,
  	3942,1,0,0,0,3944,3943,1,0,0,0,3945,455,1,0,0,0,3946,3947,7,43,0,0,3947,
  	457,1,0,0,0,3948,3951,3,1162,581,0,3949,3951,5,376,0,0,3950,3948,1,0,
  	0,0,3950,3949,1,0,0,0,3951,459,1,0,0,0,3952,3953,5,301,0,0,3953,3954,
  	5,750,0,0,3954,3965,3,1162,581,0,3955,3956,5,302,0,0,3956,3957,5,750,
  	0,0,3957,3965,3,1144,572,0,3958,3959,5,447,0,0,3959,3960,5,750,0,0,3960,
  	3965,3,1162,581,0,3961,3962,5,448,0,0,3962,3963,5,750,0,0,3963,3965,3,
  	1140,570,0,3964,3952,1,0,0,0,3964,3955,1,0,0,0,3964,3958,1,0,0,0,3964,
  	3961,1,0,0,0,3965,461,1,0,0,0,3966,3975,5,776,0,0,3967,3972,3,1140,570,
  	0,3968,3969,5,773,0,0,3969,3971,3,1140,570,0,3970,3968,1,0,0,0,3971,3974,
  	1,0,0,0,3972,3970,1,0,0,0,3972,3973,1,0,0,0,3973,3976,1,0,0,0,3974,3972,
  	1,0,0,0,3975,3967,1,0,0,0,3975,3976,1,0,0,0,3976,3977,1,0,0,0,3977,3978,
  	5,777,0,0,3978,463,1,0,0,0,3979,3980,5,55,0,0,3980,3981,5,459,0,0,3981,
  	3982,5,190,0,0,3982,3987,3,466,233,0,3983,3984,5,773,0,0,3984,3986,3,
  	466,233,0,3985,3983,1,0,0,0,3986,3989,1,0,0,0,3987,3985,1,0,0,0,3987,
  	3988,1,0,0,0,3988,3992,1,0,0,0,3989,3987,1,0,0,0,3990,3991,4,232,74,0,
  	3991,3993,3,782,391,0,3992,3990,1,0,0,0,3992,3993,1,0,0,0,3993,465,1,
  	0,0,0,3994,3995,5,460,0,0,3995,3996,5,750,0,0,3996,3998,5,776,0,0,3997,
  	3999,3,468,234,0,3998,3997,1,0,0,0,3998,3999,1,0,0,0,3999,4000,1,0,0,
  	0,4000,4044,5,777,0,0,4001,4002,5,461,0,0,4002,4003,5,750,0,0,4003,4005,
  	5,776,0,0,4004,4006,3,468,234,0,4005,4004,1,0,0,0,4005,4006,1,0,0,0,4006,
  	4007,1,0,0,0,4007,4044,5,777,0,0,4008,4009,5,462,0,0,4009,4010,5,750,
  	0,0,4010,4012,5,776,0,0,4011,4013,3,470,235,0,4012,4011,1,0,0,0,4012,
  	4013,1,0,0,0,4013,4014,1,0,0,0,4014,4044,5,777,0,0,4015,4016,5,463,0,
  	0,4016,4017,5,750,0,0,4017,4019,5,776,0,0,4018,4020,3,470,235,0,4019,
  	4018,1,0,0,0,4019,4020,1,0,0,0,4020,4021,1,0,0,0,4021,4044,5,777,0,0,
  	4022,4023,5,464,0,0,4023,4024,5,750,0,0,4024,4026,5,776,0,0,4025,4027,
  	3,472,236,0,4026,4025,1,0,0,0,4026,4027,1,0,0,0,4027,4028,1,0,0,0,4028,
  	4044,5,777,0,0,4029,4030,5,465,0,0,4030,4031,5,750,0,0,4031,4033,5,776,
  	0,0,4032,4034,3,472,236,0,4033,4032,1,0,0,0,4033,4034,1,0,0,0,4034,4035,
  	1,0,0,0,4035,4044,5,777,0,0,4036,4037,5,466,0,0,4037,4038,5,750,0,0,4038,
  	4040,5,776,0,0,4039,4041,3,476,238,0,4040,4039,1,0,0,0,4040,4041,1,0,
  	0,0,4041,4042,1,0,0,0,4042,4044,5,777,0,0,4043,3994,1,0,0,0,4043,4001,
  	1,0,0,0,4043,4008,1,0,0,0,4043,4015,1,0,0,0,4043,4022,1,0,0,0,4043,4029,
  	1,0,0,0,4043,4036,1,0,0,0,4044,467,1,0,0,0,4045,4050,3,1058,529,0,4046,
  	4047,5,773,0,0,4047,4049,3,1058,529,0,4048,4046,1,0,0,0,4049,4052,1,0,
  	0,0,4050,4048,1,0,0,0,4050,4051,1,0,0,0,4051,469,1,0,0,0,4052,4050,1,
  	0,0,0,4053,4058,3,1098,549,0,4054,4055,5,773,0,0,4055,4057,3,1098,549,
  	0,4056,4054,1,0,0,0,4057,4060,1,0,0,0,4058,4056,1,0,0,0,4058,4059,1,0,
  	0,0,4059,471,1,0,0,0,4060,4058,1,0,0,0,4061,4066,3,474,237,0,4062,4063,
  	5,773,0,0,4063,4065,3,474,237,0,4064,4062,1,0,0,0,4065,4068,1,0,0,0,4066,
  	4064,1,0,0,0,4066,4067,1,0,0,0,4067,473,1,0,0,0,4068,4066,1,0,0,0,4069,
  	4070,3,1162,581,0,4070,475,1,0,0,0,4071,4076,3,990,495,0,4072,4073,5,
  	773,0,0,4073,4075,3,990,495,0,4074,4072,1,0,0,0,4075,4078,1,0,0,0,4076,
  	4074,1,0,0,0,4076,4077,1,0,0,0,4077,477,1,0,0,0,4078,4076,1,0,0,0,4079,
  	4080,5,543,0,0,4080,4082,5,514,0,0,4081,4083,3,484,242,0,4082,4081,1,
  	0,0,0,4082,4083,1,0,0,0,4083,4086,1,0,0,0,4084,4085,5,613,0,0,4085,4087,
  	3,480,240,0,4086,4084,1,0,0,0,4086,4087,1,0,0,0,4087,4088,1,0,0,0,4088,
  	4090,3,482,241,0,4089,4091,3,782,391,0,4090,4089,1,0,0,0,4090,4091,1,
  	0,0,0,4091,4101,1,0,0,0,4092,4093,5,552,0,0,4093,4095,5,514,0,0,4094,
  	4096,3,484,242,0,4095,4094,1,0,0,0,4095,4096,1,0,0,0,4096,4098,1,0,0,
  	0,4097,4099,3,782,391,0,4098,4097,1,0,0,0,4098,4099,1,0,0,0,4099,4101,
  	1,0,0,0,4100,4079,1,0,0,0,4100,4092,1,0,0,0,4101,479,1,0,0,0,4102,4110,
  	3,460,230,0,4103,4104,4,240,75,0,4104,4105,7,44,0,0,4105,4106,5,750,0,
  	0,4106,4110,3,1156,578,0,4107,4108,4,240,76,0,4108,4110,5,529,0,0,4109,
  	4102,1,0,0,0,4109,4103,1,0,0,0,4109,4107,1,0,0,0,4110,4115,1,0,0,0,4111,
  	4112,5,773,0,0,4112,4114,3,460,230,0,4113,4111,1,0,0,0,4114,4117,1,0,
  	0,0,4115,4113,1,0,0,0,4115,4116,1,0,0,0,4116,481,1,0,0,0,4117,4115,1,
  	0,0,0,4118,4122,4,241,77,0,4119,4120,5,618,0,0,4120,4121,5,750,0,0,4121,
  	4123,3,1156,578,0,4122,4119,1,0,0,0,4122,4123,1,0,0,0,4123,4127,1,0,0,
  	0,4124,4125,5,406,0,0,4125,4126,5,750,0,0,4126,4128,3,1156,578,0,4127,
  	4124,1,0,0,0,4127,4128,1,0,0,0,4128,4132,1,0,0,0,4129,4130,5,129,0,0,
  	4130,4131,5,750,0,0,4131,4133,3,1156,578,0,4132,4129,1,0,0,0,4132,4133,
  	1,0,0,0,4133,4137,1,0,0,0,4134,4135,5,409,0,0,4135,4136,5,750,0,0,4136,
  	4138,3,1156,578,0,4137,4134,1,0,0,0,4137,4138,1,0,0,0,4138,4141,1,0,0,
  	0,4139,4141,1,0,0,0,4140,4118,1,0,0,0,4140,4139,1,0,0,0,4141,483,1,0,
  	0,0,4142,4147,3,486,243,0,4143,4144,5,773,0,0,4144,4146,3,486,243,0,4145,
  	4143,1,0,0,0,4146,4149,1,0,0,0,4147,4145,1,0,0,0,4147,4148,1,0,0,0,4148,
  	485,1,0,0,0,4149,4147,1,0,0,0,4150,4151,7,45,0,0,4151,487,1,0,0,0,4152,
  	4153,7,46,0,0,4153,4154,5,210,0,0,4154,489,1,0,0,0,4155,4156,5,417,0,
  	0,4156,4157,3,1128,564,0,4157,4160,5,203,0,0,4158,4161,3,1160,580,0,4159,
  	4161,3,742,371,0,4160,4158,1,0,0,0,4160,4159,1,0,0,0,4161,4167,1,0,0,
  	0,4162,4167,3,492,246,0,4163,4164,7,47,0,0,4164,4165,5,417,0,0,4165,4167,
  	3,1128,564,0,4166,4155,1,0,0,0,4166,4162,1,0,0,0,4166,4163,1,0,0,0,4167,
  	491,1,0,0,0,4168,4169,5,173,0,0,4169,4172,3,1128,564,0,4170,4171,5,621,
  	0,0,4171,4173,3,494,247,0,4172,4170,1,0,0,0,4172,4173,1,0,0,0,4173,493,
  	1,0,0,0,4174,4179,3,742,371,0,4175,4176,5,773,0,0,4176,4178,3,742,371,
  	0,4177,4175,1,0,0,0,4178,4181,1,0,0,0,4179,4177,1,0,0,0,4179,4180,1,0,
  	0,0,4180,495,1,0,0,0,4181,4179,1,0,0,0,4182,4207,5,677,0,0,4183,4184,
  	5,284,0,0,4184,4185,5,112,0,0,4185,4187,5,139,0,0,4186,4188,3,1190,595,
  	0,4187,4186,1,0,0,0,4187,4188,1,0,0,0,4188,4189,1,0,0,0,4189,4208,3,1154,
  	577,0,4190,4193,5,676,0,0,4191,4192,5,200,0,0,4192,4194,5,459,0,0,4193,
  	4191,1,0,0,0,4193,4194,1,0,0,0,4194,4208,1,0,0,0,4195,4196,4,248,78,0,
  	4196,4197,5,244,0,0,4197,4198,5,203,0,0,4198,4199,3,1026,513,0,4199,4200,
  	5,775,0,0,4200,4201,3,1140,570,0,4201,4202,5,230,0,0,4202,4203,5,45,0,
  	0,4203,4205,3,1154,577,0,4204,4206,3,498,249,0,4205,4204,1,0,0,0,4205,
  	4206,1,0,0,0,4206,4208,1,0,0,0,4207,4183,1,0,0,0,4207,4190,1,0,0,0,4207,
  	4195,1,0,0,0,4208,497,1,0,0,0,4209,4220,3,500,250,0,4210,4211,5,112,0,
  	0,4211,4213,5,139,0,0,4212,4214,3,1190,595,0,4213,4212,1,0,0,0,4213,4214,
  	1,0,0,0,4214,4215,1,0,0,0,4215,4217,3,1154,577,0,4216,4218,3,500,250,
  	0,4217,4216,1,0,0,0,4217,4218,1,0,0,0,4218,4220,1,0,0,0,4219,4209,1,0,
  	0,0,4219,4210,1,0,0,0,4220,499,1,0,0,0,4221,4223,5,467,0,0,4222,4224,
  	5,373,0,0,4223,4222,1,0,0,0,4223,4224,1,0,0,0,4224,4225,1,0,0,0,4225,
  	4226,5,539,0,0,4226,501,1,0,0,0,4227,4228,4,251,79,0,4228,4237,3,504,
  	252,0,4229,4237,3,510,255,0,4230,4237,3,522,261,0,4231,4237,3,524,262,
  	0,4232,4237,3,538,269,0,4233,4237,3,540,270,0,4234,4235,4,251,80,0,4235,
  	4237,3,558,279,0,4236,4227,1,0,0,0,4236,4229,1,0,0,0,4236,4230,1,0,0,
  	0,4236,4231,1,0,0,0,4236,4232,1,0,0,0,4236,4233,1,0,0,0,4236,4234,1,0,
  	0,0,4237,503,1,0,0,0,4238,4239,5,11,0,0,4239,4242,5,618,0,0,4240,4241,
  	4,252,81,0,4241,4243,3,978,489,0,4242,4240,1,0,0,0,4242,4243,1,0,0,0,
  	4243,4244,1,0,0,0,4244,4245,3,506,253,0,4245,505,1,0,0,0,4246,4247,4,
  	253,82,0,4247,4251,3,1010,505,0,4248,4249,4,253,83,0,4249,4251,3,1012,
  	506,0,4250,4246,1,0,0,0,4250,4248,1,0,0,0,4251,4252,1,0,0,0,4252,4253,
  	3,512,256,0,4253,4301,1,0,0,0,4254,4255,4,253,84,0,4255,4256,3,1026,513,
  	0,4256,4257,5,230,0,0,4257,4258,5,45,0,0,4258,4261,3,1156,578,0,4259,
  	4260,4,253,85,0,4260,4262,3,1022,511,0,4261,4259,1,0,0,0,4261,4262,1,
  	0,0,0,4262,4265,1,0,0,0,4263,4264,4,253,86,0,4264,4266,3,1018,509,0,4265,
  	4263,1,0,0,0,4265,4266,1,0,0,0,4266,4301,1,0,0,0,4267,4268,4,253,87,0,
  	4268,4269,3,1026,513,0,4269,4270,3,1020,510,0,4270,4301,1,0,0,0,4271,
  	4272,4,253,88,0,4272,4273,3,1026,513,0,4273,4274,5,128,0,0,4274,4278,
  	5,659,0,0,4275,4279,5,10,0,0,4276,4279,5,369,0,0,4277,4279,3,560,280,
  	0,4278,4275,1,0,0,0,4278,4276,1,0,0,0,4278,4277,1,0,0,0,4279,4301,1,0,
  	0,0,4280,4281,4,253,89,0,4281,4282,3,1026,513,0,4282,4285,5,230,0,0,4283,
  	4284,5,645,0,0,4284,4286,3,1180,590,0,4285,4283,1,0,0,0,4285,4286,1,0,
  	0,0,4286,4287,1,0,0,0,4287,4288,5,45,0,0,4288,4289,5,734,0,0,4289,4291,
  	5,406,0,0,4290,4292,3,1018,509,0,4291,4290,1,0,0,0,4291,4292,1,0,0,0,
  	4292,4301,1,0,0,0,4293,4294,5,741,0,0,4294,4301,3,1142,571,0,4295,4298,
  	5,740,0,0,4296,4299,3,1142,571,0,4297,4299,5,698,0,0,4298,4296,1,0,0,
  	0,4298,4297,1,0,0,0,4299,4301,1,0,0,0,4300,4250,1,0,0,0,4300,4254,1,0,
  	0,0,4300,4267,1,0,0,0,4300,4271,1,0,0,0,4300,4280,1,0,0,0,4300,4293,1,
  	0,0,0,4300,4295,1,0,0,0,4301,507,1,0,0,0,4302,4303,5,618,0,0,4303,4304,
  	3,1188,594,0,4304,509,1,0,0,0,4305,4306,5,97,0,0,4306,4310,5,618,0,0,
  	4307,4308,4,255,90,0,4308,4311,3,980,490,0,4309,4311,1,0,0,0,4310,4307,
  	1,0,0,0,4310,4309,1,0,0,0,4311,4312,1,0,0,0,4312,4313,3,1010,505,0,4313,
  	4314,3,514,257,0,4314,4315,3,512,256,0,4315,511,1,0,0,0,4316,4318,4,256,
  	91,0,4317,4319,3,516,258,0,4318,4317,1,0,0,0,4318,4319,1,0,0,0,4319,4321,
  	1,0,0,0,4320,4322,3,518,259,0,4321,4320,1,0,0,0,4321,4322,1,0,0,0,4322,
  	4326,1,0,0,0,4323,4325,3,520,260,0,4324,4323,1,0,0,0,4325,4328,1,0,0,
  	0,4326,4324,1,0,0,0,4326,4327,1,0,0,0,4327,4331,1,0,0,0,4328,4326,1,0,
  	0,0,4329,4331,1,0,0,0,4330,4316,1,0,0,0,4330,4329,1,0,0,0,4331,513,1,
  	0,0,0,4332,4336,4,257,92,0,4333,4334,5,128,0,0,4334,4335,5,659,0,0,4335,
  	4337,3,560,280,0,4336,4333,1,0,0,0,4336,4337,1,0,0,0,4337,4340,1,0,0,
  	0,4338,4340,1,0,0,0,4339,4332,1,0,0,0,4339,4338,1,0,0,0,4340,515,1,0,
  	0,0,4341,4344,5,467,0,0,4342,4345,3,552,276,0,4343,4345,7,48,0,0,4344,
  	4342,1,0,0,0,4344,4343,1,0,0,0,4345,517,1,0,0,0,4346,4355,5,645,0,0,4347,
  	4348,5,322,0,0,4348,4356,3,1140,570,0,4349,4350,5,327,0,0,4350,4356,3,
  	1140,570,0,4351,4352,5,321,0,0,4352,4356,3,1140,570,0,4353,4354,5,328,
  	0,0,4354,4356,3,1140,570,0,4355,4347,1,0,0,0,4355,4349,1,0,0,0,4355,4351,
  	1,0,0,0,4355,4353,1,0,0,0,4356,4357,1,0,0,0,4357,4355,1,0,0,0,4357,4358,
  	1,0,0,0,4358,519,1,0,0,0,4359,4360,5,2,0,0,4360,4393,7,49,0,0,4361,4390,
  	5,406,0,0,4362,4369,5,177,0,0,4363,4364,5,247,0,0,4364,4365,3,1142,571,
  	0,4365,4366,5,122,0,0,4366,4370,1,0,0,0,4367,4370,5,365,0,0,4368,4370,
  	5,128,0,0,4369,4363,1,0,0,0,4369,4367,1,0,0,0,4369,4368,1,0,0,0,4369,
  	4370,1,0,0,0,4370,4391,1,0,0,0,4371,4374,5,705,0,0,4372,4375,3,1142,571,
  	0,4373,4375,5,128,0,0,4374,4372,1,0,0,0,4374,4373,1,0,0,0,4375,4391,1,
  	0,0,0,4376,4377,5,706,0,0,4377,4382,5,247,0,0,4378,4379,3,1142,571,0,
  	4379,4380,5,122,0,0,4380,4383,1,0,0,0,4381,4383,5,128,0,0,4382,4378,1,
  	0,0,0,4382,4381,1,0,0,0,4383,4391,1,0,0,0,4384,4385,4,260,93,0,4385,4386,
  	5,467,0,0,4386,4388,5,101,0,0,4387,4389,7,50,0,0,4388,4387,1,0,0,0,4388,
  	4389,1,0,0,0,4389,4391,1,0,0,0,4390,4362,1,0,0,0,4390,4371,1,0,0,0,4390,
  	4376,1,0,0,0,4390,4384,1,0,0,0,4391,4393,1,0,0,0,4392,4359,1,0,0,0,4392,
  	4361,1,0,0,0,4393,521,1,0,0,0,4394,4395,5,148,0,0,4395,4398,5,618,0,0,
  	4396,4397,4,261,94,0,4397,4399,3,978,489,0,4398,4396,1,0,0,0,4398,4399,
  	1,0,0,0,4399,4400,1,0,0,0,4400,4401,3,1008,504,0,4401,523,1,0,0,0,4402,
  	4445,5,215,0,0,4403,4404,4,262,95,0,4404,4405,3,546,273,0,4405,4406,5,
  	590,0,0,4406,4410,3,1008,504,0,4407,4408,5,645,0,0,4408,4409,5,660,0,
  	0,4409,4411,5,391,0,0,4410,4407,1,0,0,0,4410,4411,1,0,0,0,4411,4446,1,
  	0,0,0,4412,4418,3,546,273,0,4413,4415,5,10,0,0,4414,4416,5,421,0,0,4415,
  	4414,1,0,0,0,4415,4416,1,0,0,0,4416,4418,1,0,0,0,4417,4412,1,0,0,0,4417,
  	4413,1,0,0,0,4418,4419,1,0,0,0,4419,4421,5,383,0,0,4420,4422,3,544,272,
  	0,4421,4420,1,0,0,0,4421,4422,1,0,0,0,4422,4423,1,0,0,0,4423,4424,3,550,
  	275,0,4424,4425,5,590,0,0,4425,4427,3,526,263,0,4426,4428,3,536,268,0,
  	4427,4426,1,0,0,0,4427,4428,1,0,0,0,4428,4430,1,0,0,0,4429,4431,3,528,
  	264,0,4430,4429,1,0,0,0,4430,4431,1,0,0,0,4431,4433,1,0,0,0,4432,4434,
  	3,534,267,0,4433,4432,1,0,0,0,4433,4434,1,0,0,0,4434,4446,1,0,0,0,4435,
  	4436,5,427,0,0,4436,4437,5,383,0,0,4437,4438,3,1026,513,0,4438,4439,5,
  	590,0,0,4439,4443,3,526,263,0,4440,4441,5,645,0,0,4441,4442,5,215,0,0,
  	4442,4444,5,391,0,0,4443,4440,1,0,0,0,4443,4444,1,0,0,0,4444,4446,1,0,
  	0,0,4445,4403,1,0,0,0,4445,4417,1,0,0,0,4445,4435,1,0,0,0,4446,525,1,
  	0,0,0,4447,4448,4,263,96,0,4448,4452,3,1010,505,0,4449,4450,4,263,97,
  	0,4450,4452,3,1008,504,0,4451,4447,1,0,0,0,4451,4449,1,0,0,0,4452,527,
  	1,0,0,0,4453,4454,4,264,98,0,4454,4456,5,645,0,0,4455,4457,3,556,278,
  	0,4456,4455,1,0,0,0,4457,4458,1,0,0,0,4458,4456,1,0,0,0,4458,4459,1,0,
  	0,0,4459,4465,1,0,0,0,4460,4461,4,264,99,0,4461,4462,5,645,0,0,4462,4463,
  	5,215,0,0,4463,4465,5,391,0,0,4464,4453,1,0,0,0,4464,4460,1,0,0,0,4465,
  	529,1,0,0,0,4466,4467,5,663,0,0,4467,4468,3,560,280,0,4468,531,1,0,0,
  	0,4469,4470,5,645,0,0,4470,4478,5,659,0,0,4471,4479,3,560,280,0,4472,
  	4474,5,10,0,0,4473,4475,3,530,265,0,4474,4473,1,0,0,0,4474,4475,1,0,0,
  	0,4475,4479,1,0,0,0,4476,4479,5,369,0,0,4477,4479,5,128,0,0,4478,4471,
  	1,0,0,0,4478,4472,1,0,0,0,4478,4476,1,0,0,0,4478,4477,1,0,0,0,4479,533,
  	1,0,0,0,4480,4481,5,17,0,0,4481,4483,5,618,0,0,4482,4484,3,532,266,0,
  	4483,4482,1,0,0,0,4483,4484,1,0,0,0,4484,535,1,0,0,0,4485,4486,4,268,
  	100,0,4486,4487,3,516,258,0,4487,537,1,0,0,0,4488,4489,5,453,0,0,4489,
  	4490,5,618,0,0,4490,4491,3,1026,513,0,4491,4492,5,590,0,0,4492,4500,3,
  	1026,513,0,4493,4494,5,773,0,0,4494,4495,3,1026,513,0,4495,4496,5,590,
  	0,0,4496,4497,3,1026,513,0,4497,4499,1,0,0,0,4498,4493,1,0,0,0,4499,4502,
  	1,0,0,0,4500,4498,1,0,0,0,4500,4501,1,0,0,0,4501,539,1,0,0,0,4502,4500,
  	1,0,0,0,4503,4537,5,477,0,0,4504,4505,4,270,101,0,4505,4506,3,546,273,
  	0,4506,4507,5,203,0,0,4507,4508,3,1008,504,0,4508,4538,1,0,0,0,4509,4510,
  	3,546,273,0,4510,4511,3,542,271,0,4511,4512,5,203,0,0,4512,4513,3,1008,
  	504,0,4513,4538,1,0,0,0,4514,4516,5,10,0,0,4515,4517,5,421,0,0,4516,4515,
  	1,0,0,0,4516,4517,1,0,0,0,4517,4529,1,0,0,0,4518,4519,4,270,102,0,4519,
  	4521,5,383,0,0,4520,4522,3,544,272,0,4521,4520,1,0,0,0,4521,4522,1,0,
  	0,0,4522,4523,1,0,0,0,4523,4530,3,550,275,0,4524,4525,5,773,0,0,4525,
  	4526,5,215,0,0,4526,4527,5,391,0,0,4527,4528,5,203,0,0,4528,4530,3,1008,
  	504,0,4529,4518,1,0,0,0,4529,4524,1,0,0,0,4530,4538,1,0,0,0,4531,4532,
  	5,427,0,0,4532,4533,5,383,0,0,4533,4534,3,1026,513,0,4534,4535,5,203,
  	0,0,4535,4536,3,1008,504,0,4536,4538,1,0,0,0,4537,4504,1,0,0,0,4537,4509,
  	1,0,0,0,4537,4514,1,0,0,0,4537,4531,1,0,0,0,4538,541,1,0,0,0,4539,4540,
  	4,271,103,0,4540,4542,5,383,0,0,4541,4543,3,544,272,0,4542,4541,1,0,0,
  	0,4542,4543,1,0,0,0,4543,4544,1,0,0,0,4544,4554,3,550,275,0,4545,4551,
  	4,271,104,0,4546,4548,5,383,0,0,4547,4549,3,544,272,0,4548,4547,1,0,0,
  	0,4548,4549,1,0,0,0,4549,4550,1,0,0,0,4550,4552,3,550,275,0,4551,4546,
  	1,0,0,0,4551,4552,1,0,0,0,4552,4554,1,0,0,0,4553,4539,1,0,0,0,4553,4545,
  	1,0,0,0,4554,543,1,0,0,0,4555,4556,7,51,0,0,4556,545,1,0,0,0,4557,4562,
  	3,548,274,0,4558,4559,5,773,0,0,4559,4561,3,548,274,0,4560,4558,1,0,0,
  	0,4561,4564,1,0,0,0,4562,4560,1,0,0,0,4562,4563,1,0,0,0,4563,547,1,0,
  	0,0,4564,4562,1,0,0,0,4565,4576,4,274,105,0,4566,4568,3,1184,592,0,4567,
  	4569,3,1044,522,0,4568,4567,1,0,0,0,4568,4569,1,0,0,0,4569,4577,1,0,0,
  	0,4570,4574,3,1184,592,0,4571,4575,5,784,0,0,4572,4573,5,783,0,0,4573,
  	4575,3,1180,590,0,4574,4571,1,0,0,0,4574,4572,1,0,0,0,4575,4577,1,0,0,
  	0,4576,4566,1,0,0,0,4576,4570,1,0,0,0,4577,4607,1,0,0,0,4578,4580,7,52,
  	0,0,4579,4581,3,1044,522,0,4580,4579,1,0,0,0,4580,4581,1,0,0,0,4581,4607,
  	1,0,0,0,4582,4607,7,53,0,0,4583,4584,5,215,0,0,4584,4607,5,391,0,0,4585,
  	4586,5,509,0,0,4586,4607,5,110,0,0,4587,4591,5,97,0,0,4588,4589,5,577,
  	0,0,4589,4592,5,571,0,0,4590,4592,7,54,0,0,4591,4588,1,0,0,0,4591,4590,
  	1,0,0,0,4591,4592,1,0,0,0,4592,4607,1,0,0,0,4593,4594,5,287,0,0,4594,
  	4607,5,571,0,0,4595,4596,5,459,0,0,4596,4607,7,55,0,0,4597,4598,5,509,
  	0,0,4598,4607,5,636,0,0,4599,4601,5,11,0,0,4600,4602,5,483,0,0,4601,4600,
  	1,0,0,0,4601,4602,1,0,0,0,4602,4607,1,0,0,0,4603,4604,4,274,106,0,4604,
  	4605,7,56,0,0,4605,4607,5,659,0,0,4606,4565,1,0,0,0,4606,4578,1,0,0,0,
  	4606,4582,1,0,0,0,4606,4583,1,0,0,0,4606,4585,1,0,0,0,4606,4587,1,0,0,
  	0,4606,4593,1,0,0,0,4606,4595,1,0,0,0,4606,4597,1,0,0,0,4606,4599,1,0,
  	0,0,4606,4603,1,0,0,0,4607,549,1,0,0,0,4608,4611,5,760,0,0,4609,4610,
  	5,772,0,0,4610,4612,5,760,0,0,4611,4609,1,0,0,0,4611,4612,1,0,0,0,4612,
  	4625,1,0,0,0,4613,4616,3,1058,529,0,4614,4615,5,772,0,0,4615,4617,5,760,
  	0,0,4616,4614,1,0,0,0,4616,4617,1,0,0,0,4617,4625,1,0,0,0,4618,4625,3,
  	1102,551,0,4619,4620,4,275,107,0,4620,4621,3,1058,529,0,4621,4622,5,772,
  	0,0,4622,4623,3,1102,551,0,4623,4625,1,0,0,0,4624,4608,1,0,0,0,4624,4613,
  	1,0,0,0,4624,4618,1,0,0,0,4624,4619,1,0,0,0,4625,551,1,0,0,0,4626,4633,
  	3,554,277,0,4627,4629,5,15,0,0,4628,4627,1,0,0,0,4628,4629,1,0,0,0,4629,
  	4630,1,0,0,0,4630,4632,3,554,277,0,4631,4628,1,0,0,0,4632,4635,1,0,0,
  	0,4633,4631,1,0,0,0,4633,4634,1,0,0,0,4634,553,1,0,0,0,4635,4633,1,0,
  	0,0,4636,4637,5,63,0,0,4637,4643,3,1156,578,0,4638,4639,5,259,0,0,4639,
  	4643,3,1156,578,0,4640,4641,5,559,0,0,4641,4643,3,1156,578,0,4642,4636,
  	1,0,0,0,4642,4638,1,0,0,0,4642,4640,1,0,0,0,4643,555,1,0,0,0,4644,4645,
  	5,215,0,0,4645,4655,5,391,0,0,4646,4647,5,322,0,0,4647,4655,3,1140,570,
  	0,4648,4649,5,327,0,0,4649,4655,3,1140,570,0,4650,4651,5,321,0,0,4651,
  	4655,3,1140,570,0,4652,4653,5,328,0,0,4653,4655,3,1140,570,0,4654,4644,
  	1,0,0,0,4654,4646,1,0,0,0,4654,4648,1,0,0,0,4654,4650,1,0,0,0,4654,4652,
  	1,0,0,0,4655,557,1,0,0,0,4656,4657,5,506,0,0,4657,4658,5,659,0,0,4658,
  	4680,3,560,280,0,4659,4660,5,506,0,0,4660,4661,5,659,0,0,4661,4680,7,
  	57,0,0,4662,4663,5,506,0,0,4663,4664,5,128,0,0,4664,4668,5,659,0,0,4665,
  	4669,3,560,280,0,4666,4669,5,369,0,0,4667,4669,5,10,0,0,4668,4665,1,0,
  	0,0,4668,4666,1,0,0,0,4668,4667,1,0,0,0,4669,4670,1,0,0,0,4670,4671,5,
  	590,0,0,4671,4680,3,560,280,0,4672,4673,5,506,0,0,4673,4674,5,659,0,0,
  	4674,4677,5,10,0,0,4675,4676,5,663,0,0,4676,4678,3,560,280,0,4677,4675,
  	1,0,0,0,4677,4678,1,0,0,0,4678,4680,1,0,0,0,4679,4656,1,0,0,0,4679,4659,
  	1,0,0,0,4679,4662,1,0,0,0,4679,4672,1,0,0,0,4680,559,1,0,0,0,4681,4686,
  	3,562,281,0,4682,4683,5,773,0,0,4683,4685,3,562,281,0,4684,4682,1,0,0,
  	0,4685,4688,1,0,0,0,4686,4684,1,0,0,0,4686,4687,1,0,0,0,4687,561,1,0,
  	0,0,4688,4686,1,0,0,0,4689,4693,3,1184,592,0,4690,4691,5,783,0,0,4691,
  	4694,3,1180,590,0,4692,4694,5,784,0,0,4693,4690,1,0,0,0,4693,4692,1,0,
  	0,0,4693,4694,1,0,0,0,4694,563,1,0,0,0,4695,4697,5,14,0,0,4696,4698,3,
  	1034,517,0,4697,4696,1,0,0,0,4697,4698,1,0,0,0,4698,4699,1,0,0,0,4699,
  	4700,5,574,0,0,4700,4703,3,1104,552,0,4701,4702,4,282,108,0,4702,4704,
  	3,566,283,0,4703,4701,1,0,0,0,4703,4704,1,0,0,0,4704,4739,1,0,0,0,4705,
  	4706,5,62,0,0,4706,4707,5,574,0,0,4707,4711,3,1104,552,0,4708,4710,3,
  	568,284,0,4709,4708,1,0,0,0,4710,4713,1,0,0,0,4711,4709,1,0,0,0,4711,
  	4712,1,0,0,0,4712,4739,1,0,0,0,4713,4711,1,0,0,0,4714,4715,5,61,0,0,4715,
  	4716,5,574,0,0,4716,4718,3,1104,552,0,4717,4719,7,58,0,0,4718,4717,1,
  	0,0,0,4718,4719,1,0,0,0,4719,4739,1,0,0,0,4720,4722,5,388,0,0,4721,4723,
  	3,1034,517,0,4722,4721,1,0,0,0,4722,4723,1,0,0,0,4723,4724,1,0,0,0,4724,
  	4725,5,574,0,0,4725,4739,3,1104,552,0,4726,4728,5,455,0,0,4727,4729,3,
  	1034,517,0,4728,4727,1,0,0,0,4728,4729,1,0,0,0,4729,4730,1,0,0,0,4730,
  	4731,5,574,0,0,4731,4735,3,1104,552,0,4732,4734,3,570,285,0,4733,4732,
  	1,0,0,0,4734,4737,1,0,0,0,4735,4733,1,0,0,0,4735,4736,1,0,0,0,4736,4739,
  	1,0,0,0,4737,4735,1,0,0,0,4738,4695,1,0,0,0,4738,4705,1,0,0,0,4738,4714,
  	1,0,0,0,4738,4720,1,0,0,0,4738,4726,1,0,0,0,4739,565,1,0,0,0,4740,4741,
  	5,614,0,0,4741,4742,5,674,0,0,4742,4743,5,383,0,0,4743,4747,3,1130,565,
  	0,4744,4745,5,645,0,0,4745,4746,5,747,0,0,4746,4748,5,675,0,0,4747,4744,
  	1,0,0,0,4747,4748,1,0,0,0,4748,4754,1,0,0,0,4749,4750,5,148,0,0,4750,
  	4751,5,674,0,0,4751,4752,5,383,0,0,4752,4754,3,1130,565,0,4753,4740,1,
  	0,0,0,4753,4749,1,0,0,0,4754,567,1,0,0,0,4755,4756,5,200,0,0,4756,4759,
  	5,615,0,0,4757,4759,7,59,0,0,4758,4755,1,0,0,0,4758,4757,1,0,0,0,4759,
  	569,1,0,0,0,4760,4761,7,60,0,0,4761,571,1,0,0,0,4762,4763,5,245,0,0,4763,
  	4764,5,410,0,0,4764,4765,3,1128,564,0,4765,4766,5,520,0,0,4766,4767,3,
  	1154,577,0,4767,4785,1,0,0,0,4768,4769,5,245,0,0,4769,4770,5,664,0,0,
  	4770,4785,3,1164,582,0,4771,4772,5,607,0,0,4772,4773,5,410,0,0,4773,4785,
  	3,1118,559,0,4774,4775,5,607,0,0,4775,4776,5,664,0,0,4776,4781,3,1120,
  	560,0,4777,4778,5,773,0,0,4778,4780,3,1120,560,0,4779,4777,1,0,0,0,4780,
  	4783,1,0,0,0,4781,4779,1,0,0,0,4781,4782,1,0,0,0,4782,4785,1,0,0,0,4783,
  	4781,1,0,0,0,4784,4762,1,0,0,0,4784,4768,1,0,0,0,4784,4771,1,0,0,0,4784,
  	4774,1,0,0,0,4785,573,1,0,0,0,4786,4787,5,506,0,0,4787,4788,3,576,288,
  	0,4788,575,1,0,0,0,4789,4790,3,586,293,0,4790,4791,3,584,292,0,4791,4846,
  	1,0,0,0,4792,4793,5,592,0,0,4793,4846,3,578,289,0,4794,4795,3,1192,596,
  	0,4795,4796,3,592,296,0,4796,4846,1,0,0,0,4797,4800,5,406,0,0,4798,4799,
  	5,200,0,0,4799,4801,3,1026,513,0,4800,4798,1,0,0,0,4800,4801,1,0,0,0,
  	4801,4802,1,0,0,0,4802,4829,3,1190,595,0,4803,4805,3,1156,578,0,4804,
  	4806,3,1022,511,0,4805,4804,1,0,0,0,4805,4806,1,0,0,0,4806,4808,1,0,0,
  	0,4807,4809,3,1018,509,0,4808,4807,1,0,0,0,4808,4809,1,0,0,0,4809,4830,
  	1,0,0,0,4810,4812,3,1156,578,0,4811,4813,3,1022,511,0,4812,4811,1,0,0,
  	0,4812,4813,1,0,0,0,4813,4815,1,0,0,0,4814,4816,3,1018,509,0,4815,4814,
  	1,0,0,0,4815,4816,1,0,0,0,4816,4830,1,0,0,0,4817,4818,4,288,109,0,4818,
  	4819,5,382,0,0,4819,4820,5,776,0,0,4820,4821,3,1156,578,0,4821,4822,5,
  	777,0,0,4822,4830,1,0,0,0,4823,4824,4,288,110,0,4824,4825,5,406,0,0,4825,
  	4826,5,776,0,0,4826,4827,3,1156,578,0,4827,4828,5,777,0,0,4828,4830,1,
  	0,0,0,4829,4803,1,0,0,0,4829,4810,1,0,0,0,4829,4817,1,0,0,0,4829,4823,
  	1,0,0,0,4830,4846,1,0,0,0,4831,4832,4,288,111,0,4832,4835,5,406,0,0,4833,
  	4834,5,200,0,0,4834,4836,3,1026,513,0,4835,4833,1,0,0,0,4835,4836,1,0,
  	0,0,4836,4837,1,0,0,0,4837,4838,5,590,0,0,4838,4840,5,734,0,0,4839,4841,
  	3,1022,511,0,4840,4839,1,0,0,0,4840,4841,1,0,0,0,4841,4843,1,0,0,0,4842,
  	4844,3,1018,509,0,4843,4842,1,0,0,0,4843,4844,1,0,0,0,4844,4846,1,0,0,
  	0,4845,4789,1,0,0,0,4845,4792,1,0,0,0,4845,4794,1,0,0,0,4845,4797,1,0,
  	0,0,4845,4831,1,0,0,0,4846,577,1,0,0,0,4847,4849,3,580,290,0,4848,4850,
  	3,582,291,0,4849,4848,1,0,0,0,4849,4850,1,0,0,0,4850,4857,1,0,0,0,4851,
  	4854,3,582,291,0,4852,4853,5,773,0,0,4853,4855,3,580,290,0,4854,4852,
  	1,0,0,0,4854,4855,1,0,0,0,4855,4857,1,0,0,0,4856,4847,1,0,0,0,4856,4851,
  	1,0,0,0,4857,579,1,0,0,0,4858,4859,5,435,0,0,4859,4860,7,39,0,0,4860,
  	581,1,0,0,0,4861,4862,5,258,0,0,4862,4868,5,274,0,0,4863,4864,5,456,0,
  	0,4864,4869,5,435,0,0,4865,4866,5,435,0,0,4866,4869,7,61,0,0,4867,4869,
  	5,500,0,0,4868,4863,1,0,0,0,4868,4865,1,0,0,0,4868,4867,1,0,0,0,4869,
  	583,1,0,0,0,4870,4871,5,773,0,0,4871,4873,3,588,294,0,4872,4870,1,0,0,
  	0,4873,4876,1,0,0,0,4874,4872,1,0,0,0,4874,4875,1,0,0,0,4875,585,1,0,
  	0,0,4876,4874,1,0,0,0,4877,4878,3,746,373,0,4878,4879,3,1190,595,0,4879,
  	4880,3,596,298,0,4880,4903,1,0,0,0,4881,4903,3,998,499,0,4882,4883,3,
  	742,371,0,4883,4884,3,1190,595,0,4884,4885,3,676,338,0,4885,4903,1,0,
  	0,0,4886,4887,3,590,295,0,4887,4888,3,1190,595,0,4888,4889,3,596,298,
  	0,4889,4903,1,0,0,0,4890,4900,5,356,0,0,4891,4892,3,1190,595,0,4892,4893,
  	3,676,338,0,4893,4901,1,0,0,0,4894,4896,3,936,468,0,4895,4897,3,986,493,
  	0,4896,4895,1,0,0,0,4896,4897,1,0,0,0,4897,4901,1,0,0,0,4898,4899,4,293,
  	112,0,4899,4901,5,128,0,0,4900,4891,1,0,0,0,4900,4894,1,0,0,0,4900,4898,
  	1,0,0,0,4901,4903,1,0,0,0,4902,4877,1,0,0,0,4902,4881,1,0,0,0,4902,4882,
  	1,0,0,0,4902,4886,1,0,0,0,4902,4890,1,0,0,0,4903,587,1,0,0,0,4904,4905,
  	3,1192,596,0,4905,4906,3,746,373,0,4906,4907,3,1190,595,0,4907,4908,3,
  	596,298,0,4908,4911,1,0,0,0,4909,4911,3,586,293,0,4910,4904,1,0,0,0,4910,
  	4909,1,0,0,0,4911,589,1,0,0,0,4912,4914,5,785,0,0,4913,4915,3,1196,598,
  	0,4914,4913,1,0,0,0,4914,4915,1,0,0,0,4915,4916,1,0,0,0,4916,4917,3,746,
  	373,0,4917,591,1,0,0,0,4918,4919,3,594,297,0,4919,4920,3,584,292,0,4920,
  	4924,1,0,0,0,4921,4922,5,592,0,0,4922,4924,3,578,289,0,4923,4918,1,0,
  	0,0,4923,4921,1,0,0,0,4924,593,1,0,0,0,4925,4926,3,746,373,0,4926,4927,
  	3,1190,595,0,4927,4928,3,596,298,0,4928,595,1,0,0,0,4929,4934,3,676,338,
  	0,4930,4934,7,62,0,0,4931,4932,4,298,113,0,4932,4934,7,63,0,0,4933,4929,
  	1,0,0,0,4933,4930,1,0,0,0,4933,4931,1,0,0,0,4934,597,1,0,0,0,4935,5155,
  	5,509,0,0,4936,4937,4,299,114,0,4937,5156,5,22,0,0,4938,4940,5,110,0,
  	0,4939,4941,3,1030,515,0,4940,4939,1,0,0,0,4940,4941,1,0,0,0,4941,5156,
  	1,0,0,0,4942,4944,3,600,300,0,4943,4942,1,0,0,0,4943,4944,1,0,0,0,4944,
  	4945,1,0,0,0,4945,4947,5,571,0,0,4946,4948,3,606,303,0,4947,4946,1,0,
  	0,0,4947,4948,1,0,0,0,4948,4950,1,0,0,0,4949,4951,3,1030,515,0,4950,4949,
  	1,0,0,0,4950,4951,1,0,0,0,4951,5156,1,0,0,0,4952,4954,5,204,0,0,4953,
  	4952,1,0,0,0,4953,4954,1,0,0,0,4954,4955,1,0,0,0,4955,4957,5,593,0,0,
  	4956,4958,3,606,303,0,4957,4956,1,0,0,0,4957,4958,1,0,0,0,4958,4960,1,
  	0,0,0,4959,4961,3,1030,515,0,4960,4959,1,0,0,0,4960,4961,1,0,0,0,4961,
  	5156,1,0,0,0,4962,4964,5,169,0,0,4963,4965,3,606,303,0,4964,4963,1,0,
  	0,0,4964,4965,1,0,0,0,4965,4967,1,0,0,0,4966,4968,3,1030,515,0,4967,4966,
  	1,0,0,0,4967,4968,1,0,0,0,4968,5156,1,0,0,0,4969,4970,5,574,0,0,4970,
  	4972,5,547,0,0,4971,4973,3,606,303,0,4972,4971,1,0,0,0,4972,4973,1,0,
  	0,0,4973,4975,1,0,0,0,4974,4976,3,1030,515,0,4975,4974,1,0,0,0,4975,4976,
  	1,0,0,0,4976,5156,1,0,0,0,4977,4978,5,387,0,0,4978,4980,5,571,0,0,4979,
  	4981,3,606,303,0,4980,4979,1,0,0,0,4980,4981,1,0,0,0,4981,4983,1,0,0,
  	0,4982,4984,3,1030,515,0,4983,4982,1,0,0,0,4983,4984,1,0,0,0,4984,5156,
  	1,0,0,0,4985,5156,5,408,0,0,4986,4989,5,163,0,0,4987,4990,3,1094,547,
  	0,4988,4990,5,10,0,0,4989,4987,1,0,0,0,4989,4988,1,0,0,0,4990,4991,1,
  	0,0,0,4991,5156,7,64,0,0,4992,4994,3,600,300,0,4993,4992,1,0,0,0,4993,
  	4994,1,0,0,0,4994,4995,1,0,0,0,4995,4996,5,71,0,0,4996,4997,7,65,0,0,
  	4997,4999,3,1102,551,0,4998,5000,3,606,303,0,4999,4998,1,0,0,0,4999,5000,
  	1,0,0,0,5000,5002,1,0,0,0,5001,5003,3,1030,515,0,5002,5001,1,0,0,0,5002,
  	5003,1,0,0,0,5003,5156,1,0,0,0,5004,5005,7,42,0,0,5005,5156,5,289,0,0,
  	5006,5013,5,514,0,0,5007,5014,5,225,0,0,5008,5009,5,547,0,0,5009,5011,
  	3,602,301,0,5010,5012,3,782,391,0,5011,5010,1,0,0,0,5011,5012,1,0,0,0,
  	5012,5014,1,0,0,0,5013,5007,1,0,0,0,5013,5008,1,0,0,0,5014,5156,1,0,0,
  	0,5015,5016,7,66,0,0,5016,5019,5,169,0,0,5017,5018,5,251,0,0,5018,5020,
  	3,1156,578,0,5019,5017,1,0,0,0,5019,5020,1,0,0,0,5020,5023,1,0,0,0,5021,
  	5022,5,203,0,0,5022,5024,3,1144,572,0,5023,5021,1,0,0,0,5023,5024,1,0,
  	0,0,5024,5026,1,0,0,0,5025,5027,3,284,142,0,5026,5025,1,0,0,0,5026,5027,
  	1,0,0,0,5027,5029,1,0,0,0,5028,5030,3,782,391,0,5029,5028,1,0,0,0,5029,
  	5030,1,0,0,0,5030,5156,1,0,0,0,5031,5032,4,299,115,0,5032,5034,5,180,
  	0,0,5033,5031,1,0,0,0,5033,5034,1,0,0,0,5034,5035,1,0,0,0,5035,5036,7,
  	67,0,0,5036,5037,3,604,302,0,5037,5039,3,1102,551,0,5038,5040,3,606,303,
  	0,5039,5038,1,0,0,0,5039,5040,1,0,0,0,5040,5042,1,0,0,0,5041,5043,3,358,
  	179,0,5042,5041,1,0,0,0,5042,5043,1,0,0,0,5043,5156,1,0,0,0,5044,5046,
  	5,553,0,0,5045,5044,1,0,0,0,5045,5046,1,0,0,0,5046,5047,1,0,0,0,5047,
  	5156,5,162,0,0,5048,5049,5,95,0,0,5049,5050,5,776,0,0,5050,5051,5,760,
  	0,0,5051,5052,5,777,0,0,5052,5156,7,68,0,0,5053,5055,5,639,0,0,5054,5056,
  	3,284,142,0,5055,5054,1,0,0,0,5055,5056,1,0,0,0,5056,5156,1,0,0,0,5057,
  	5059,5,166,0,0,5058,5060,3,284,142,0,5059,5058,1,0,0,0,5059,5060,1,0,
  	0,0,5060,5156,1,0,0,0,5061,5156,5,426,0,0,5062,5071,5,425,0,0,5063,5068,
  	3,608,304,0,5064,5065,5,773,0,0,5065,5067,3,608,304,0,5066,5064,1,0,0,
  	0,5067,5070,1,0,0,0,5068,5066,1,0,0,0,5068,5069,1,0,0,0,5069,5072,1,0,
  	0,0,5070,5068,1,0,0,0,5071,5063,1,0,0,0,5071,5072,1,0,0,0,5072,5076,1,
  	0,0,0,5073,5074,5,200,0,0,5074,5075,5,430,0,0,5075,5077,5,747,0,0,5076,
  	5073,1,0,0,0,5076,5077,1,0,0,0,5077,5079,1,0,0,0,5078,5080,3,284,142,
  	0,5079,5078,1,0,0,0,5079,5080,1,0,0,0,5080,5156,1,0,0,0,5081,5083,3,1192,
  	596,0,5082,5081,1,0,0,0,5082,5083,1,0,0,0,5083,5084,1,0,0,0,5084,5086,
  	7,69,0,0,5085,5087,3,1030,515,0,5086,5085,1,0,0,0,5086,5087,1,0,0,0,5087,
  	5156,1,0,0,0,5088,5090,5,204,0,0,5089,5088,1,0,0,0,5089,5090,1,0,0,0,
  	5090,5091,1,0,0,0,5091,5156,5,424,0,0,5092,5094,3,758,379,0,5093,5095,
  	3,1030,515,0,5094,5093,1,0,0,0,5094,5095,1,0,0,0,5095,5156,1,0,0,0,5096,
  	5098,5,70,0,0,5097,5099,3,1030,515,0,5098,5097,1,0,0,0,5098,5099,1,0,
  	0,0,5099,5156,1,0,0,0,5100,5101,4,299,116,0,5101,5156,5,93,0,0,5102,5156,
  	5,421,0,0,5103,5106,5,216,0,0,5104,5105,5,200,0,0,5105,5107,3,1026,513,
  	0,5106,5104,1,0,0,0,5106,5107,1,0,0,0,5107,5156,1,0,0,0,5108,5109,5,216,
  	0,0,5109,5110,5,200,0,0,5110,5111,3,1026,513,0,5111,5112,5,621,0,0,5112,
  	5113,3,1008,504,0,5113,5156,1,0,0,0,5114,5115,5,316,0,0,5115,5156,5,547,
  	0,0,5116,5137,5,97,0,0,5117,5119,5,109,0,0,5118,5120,3,980,490,0,5119,
  	5118,1,0,0,0,5119,5120,1,0,0,0,5120,5121,1,0,0,0,5121,5138,3,1058,529,
  	0,5122,5123,5,170,0,0,5123,5138,3,1086,543,0,5124,5125,5,206,0,0,5125,
  	5138,3,1066,533,0,5126,5127,5,422,0,0,5127,5138,3,1062,531,0,5128,5129,
  	5,574,0,0,5129,5138,3,1102,551,0,5130,5131,5,594,0,0,5131,5138,3,1070,
  	535,0,5132,5133,5,636,0,0,5133,5138,3,1074,537,0,5134,5135,4,299,117,
  	0,5135,5136,5,618,0,0,5136,5138,3,1026,513,0,5137,5117,1,0,0,0,5137,5122,
  	1,0,0,0,5137,5124,1,0,0,0,5137,5126,1,0,0,0,5137,5128,1,0,0,0,5137,5130,
  	1,0,0,0,5137,5132,1,0,0,0,5137,5134,1,0,0,0,5138,5156,1,0,0,0,5139,5140,
  	5,422,0,0,5140,5142,5,547,0,0,5141,5143,3,1030,515,0,5142,5141,1,0,0,
  	0,5142,5143,1,0,0,0,5143,5156,1,0,0,0,5144,5145,5,206,0,0,5145,5147,5,
  	547,0,0,5146,5148,3,1030,515,0,5147,5146,1,0,0,0,5147,5148,1,0,0,0,5148,
  	5156,1,0,0,0,5149,5150,5,422,0,0,5150,5151,5,68,0,0,5151,5156,3,1062,
  	531,0,5152,5153,5,206,0,0,5153,5154,5,68,0,0,5154,5156,3,1066,533,0,5155,
  	4936,1,0,0,0,5155,4938,1,0,0,0,5155,4943,1,0,0,0,5155,4953,1,0,0,0,5155,
  	4962,1,0,0,0,5155,4969,1,0,0,0,5155,4977,1,0,0,0,5155,4985,1,0,0,0,5155,
  	4986,1,0,0,0,5155,4993,1,0,0,0,5155,5004,1,0,0,0,5155,5006,1,0,0,0,5155,
  	5015,1,0,0,0,5155,5033,1,0,0,0,5155,5045,1,0,0,0,5155,5048,1,0,0,0,5155,
  	5053,1,0,0,0,5155,5057,1,0,0,0,5155,5061,1,0,0,0,5155,5062,1,0,0,0,5155,
  	5082,1,0,0,0,5155,5089,1,0,0,0,5155,5092,1,0,0,0,5155,5096,1,0,0,0,5155,
  	5100,1,0,0,0,5155,5102,1,0,0,0,5155,5103,1,0,0,0,5155,5108,1,0,0,0,5155,
  	5114,1,0,0,0,5155,5116,1,0,0,0,5155,5139,1,0,0,0,5155,5144,1,0,0,0,5155,
  	5149,1,0,0,0,5155,5152,1,0,0,0,5156,599,1,0,0,0,5157,5164,5,204,0,0,5158,
  	5159,4,300,118,0,5159,5161,5,180,0,0,5160,5162,5,204,0,0,5161,5160,1,
  	0,0,0,5161,5162,1,0,0,0,5162,5164,1,0,0,0,5163,5157,1,0,0,0,5163,5158,
  	1,0,0,0,5164,601,1,0,0,0,5165,5167,4,301,119,0,5166,5168,5,370,0,0,5167,
  	5166,1,0,0,0,5167,5168,1,0,0,0,5168,5171,1,0,0,0,5169,5171,1,0,0,0,5170,
  	5165,1,0,0,0,5170,5169,1,0,0,0,5171,603,1,0,0,0,5172,5173,7,65,0,0,5173,
  	605,1,0,0,0,5174,5175,3,604,302,0,5175,5176,3,1128,564,0,5176,607,1,0,
  	0,0,5177,5178,5,40,0,0,5178,5185,5,255,0,0,5179,5180,5,91,0,0,5180,5185,
  	5,568,0,0,5181,5182,5,400,0,0,5182,5185,5,185,0,0,5183,5185,7,70,0,0,
  	5184,5177,1,0,0,0,5184,5179,1,0,0,0,5184,5181,1,0,0,0,5184,5183,1,0,0,
  	0,5185,609,1,0,0,0,5186,5187,5,33,0,0,5187,5224,3,1160,580,0,5188,5189,
  	5,47,0,0,5189,5190,5,236,0,0,5190,5191,3,612,306,0,5191,5194,5,251,0,
  	0,5192,5195,3,1128,564,0,5193,5195,5,128,0,0,5194,5192,1,0,0,0,5194,5193,
  	1,0,0,0,5195,5224,1,0,0,0,5196,5198,5,196,0,0,5197,5199,3,1034,517,0,
  	5198,5197,1,0,0,0,5198,5199,1,0,0,0,5199,5209,1,0,0,0,5200,5210,3,630,
  	315,0,5201,5206,3,626,313,0,5202,5203,5,773,0,0,5203,5205,3,626,313,0,
  	5204,5202,1,0,0,0,5205,5208,1,0,0,0,5206,5204,1,0,0,0,5206,5207,1,0,0,
  	0,5207,5210,1,0,0,0,5208,5206,1,0,0,0,5209,5200,1,0,0,0,5209,5201,1,0,
  	0,0,5210,5224,1,0,0,0,5211,5213,5,266,0,0,5212,5214,7,71,0,0,5213,5212,
  	1,0,0,0,5213,5214,1,0,0,0,5214,5215,1,0,0,0,5215,5224,3,676,338,0,5216,
  	5217,5,281,0,0,5217,5218,5,236,0,0,5218,5219,5,248,0,0,5219,5220,5,47,
  	0,0,5220,5224,3,634,317,0,5221,5222,4,305,120,0,5222,5224,5,510,0,0,5223,
  	5186,1,0,0,0,5223,5188,1,0,0,0,5223,5196,1,0,0,0,5223,5211,1,0,0,0,5223,
  	5216,1,0,0,0,5223,5221,1,0,0,0,5224,611,1,0,0,0,5225,5228,3,614,307,0,
  	5226,5228,3,618,309,0,5227,5225,1,0,0,0,5227,5226,1,0,0,0,5228,613,1,
  	0,0,0,5229,5234,3,616,308,0,5230,5231,5,773,0,0,5231,5233,3,616,308,0,
  	5232,5230,1,0,0,0,5233,5236,1,0,0,0,5234,5232,1,0,0,0,5234,5235,1,0,0,
  	0,5235,615,1,0,0,0,5236,5234,1,0,0,0,5237,5239,3,1102,551,0,5238,5240,
  	3,620,310,0,5239,5238,1,0,0,0,5239,5240,1,0,0,0,5240,617,1,0,0,0,5241,
  	5242,3,1102,551,0,5242,5243,5,405,0,0,5243,5244,5,776,0,0,5244,5245,3,
  	52,26,0,5245,5247,5,777,0,0,5246,5248,3,620,310,0,5247,5246,1,0,0,0,5247,
  	5248,1,0,0,0,5248,619,1,0,0,0,5249,5250,3,406,203,0,5250,5252,5,776,0,
  	0,5251,5253,3,624,312,0,5252,5251,1,0,0,0,5252,5253,1,0,0,0,5253,5254,
  	1,0,0,0,5254,5255,5,777,0,0,5255,621,1,0,0,0,5256,5259,3,1128,564,0,5257,
  	5259,5,420,0,0,5258,5256,1,0,0,0,5258,5257,1,0,0,0,5259,623,1,0,0,0,5260,
  	5265,3,622,311,0,5261,5262,5,773,0,0,5262,5264,3,622,311,0,5263,5261,
  	1,0,0,0,5264,5267,1,0,0,0,5265,5263,1,0,0,0,5265,5266,1,0,0,0,5266,625,
  	1,0,0,0,5267,5265,1,0,0,0,5268,5284,7,72,0,0,5269,5271,3,628,314,0,5270,
  	5269,1,0,0,0,5270,5271,1,0,0,0,5271,5272,1,0,0,0,5272,5284,5,289,0,0,
  	5273,5274,5,445,0,0,5274,5276,5,289,0,0,5275,5277,3,782,391,0,5276,5275,
  	1,0,0,0,5276,5277,1,0,0,0,5277,5284,1,0,0,0,5278,5279,4,313,121,0,5279,
  	5280,5,430,0,0,5280,5284,5,47,0,0,5281,5282,4,313,122,0,5282,5284,5,389,
  	0,0,5283,5268,1,0,0,0,5283,5270,1,0,0,0,5283,5273,1,0,0,0,5283,5278,1,
  	0,0,0,5283,5281,1,0,0,0,5284,627,1,0,0,0,5285,5286,7,73,0,0,5286,629,
  	1,0,0,0,5287,5295,7,18,0,0,5288,5289,5,645,0,0,5289,5290,5,435,0,0,5290,
  	5296,5,287,0,0,5291,5293,3,1130,565,0,5292,5294,3,632,316,0,5293,5292,
  	1,0,0,0,5293,5294,1,0,0,0,5294,5296,1,0,0,0,5295,5288,1,0,0,0,5295,5291,
  	1,0,0,0,5295,5296,1,0,0,0,5296,631,1,0,0,0,5297,5298,4,316,123,0,5298,
  	5299,5,200,0,0,5299,5304,5,179,0,0,5300,5301,5,645,0,0,5301,5302,5,435,
  	0,0,5302,5304,5,287,0,0,5303,5297,1,0,0,0,5303,5300,1,0,0,0,5304,633,
  	1,0,0,0,5305,5306,3,1102,551,0,5306,5308,3,640,320,0,5307,5309,3,620,
  	310,0,5308,5307,1,0,0,0,5308,5309,1,0,0,0,5309,5312,1,0,0,0,5310,5311,
  	5,232,0,0,5311,5313,5,270,0,0,5312,5310,1,0,0,0,5312,5313,1,0,0,0,5313,
  	5316,1,0,0,0,5314,5316,3,636,318,0,5315,5305,1,0,0,0,5315,5314,1,0,0,
  	0,5316,635,1,0,0,0,5317,5322,3,638,319,0,5318,5319,5,773,0,0,5319,5321,
  	3,638,319,0,5320,5318,1,0,0,0,5321,5324,1,0,0,0,5322,5320,1,0,0,0,5322,
  	5323,1,0,0,0,5323,637,1,0,0,0,5324,5322,1,0,0,0,5325,5327,3,1102,551,
  	0,5326,5328,3,620,310,0,5327,5326,1,0,0,0,5327,5328,1,0,0,0,5328,5331,
  	1,0,0,0,5329,5330,5,232,0,0,5330,5332,5,270,0,0,5331,5329,1,0,0,0,5331,
  	5332,1,0,0,0,5332,639,1,0,0,0,5333,5334,5,405,0,0,5334,5335,5,776,0,0,
  	5335,5336,3,52,26,0,5336,5337,5,777,0,0,5337,641,1,0,0,0,5338,5343,3,
  	644,322,0,5339,5343,3,654,327,0,5340,5343,3,656,328,0,5341,5343,3,660,
  	330,0,5342,5338,1,0,0,0,5342,5339,1,0,0,0,5342,5340,1,0,0,0,5342,5341,
  	1,0,0,0,5343,643,1,0,0,0,5344,5345,5,97,0,0,5345,5346,5,709,0,0,5346,
  	5347,5,217,0,0,5347,5348,3,1128,564,0,5348,5350,5,599,0,0,5349,5351,3,
  	1190,595,0,5350,5349,1,0,0,0,5350,5351,1,0,0,0,5351,5352,1,0,0,0,5352,
  	5354,7,74,0,0,5353,5355,3,646,323,0,5354,5353,1,0,0,0,5354,5355,1,0,0,
  	0,5355,5357,1,0,0,0,5356,5358,3,650,325,0,5357,5356,1,0,0,0,5357,5358,
  	1,0,0,0,5358,5360,1,0,0,0,5359,5361,3,652,326,0,5360,5359,1,0,0,0,5360,
  	5361,1,0,0,0,5361,645,1,0,0,0,5362,5364,5,711,0,0,5363,5365,3,1190,595,
  	0,5364,5363,1,0,0,0,5364,5365,1,0,0,0,5365,5366,1,0,0,0,5366,5373,3,648,
  	324,0,5367,5369,5,773,0,0,5368,5367,1,0,0,0,5368,5369,1,0,0,0,5369,5370,
  	1,0,0,0,5370,5372,3,648,324,0,5371,5368,1,0,0,0,5372,5375,1,0,0,0,5373,
  	5371,1,0,0,0,5373,5374,1,0,0,0,5374,647,1,0,0,0,5375,5373,1,0,0,0,5376,
  	5379,5,747,0,0,5377,5378,5,759,0,0,5378,5380,5,747,0,0,5379,5377,1,0,
  	0,0,5379,5380,1,0,0,0,5380,649,1,0,0,0,5381,5383,5,708,0,0,5382,5384,
  	3,1190,595,0,5383,5382,1,0,0,0,5383,5384,1,0,0,0,5384,5385,1,0,0,0,5385,
  	5386,5,747,0,0,5386,651,1,0,0,0,5387,5388,7,75,0,0,5388,653,1,0,0,0,5389,
  	5390,5,11,0,0,5390,5391,5,709,0,0,5391,5392,5,217,0,0,5392,5394,3,1122,
  	561,0,5393,5395,3,646,323,0,5394,5393,1,0,0,0,5394,5395,1,0,0,0,5395,
  	5397,1,0,0,0,5396,5398,3,650,325,0,5397,5396,1,0,0,0,5397,5398,1,0,0,
  	0,5398,5400,1,0,0,0,5399,5401,3,652,326,0,5400,5399,1,0,0,0,5400,5401,
  	1,0,0,0,5401,5403,1,0,0,0,5402,5404,5,198,0,0,5403,5402,1,0,0,0,5403,
  	5404,1,0,0,0,5404,655,1,0,0,0,5405,5406,5,506,0,0,5406,5407,5,709,0,0,
  	5407,5408,5,217,0,0,5408,5411,3,1128,564,0,5409,5410,5,200,0,0,5410,5412,
  	3,658,329,0,5411,5409,1,0,0,0,5411,5412,1,0,0,0,5412,657,1,0,0,0,5413,
  	5420,3,1142,571,0,5414,5416,5,773,0,0,5415,5414,1,0,0,0,5415,5416,1,0,
  	0,0,5416,5417,1,0,0,0,5417,5419,3,1142,571,0,5418,5415,1,0,0,0,5419,5422,
  	1,0,0,0,5420,5418,1,0,0,0,5420,5421,1,0,0,0,5421,659,1,0,0,0,5422,5420,
  	1,0,0,0,5423,5424,5,148,0,0,5424,5425,5,709,0,0,5425,5426,5,217,0,0,5426,
  	5428,3,1122,561,0,5427,5429,5,198,0,0,5428,5427,1,0,0,0,5428,5429,1,0,
  	0,0,5429,661,1,0,0,0,5430,5437,3,664,332,0,5431,5437,3,666,333,0,5432,
  	5437,3,670,335,0,5433,5437,3,672,336,0,5434,5435,4,331,124,0,5435,5437,
  	3,674,337,0,5436,5430,1,0,0,0,5436,5431,1,0,0,0,5436,5432,1,0,0,0,5436,
  	5433,1,0,0,0,5436,5434,1,0,0,0,5437,663,1,0,0,0,5438,5439,7,76,0,0,5439,
  	5442,3,1102,551,0,5440,5443,3,1156,578,0,5441,5443,3,1046,523,0,5442,
  	5440,1,0,0,0,5442,5441,1,0,0,0,5442,5443,1,0,0,0,5443,665,1,0,0,0,5444,
  	5460,7,76,0,0,5445,5446,4,333,125,0,5446,5461,5,180,0,0,5447,5448,4,333,
  	126,0,5448,5461,5,404,0,0,5449,5450,4,333,127,0,5450,5451,5,201,0,0,5451,
  	5452,5,750,0,0,5452,5461,3,1180,590,0,5453,5454,4,333,128,0,5454,5461,
  	5,14,0,0,5455,5456,4,333,129,0,5456,5457,5,14,0,0,5457,5458,5,201,0,0,
  	5458,5459,5,750,0,0,5459,5461,3,1180,590,0,5460,5445,1,0,0,0,5460,5447,
  	1,0,0,0,5460,5449,1,0,0,0,5460,5453,1,0,0,0,5460,5455,1,0,0,0,5460,5461,
  	1,0,0,0,5461,5462,1,0,0,0,5462,5463,3,668,334,0,5463,667,1,0,0,0,5464,
  	5477,3,266,133,0,5465,5470,4,334,130,0,5466,5471,3,220,110,0,5467,5471,
  	3,232,116,0,5468,5471,3,264,132,0,5469,5471,3,416,208,0,5470,5466,1,0,
  	0,0,5470,5467,1,0,0,0,5470,5468,1,0,0,0,5470,5469,1,0,0,0,5471,5477,1,
  	0,0,0,5472,5473,4,334,131,0,5473,5474,5,200,0,0,5474,5475,5,84,0,0,5475,
  	5477,3,1142,571,0,5476,5464,1,0,0,0,5476,5465,1,0,0,0,5476,5472,1,0,0,
  	0,5477,669,1,0,0,0,5478,5479,5,222,0,0,5479,5480,3,1180,590,0,5480,671,
  	1,0,0,0,5481,5482,5,620,0,0,5482,5483,3,1128,564,0,5483,673,1,0,0,0,5484,
  	5485,5,714,0,0,5485,675,1,0,0,0,5486,5487,6,338,-1,0,5487,5493,3,678,
  	339,0,5488,5490,5,257,0,0,5489,5491,3,760,380,0,5490,5489,1,0,0,0,5490,
  	5491,1,0,0,0,5491,5492,1,0,0,0,5492,5494,7,77,0,0,5493,5488,1,0,0,0,5493,
  	5494,1,0,0,0,5494,5498,1,0,0,0,5495,5496,5,371,0,0,5496,5498,3,676,338,
  	4,5497,5486,1,0,0,0,5497,5495,1,0,0,0,5498,5510,1,0,0,0,5499,5500,10,
  	3,0,0,5500,5501,7,78,0,0,5501,5509,3,676,338,4,5502,5503,10,2,0,0,5503,
  	5504,5,654,0,0,5504,5509,3,676,338,3,5505,5506,10,1,0,0,5506,5507,7,79,
  	0,0,5507,5509,3,676,338,2,5508,5499,1,0,0,0,5508,5502,1,0,0,0,5508,5505,
  	1,0,0,0,5509,5512,1,0,0,0,5510,5508,1,0,0,0,5510,5511,1,0,0,0,5511,677,
  	1,0,0,0,5512,5510,1,0,0,0,5513,5514,6,339,-1,0,5514,5515,3,682,341,0,
  	5515,5533,1,0,0,0,5516,5517,10,3,0,0,5517,5519,5,257,0,0,5518,5520,3,
  	760,380,0,5519,5518,1,0,0,0,5519,5520,1,0,0,0,5520,5521,1,0,0,0,5521,
  	5532,5,376,0,0,5522,5523,10,2,0,0,5523,5524,3,680,340,0,5524,5525,3,682,
  	341,0,5525,5532,1,0,0,0,5526,5527,10,1,0,0,5527,5528,3,680,340,0,5528,
  	5529,7,80,0,0,5529,5530,3,280,140,0,5530,5532,1,0,0,0,5531,5516,1,0,0,
  	0,5531,5522,1,0,0,0,5531,5526,1,0,0,0,5532,5535,1,0,0,0,5533,5531,1,0,
  	0,0,5533,5534,1,0,0,0,5534,679,1,0,0,0,5535,5533,1,0,0,0,5536,5537,7,
  	81,0,0,5537,681,1,0,0,0,5538,5552,3,686,343,0,5539,5541,3,760,380,0,5540,
  	5539,1,0,0,0,5540,5541,1,0,0,0,5541,5542,1,0,0,0,5542,5553,3,684,342,
  	0,5543,5544,4,341,138,0,5544,5546,5,733,0,0,5545,5547,5,668,0,0,5546,
  	5545,1,0,0,0,5546,5547,1,0,0,0,5547,5548,1,0,0,0,5548,5553,3,772,386,
  	0,5549,5550,5,521,0,0,5550,5551,5,275,0,0,5551,5553,3,686,343,0,5552,
  	5540,1,0,0,0,5552,5543,1,0,0,0,5552,5549,1,0,0,0,5552,5553,1,0,0,0,5553,
  	683,1,0,0,0,5554,5560,5,251,0,0,5555,5561,3,280,140,0,5556,5557,5,776,
  	0,0,5557,5558,3,756,378,0,5558,5559,5,777,0,0,5559,5561,1,0,0,0,5560,
  	5555,1,0,0,0,5560,5556,1,0,0,0,5561,5576,1,0,0,0,5562,5563,5,30,0,0,5563,
  	5564,3,686,343,0,5564,5565,5,15,0,0,5565,5566,3,682,341,0,5566,5576,1,
  	0,0,0,5567,5568,5,275,0,0,5568,5571,3,688,344,0,5569,5570,5,168,0,0,5570,
  	5572,3,688,344,0,5571,5569,1,0,0,0,5571,5572,1,0,0,0,5572,5576,1,0,0,
  	0,5573,5574,5,444,0,0,5574,5576,3,686,343,0,5575,5554,1,0,0,0,5575,5562,
  	1,0,0,0,5575,5567,1,0,0,0,5575,5573,1,0,0,0,5576,685,1,0,0,0,5577,5578,
  	6,343,-1,0,5578,5579,3,688,344,0,5579,5606,1,0,0,0,5580,5581,10,7,0,0,
  	5581,5582,5,769,0,0,5582,5605,3,686,343,8,5583,5584,10,6,0,0,5584,5585,
  	7,82,0,0,5585,5605,3,686,343,7,5586,5587,10,5,0,0,5587,5588,7,83,0,0,
  	5588,5605,3,686,343,6,5589,5590,10,3,0,0,5590,5591,7,84,0,0,5591,5605,
  	3,686,343,4,5592,5593,10,2,0,0,5593,5594,5,768,0,0,5594,5605,3,686,343,
  	3,5595,5596,10,1,0,0,5596,5597,5,771,0,0,5597,5605,3,686,343,2,5598,5599,
  	10,4,0,0,5599,5600,7,83,0,0,5600,5601,5,247,0,0,5601,5602,3,676,338,0,
  	5602,5603,3,764,382,0,5603,5605,1,0,0,0,5604,5580,1,0,0,0,5604,5583,1,
  	0,0,0,5604,5586,1,0,0,0,5604,5589,1,0,0,0,5604,5592,1,0,0,0,5604,5595,
  	1,0,0,0,5604,5598,1,0,0,0,5605,5608,1,0,0,0,5606,5604,1,0,0,0,5606,5607,
  	1,0,0,0,5607,687,1,0,0,0,5608,5606,1,0,0,0,5609,5610,6,344,-1,0,5610,
  	5614,3,740,370,0,5611,5612,3,1190,595,0,5612,5613,3,676,338,0,5613,5615,
  	1,0,0,0,5614,5611,1,0,0,0,5614,5615,1,0,0,0,5615,5719,1,0,0,0,5616,5618,
  	3,1046,523,0,5617,5619,3,692,346,0,5618,5617,1,0,0,0,5618,5619,1,0,0,
  	0,5619,5719,1,0,0,0,5620,5719,3,716,358,0,5621,5719,3,734,367,0,5622,
  	5719,3,1148,574,0,5623,5719,5,787,0,0,5624,5719,3,694,347,0,5625,5626,
  	4,344,146,0,5626,5719,3,696,348,0,5627,5628,4,344,147,0,5628,5719,3,698,
  	349,0,5629,5630,7,85,0,0,5630,5719,3,688,344,14,5631,5632,3,762,381,0,
  	5632,5633,3,688,344,13,5633,5719,1,0,0,0,5634,5636,5,487,0,0,5635,5634,
  	1,0,0,0,5635,5636,1,0,0,0,5636,5637,1,0,0,0,5637,5638,5,776,0,0,5638,
  	5639,3,756,378,0,5639,5640,5,777,0,0,5640,5719,1,0,0,0,5641,5643,5,174,
  	0,0,5642,5641,1,0,0,0,5642,5643,1,0,0,0,5643,5644,1,0,0,0,5644,5719,3,
  	280,140,0,5645,5646,5,778,0,0,5646,5647,3,1128,564,0,5647,5648,3,676,
  	338,0,5648,5649,5,779,0,0,5649,5719,1,0,0,0,5650,5651,5,320,0,0,5651,
  	5652,3,710,355,0,5652,5653,5,7,0,0,5653,5654,5,776,0,0,5654,5656,3,686,
  	343,0,5655,5657,3,714,357,0,5656,5655,1,0,0,0,5656,5657,1,0,0,0,5657,
  	5658,1,0,0,0,5658,5659,5,777,0,0,5659,5719,1,0,0,0,5660,5661,5,32,0,0,
  	5661,5719,3,688,344,8,5662,5663,5,52,0,0,5663,5664,5,776,0,0,5664,5665,
  	3,676,338,0,5665,5666,5,17,0,0,5666,5668,3,754,377,0,5667,5669,3,690,
  	345,0,5668,5667,1,0,0,0,5668,5669,1,0,0,0,5669,5670,1,0,0,0,5670,5671,
  	5,777,0,0,5671,5719,1,0,0,0,5672,5674,5,51,0,0,5673,5675,3,676,338,0,
  	5674,5673,1,0,0,0,5674,5675,1,0,0,0,5675,5679,1,0,0,0,5676,5677,3,748,
  	374,0,5677,5678,3,750,375,0,5678,5680,1,0,0,0,5679,5676,1,0,0,0,5680,
  	5681,1,0,0,0,5681,5679,1,0,0,0,5681,5682,1,0,0,0,5682,5684,1,0,0,0,5683,
  	5685,3,752,376,0,5684,5683,1,0,0,0,5684,5685,1,0,0,0,5685,5686,1,0,0,
  	0,5686,5687,5,159,0,0,5687,5719,1,0,0,0,5688,5689,5,94,0,0,5689,5690,
  	5,776,0,0,5690,5691,3,676,338,0,5691,5692,5,773,0,0,5692,5693,3,754,377,
  	0,5693,5694,5,777,0,0,5694,5719,1,0,0,0,5695,5696,5,94,0,0,5696,5697,
  	5,776,0,0,5697,5698,3,676,338,0,5698,5699,5,621,0,0,5699,5700,3,936,468,
  	0,5700,5701,5,777,0,0,5701,5719,1,0,0,0,5702,5703,5,128,0,0,5703,5704,
  	5,776,0,0,5704,5705,3,1136,568,0,5705,5706,5,777,0,0,5706,5719,1,0,0,
  	0,5707,5708,5,626,0,0,5708,5709,5,776,0,0,5709,5710,3,1136,568,0,5710,
  	5711,5,777,0,0,5711,5719,1,0,0,0,5712,5713,5,247,0,0,5713,5714,3,676,
  	338,0,5714,5715,3,764,382,0,5715,5716,5,758,0,0,5716,5717,3,676,338,0,
  	5717,5719,1,0,0,0,5718,5609,1,0,0,0,5718,5616,1,0,0,0,5718,5620,1,0,0,
  	0,5718,5621,1,0,0,0,5718,5622,1,0,0,0,5718,5623,1,0,0,0,5718,5624,1,0,
  	0,0,5718,5625,1,0,0,0,5718,5627,1,0,0,0,5718,5629,1,0,0,0,5718,5631,1,
  	0,0,0,5718,5635,1,0,0,0,5718,5642,1,0,0,0,5718,5645,1,0,0,0,5718,5650,
  	1,0,0,0,5718,5660,1,0,0,0,5718,5662,1,0,0,0,5718,5672,1,0,0,0,5718,5688,
  	1,0,0,0,5718,5695,1,0,0,0,5718,5702,1,0,0,0,5718,5707,1,0,0,0,5718,5712,
  	1,0,0,0,5719,5728,1,0,0,0,5720,5721,10,15,0,0,5721,5722,5,746,0,0,5722,
  	5727,3,688,344,16,5723,5724,10,21,0,0,5724,5725,5,69,0,0,5725,5727,3,
  	1180,590,0,5726,5720,1,0,0,0,5726,5723,1,0,0,0,5727,5730,1,0,0,0,5728,
  	5726,1,0,0,0,5728,5729,1,0,0,0,5729,689,1,0,0,0,5730,5728,1,0,0,0,5731,
  	5732,4,345,150,0,5732,5733,5,731,0,0,5733,691,1,0,0,0,5734,5735,4,346,
  	151,0,5735,5736,5,781,0,0,5736,5741,3,1154,577,0,5737,5738,4,346,152,
  	0,5738,5739,5,782,0,0,5739,5741,3,1154,577,0,5740,5734,1,0,0,0,5740,5737,
  	1,0,0,0,5741,693,1,0,0,0,5742,5743,5,26,0,0,5743,5745,5,776,0,0,5744,
  	5746,5,143,0,0,5745,5744,1,0,0,0,5745,5746,1,0,0,0,5746,5747,1,0,0,0,
  	5747,5748,3,708,354,0,5748,5751,5,777,0,0,5749,5750,4,347,153,0,5750,
  	5752,3,700,350,0,5751,5749,1,0,0,0,5751,5752,1,0,0,0,5752,5874,1,0,0,
  	0,5753,5754,7,86,0,0,5754,5755,5,776,0,0,5755,5756,3,708,354,0,5756,5759,
  	5,777,0,0,5757,5758,4,347,154,0,5758,5760,3,700,350,0,5759,5757,1,0,0,
  	0,5759,5760,1,0,0,0,5760,5874,1,0,0,0,5761,5762,4,347,155,0,5762,5874,
  	3,706,353,0,5763,5764,5,95,0,0,5764,5766,5,776,0,0,5765,5767,5,10,0,0,
  	5766,5765,1,0,0,0,5766,5767,1,0,0,0,5767,5768,1,0,0,0,5768,5769,5,760,
  	0,0,5769,5772,5,777,0,0,5770,5771,4,347,156,0,5771,5773,3,700,350,0,5772,
  	5770,1,0,0,0,5772,5773,1,0,0,0,5773,5874,1,0,0,0,5774,5775,5,95,0,0,5775,
  	5783,5,776,0,0,5776,5778,5,10,0,0,5777,5776,1,0,0,0,5777,5778,1,0,0,0,
  	5778,5779,1,0,0,0,5779,5784,5,760,0,0,5780,5784,3,708,354,0,5781,5782,
  	5,143,0,0,5782,5784,3,756,378,0,5783,5777,1,0,0,0,5783,5780,1,0,0,0,5783,
  	5781,1,0,0,0,5784,5785,1,0,0,0,5785,5788,5,777,0,0,5786,5787,4,347,157,
  	0,5787,5789,3,700,350,0,5788,5786,1,0,0,0,5788,5789,1,0,0,0,5789,5874,
  	1,0,0,0,5790,5791,5,345,0,0,5791,5793,5,776,0,0,5792,5794,5,143,0,0,5793,
  	5792,1,0,0,0,5793,5794,1,0,0,0,5794,5795,1,0,0,0,5795,5796,3,708,354,
  	0,5796,5799,5,777,0,0,5797,5798,4,347,158,0,5798,5800,3,700,350,0,5799,
  	5797,1,0,0,0,5799,5800,1,0,0,0,5800,5874,1,0,0,0,5801,5802,5,326,0,0,
  	5802,5804,5,776,0,0,5803,5805,5,143,0,0,5804,5803,1,0,0,0,5804,5805,1,
  	0,0,0,5805,5806,1,0,0,0,5806,5807,3,708,354,0,5807,5810,5,777,0,0,5808,
  	5809,4,347,159,0,5809,5811,3,700,350,0,5810,5808,1,0,0,0,5810,5811,1,
  	0,0,0,5811,5874,1,0,0,0,5812,5813,5,551,0,0,5813,5814,5,776,0,0,5814,
  	5815,3,708,354,0,5815,5818,5,777,0,0,5816,5817,4,347,160,0,5817,5819,
  	3,700,350,0,5818,5816,1,0,0,0,5818,5819,1,0,0,0,5819,5874,1,0,0,0,5820,
  	5821,5,632,0,0,5821,5822,5,776,0,0,5822,5823,3,708,354,0,5823,5826,5,
  	777,0,0,5824,5825,4,347,161,0,5825,5827,3,700,350,0,5826,5824,1,0,0,0,
  	5826,5827,1,0,0,0,5827,5874,1,0,0,0,5828,5829,5,548,0,0,5829,5830,5,776,
  	0,0,5830,5831,3,708,354,0,5831,5834,5,777,0,0,5832,5833,4,347,162,0,5833,
  	5835,3,700,350,0,5834,5832,1,0,0,0,5834,5835,1,0,0,0,5835,5874,1,0,0,
  	0,5836,5837,5,635,0,0,5837,5838,5,776,0,0,5838,5839,3,708,354,0,5839,
  	5842,5,777,0,0,5840,5841,4,347,163,0,5841,5843,3,700,350,0,5842,5840,
  	1,0,0,0,5842,5843,1,0,0,0,5843,5874,1,0,0,0,5844,5845,5,564,0,0,5845,
  	5847,5,776,0,0,5846,5848,5,143,0,0,5847,5846,1,0,0,0,5847,5848,1,0,0,
  	0,5848,5849,1,0,0,0,5849,5850,3,708,354,0,5850,5853,5,777,0,0,5851,5852,
  	4,347,164,0,5852,5854,3,700,350,0,5853,5851,1,0,0,0,5853,5854,1,0,0,0,
  	5854,5874,1,0,0,0,5855,5856,5,218,0,0,5856,5858,5,776,0,0,5857,5859,5,
  	143,0,0,5858,5857,1,0,0,0,5858,5859,1,0,0,0,5859,5860,1,0,0,0,5860,5862,
  	3,756,378,0,5861,5863,3,328,164,0,5862,5861,1,0,0,0,5862,5863,1,0,0,0,
  	5863,5866,1,0,0,0,5864,5865,5,499,0,0,5865,5867,3,1156,578,0,5866,5864,
  	1,0,0,0,5866,5867,1,0,0,0,5867,5868,1,0,0,0,5868,5871,5,777,0,0,5869,
  	5870,4,347,165,0,5870,5872,3,700,350,0,5871,5869,1,0,0,0,5871,5872,1,
  	0,0,0,5872,5874,1,0,0,0,5873,5742,1,0,0,0,5873,5753,1,0,0,0,5873,5761,
  	1,0,0,0,5873,5763,1,0,0,0,5873,5774,1,0,0,0,5873,5790,1,0,0,0,5873,5801,
  	1,0,0,0,5873,5812,1,0,0,0,5873,5820,1,0,0,0,5873,5828,1,0,0,0,5873,5836,
  	1,0,0,0,5873,5844,1,0,0,0,5873,5855,1,0,0,0,5874,695,1,0,0,0,5875,5876,
  	5,672,0,0,5876,5877,5,776,0,0,5877,5878,3,756,378,0,5878,5879,5,777,0,
  	0,5879,697,1,0,0,0,5880,5881,7,87,0,0,5881,5882,3,1188,594,0,5882,5883,
  	3,700,350,0,5883,5923,1,0,0,0,5884,5885,5,688,0,0,5885,5886,3,772,386,
  	0,5886,5887,3,700,350,0,5887,5923,1,0,0,0,5888,5889,7,88,0,0,5889,5890,
  	5,776,0,0,5890,5892,3,676,338,0,5891,5893,3,702,351,0,5892,5891,1,0,0,
  	0,5892,5893,1,0,0,0,5893,5894,1,0,0,0,5894,5896,5,777,0,0,5895,5897,3,
  	704,352,0,5896,5895,1,0,0,0,5896,5897,1,0,0,0,5897,5898,1,0,0,0,5898,
  	5899,3,700,350,0,5899,5923,1,0,0,0,5900,5901,7,89,0,0,5901,5903,3,770,
  	385,0,5902,5904,3,704,352,0,5903,5902,1,0,0,0,5903,5904,1,0,0,0,5904,
  	5905,1,0,0,0,5905,5906,3,700,350,0,5906,5923,1,0,0,0,5907,5908,5,687,
  	0,0,5908,5909,5,776,0,0,5909,5910,3,676,338,0,5910,5911,5,773,0,0,5911,
  	5912,3,688,344,0,5912,5915,5,777,0,0,5913,5914,5,203,0,0,5914,5916,7,
  	90,0,0,5915,5913,1,0,0,0,5915,5916,1,0,0,0,5916,5918,1,0,0,0,5917,5919,
  	3,704,352,0,5918,5917,1,0,0,0,5918,5919,1,0,0,0,5919,5920,1,0,0,0,5920,
  	5921,3,700,350,0,5921,5923,1,0,0,0,5922,5880,1,0,0,0,5922,5884,1,0,0,
  	0,5922,5888,1,0,0,0,5922,5900,1,0,0,0,5922,5907,1,0,0,0,5923,699,1,0,
  	0,0,5924,5927,5,691,0,0,5925,5928,3,1124,562,0,5926,5928,3,302,151,0,
  	5927,5925,1,0,0,0,5927,5926,1,0,0,0,5928,701,1,0,0,0,5929,5932,5,773,
  	0,0,5930,5933,3,1144,572,0,5931,5933,5,787,0,0,5932,5930,1,0,0,0,5932,
  	5931,1,0,0,0,5933,5936,1,0,0,0,5934,5935,5,773,0,0,5935,5937,3,676,338,
  	0,5936,5934,1,0,0,0,5936,5937,1,0,0,0,5937,703,1,0,0,0,5938,5939,7,91,
  	0,0,5939,5940,5,689,0,0,5940,705,1,0,0,0,5941,5942,5,667,0,0,5942,5943,
  	5,776,0,0,5943,5944,3,708,354,0,5944,5946,5,777,0,0,5945,5947,3,700,350,
  	0,5946,5945,1,0,0,0,5946,5947,1,0,0,0,5947,5958,1,0,0,0,5948,5949,5,666,
  	0,0,5949,5950,5,776,0,0,5950,5951,3,708,354,0,5951,5952,5,773,0,0,5952,
  	5953,3,708,354,0,5953,5955,5,777,0,0,5954,5956,3,700,350,0,5955,5954,
  	1,0,0,0,5955,5956,1,0,0,0,5956,5958,1,0,0,0,5957,5941,1,0,0,0,5957,5948,
  	1,0,0,0,5958,707,1,0,0,0,5959,5961,5,10,0,0,5960,5959,1,0,0,0,5960,5961,
  	1,0,0,0,5961,5962,1,0,0,0,5962,5963,3,676,338,0,5963,709,1,0,0,0,5964,
  	5970,3,712,356,0,5965,5966,5,776,0,0,5966,5967,3,712,356,0,5967,5968,
  	5,777,0,0,5968,5970,1,0,0,0,5969,5964,1,0,0,0,5969,5965,1,0,0,0,5970,
  	711,1,0,0,0,5971,5976,3,1136,568,0,5972,5973,5,773,0,0,5973,5975,3,1136,
  	568,0,5974,5972,1,0,0,0,5975,5978,1,0,0,0,5976,5974,1,0,0,0,5976,5977,
  	1,0,0,0,5977,713,1,0,0,0,5978,5976,1,0,0,0,5979,5980,5,251,0,0,5980,5981,
  	5,41,0,0,5981,5995,5,346,0,0,5982,5983,5,251,0,0,5983,5984,5,359,0,0,
  	5984,5985,5,267,0,0,5985,5989,5,346,0,0,5986,5987,5,645,0,0,5987,5988,
  	5,430,0,0,5988,5990,5,176,0,0,5989,5986,1,0,0,0,5989,5990,1,0,0,0,5990,
  	5995,1,0,0,0,5991,5992,5,645,0,0,5992,5993,5,430,0,0,5993,5995,5,176,
  	0,0,5994,5979,1,0,0,0,5994,5982,1,0,0,0,5994,5991,1,0,0,0,5995,715,1,
  	0,0,0,5996,5997,5,60,0,0,5997,5998,5,776,0,0,5998,6001,3,756,378,0,5999,
  	6000,5,621,0,0,6000,6002,3,936,468,0,6001,5999,1,0,0,0,6001,6002,1,0,
  	0,0,6002,6003,1,0,0,0,6003,6004,5,777,0,0,6004,6270,1,0,0,0,6005,6007,
  	5,105,0,0,6006,6008,3,1188,594,0,6007,6006,1,0,0,0,6007,6008,1,0,0,0,
  	6008,6270,1,0,0,0,6009,6010,5,116,0,0,6010,6270,3,770,385,0,6011,6012,
  	5,122,0,0,6012,6270,3,770,385,0,6013,6014,5,229,0,0,6014,6270,3,770,385,
  	0,6015,6016,5,242,0,0,6016,6017,5,776,0,0,6017,6018,3,676,338,0,6018,
  	6019,5,773,0,0,6019,6020,3,676,338,0,6020,6021,5,773,0,0,6021,6022,3,
  	676,338,0,6022,6023,5,773,0,0,6023,6024,3,676,338,0,6024,6025,5,777,0,
  	0,6025,6270,1,0,0,0,6026,6027,5,247,0,0,6027,6028,5,776,0,0,6028,6031,
  	3,676,338,0,6029,6030,5,773,0,0,6030,6032,3,676,338,0,6031,6029,1,0,0,
  	0,6032,6033,1,0,0,0,6033,6031,1,0,0,0,6033,6034,1,0,0,0,6034,6035,1,0,
  	0,0,6035,6036,5,777,0,0,6036,6270,1,0,0,0,6037,6038,5,272,0,0,6038,6039,
  	5,776,0,0,6039,6040,3,676,338,0,6040,6041,5,773,0,0,6041,6042,3,676,338,
  	0,6042,6043,5,777,0,0,6043,6270,1,0,0,0,6044,6045,5,343,0,0,6045,6270,
  	3,770,385,0,6046,6047,5,350,0,0,6047,6270,3,770,385,0,6048,6049,5,478,
  	0,0,6049,6050,5,776,0,0,6050,6051,3,676,338,0,6051,6052,5,773,0,0,6052,
  	6053,3,676,338,0,6053,6054,5,777,0,0,6054,6270,1,0,0,0,6055,6056,5,495,
  	0,0,6056,6270,3,770,385,0,6057,6058,5,586,0,0,6058,6270,3,770,385,0,6059,
  	6060,5,583,0,0,6060,6061,5,776,0,0,6061,6064,3,676,338,0,6062,6063,5,
  	773,0,0,6063,6065,3,676,338,0,6064,6062,1,0,0,0,6064,6065,1,0,0,0,6065,
  	6066,1,0,0,0,6066,6067,5,777,0,0,6067,6270,1,0,0,0,6068,6270,3,730,365,
  	0,6069,6070,5,618,0,0,6070,6270,3,1188,594,0,6071,6072,5,626,0,0,6072,
  	6270,3,770,385,0,6073,6074,5,656,0,0,6074,6270,3,770,385,0,6075,6076,
  	7,92,0,0,6076,6077,5,776,0,0,6077,6078,3,676,338,0,6078,6084,5,773,0,
  	0,6079,6085,3,676,338,0,6080,6081,5,247,0,0,6081,6082,3,676,338,0,6082,
  	6083,3,764,382,0,6083,6085,1,0,0,0,6084,6079,1,0,0,0,6084,6080,1,0,0,
  	0,6085,6086,1,0,0,0,6086,6087,5,777,0,0,6087,6270,1,0,0,0,6088,6090,5,
  	100,0,0,6089,6091,3,1188,594,0,6090,6089,1,0,0,0,6090,6091,1,0,0,0,6091,
  	6270,1,0,0,0,6092,6094,5,108,0,0,6093,6095,3,720,360,0,6094,6093,1,0,
  	0,0,6094,6095,1,0,0,0,6095,6270,1,0,0,0,6096,6097,7,93,0,0,6097,6098,
  	5,776,0,0,6098,6099,3,676,338,0,6099,6100,5,773,0,0,6100,6101,5,247,0,
  	0,6101,6102,3,676,338,0,6102,6103,3,764,382,0,6103,6104,5,777,0,0,6104,
  	6270,1,0,0,0,6105,6106,5,182,0,0,6106,6107,5,776,0,0,6107,6108,3,764,
  	382,0,6108,6109,5,203,0,0,6109,6110,3,676,338,0,6110,6111,5,777,0,0,6111,
  	6270,1,0,0,0,6112,6113,5,213,0,0,6113,6114,5,776,0,0,6114,6115,3,728,
  	364,0,6115,6116,5,773,0,0,6116,6117,3,676,338,0,6117,6118,5,777,0,0,6118,
  	6270,1,0,0,0,6119,6121,5,372,0,0,6120,6122,3,720,360,0,6121,6120,1,0,
  	0,0,6121,6122,1,0,0,0,6122,6270,1,0,0,0,6123,6124,5,414,0,0,6124,6125,
  	5,776,0,0,6125,6126,3,686,343,0,6126,6127,5,251,0,0,6127,6128,3,676,338,
  	0,6128,6129,5,777,0,0,6129,6270,1,0,0,0,6130,6270,3,732,366,0,6131,6133,
  	5,569,0,0,6132,6134,3,720,360,0,6133,6132,1,0,0,0,6133,6134,1,0,0,0,6134,
  	6270,1,0,0,0,6135,6136,7,94,0,0,6136,6137,5,776,0,0,6137,6138,3,766,383,
  	0,6138,6139,5,773,0,0,6139,6140,3,676,338,0,6140,6141,5,773,0,0,6141,
  	6142,3,676,338,0,6142,6143,5,777,0,0,6143,6270,1,0,0,0,6144,6146,5,622,
  	0,0,6145,6147,3,1188,594,0,6146,6145,1,0,0,0,6146,6147,1,0,0,0,6147,6270,
  	1,0,0,0,6148,6150,5,624,0,0,6149,6151,3,720,360,0,6150,6149,1,0,0,0,6150,
  	6151,1,0,0,0,6151,6270,1,0,0,0,6152,6154,5,623,0,0,6153,6155,3,720,360,
  	0,6154,6153,1,0,0,0,6154,6155,1,0,0,0,6155,6270,1,0,0,0,6156,6157,5,19,
  	0,0,6157,6270,3,770,385,0,6158,6159,5,58,0,0,6159,6270,3,770,385,0,6160,
  	6161,5,67,0,0,6161,6270,3,768,384,0,6162,6163,5,70,0,0,6163,6270,3,770,
  	385,0,6164,6165,5,109,0,0,6165,6270,3,1188,594,0,6166,6167,5,231,0,0,
  	6167,6168,5,776,0,0,6168,6169,3,676,338,0,6169,6170,5,773,0,0,6170,6171,
  	3,676,338,0,6171,6172,5,773,0,0,6172,6173,3,676,338,0,6173,6174,5,777,
  	0,0,6174,6270,1,0,0,0,6175,6176,5,201,0,0,6176,6177,5,776,0,0,6177,6178,
  	3,676,338,0,6178,6179,5,773,0,0,6179,6182,3,676,338,0,6180,6181,5,773,
  	0,0,6181,6183,3,676,338,0,6182,6180,1,0,0,0,6182,6183,1,0,0,0,6183,6184,
  	1,0,0,0,6184,6185,5,777,0,0,6185,6270,1,0,0,0,6186,6187,5,337,0,0,6187,
  	6270,3,770,385,0,6188,6189,5,349,0,0,6189,6190,5,776,0,0,6190,6191,3,
  	676,338,0,6191,6192,5,773,0,0,6192,6193,3,676,338,0,6193,6194,5,777,0,
  	0,6194,6270,1,0,0,0,6195,6196,4,358,166,0,6196,6197,5,382,0,0,6197,6198,
  	5,776,0,0,6198,6199,3,1160,580,0,6199,6200,5,777,0,0,6200,6270,1,0,0,
  	0,6201,6202,4,358,167,0,6202,6203,5,406,0,0,6203,6270,3,770,385,0,6204,
  	6205,5,429,0,0,6205,6270,3,770,385,0,6206,6207,5,457,0,0,6207,6208,5,
  	776,0,0,6208,6209,3,676,338,0,6209,6210,5,773,0,0,6210,6211,3,676,338,
  	0,6211,6212,5,777,0,0,6212,6270,1,0,0,0,6213,6214,5,458,0,0,6214,6215,
  	5,776,0,0,6215,6216,3,676,338,0,6216,6217,5,773,0,0,6217,6218,3,676,338,
  	0,6218,6219,5,773,0,0,6219,6220,3,676,338,0,6220,6221,5,777,0,0,6221,
  	6270,1,0,0,0,6222,6223,5,476,0,0,6223,6270,3,770,385,0,6224,6225,5,485,
  	0,0,6225,6270,3,1188,594,0,6226,6227,5,597,0,0,6227,6228,5,776,0,0,6228,
  	6229,3,676,338,0,6229,6230,5,773,0,0,6230,6231,3,676,338,0,6231,6232,
  	5,777,0,0,6232,6270,1,0,0,0,6233,6234,5,640,0,0,6234,6235,5,776,0,0,6235,
  	6238,3,676,338,0,6236,6237,5,773,0,0,6237,6239,3,676,338,0,6238,6236,
  	1,0,0,0,6238,6239,1,0,0,0,6239,6240,1,0,0,0,6240,6241,5,777,0,0,6241,
  	6270,1,0,0,0,6242,6243,5,641,0,0,6243,6244,5,776,0,0,6244,6264,3,676,
  	338,0,6245,6246,5,17,0,0,6246,6247,5,60,0,0,6247,6249,3,932,466,0,6248,
  	6245,1,0,0,0,6248,6249,1,0,0,0,6249,6252,1,0,0,0,6250,6251,4,358,168,
  	0,6251,6253,3,724,362,0,6252,6250,1,0,0,0,6252,6253,1,0,0,0,6253,6265,
  	1,0,0,0,6254,6255,5,17,0,0,6255,6256,5,32,0,0,6256,6265,3,932,466,0,6257,
  	6258,5,773,0,0,6258,6259,3,1140,570,0,6259,6260,5,773,0,0,6260,6261,3,
  	1140,570,0,6261,6262,5,773,0,0,6262,6263,3,1140,570,0,6263,6265,1,0,0,
  	0,6264,6248,1,0,0,0,6264,6254,1,0,0,0,6264,6257,1,0,0,0,6265,6266,1,0,
  	0,0,6266,6267,5,777,0,0,6267,6270,1,0,0,0,6268,6270,3,718,359,0,6269,
  	5996,1,0,0,0,6269,6005,1,0,0,0,6269,6009,1,0,0,0,6269,6011,1,0,0,0,6269,
  	6013,1,0,0,0,6269,6015,1,0,0,0,6269,6026,1,0,0,0,6269,6037,1,0,0,0,6269,
  	6044,1,0,0,0,6269,6046,1,0,0,0,6269,6048,1,0,0,0,6269,6055,1,0,0,0,6269,
  	6057,1,0,0,0,6269,6059,1,0,0,0,6269,6068,1,0,0,0,6269,6069,1,0,0,0,6269,
  	6071,1,0,0,0,6269,6073,1,0,0,0,6269,6075,1,0,0,0,6269,6088,1,0,0,0,6269,
  	6092,1,0,0,0,6269,6096,1,0,0,0,6269,6105,1,0,0,0,6269,6112,1,0,0,0,6269,
  	6119,1,0,0,0,6269,6123,1,0,0,0,6269,6130,1,0,0,0,6269,6131,1,0,0,0,6269,
  	6135,1,0,0,0,6269,6144,1,0,0,0,6269,6148,1,0,0,0,6269,6152,1,0,0,0,6269,
  	6156,1,0,0,0,6269,6158,1,0,0,0,6269,6160,1,0,0,0,6269,6162,1,0,0,0,6269,
  	6164,1,0,0,0,6269,6166,1,0,0,0,6269,6175,1,0,0,0,6269,6186,1,0,0,0,6269,
  	6188,1,0,0,0,6269,6195,1,0,0,0,6269,6201,1,0,0,0,6269,6204,1,0,0,0,6269,
  	6206,1,0,0,0,6269,6213,1,0,0,0,6269,6222,1,0,0,0,6269,6224,1,0,0,0,6269,
  	6226,1,0,0,0,6269,6233,1,0,0,0,6269,6242,1,0,0,0,6269,6268,1,0,0,0,6270,
  	717,1,0,0,0,6271,6272,4,359,169,0,6272,6273,5,90,0,0,6273,6274,5,776,
  	0,0,6274,6275,3,676,338,0,6275,6276,5,773,0,0,6276,6277,3,676,338,0,6277,
  	6278,5,777,0,0,6278,6303,1,0,0,0,6279,6280,5,211,0,0,6280,6282,5,776,
  	0,0,6281,6283,3,756,378,0,6282,6281,1,0,0,0,6282,6283,1,0,0,0,6283,6284,
  	1,0,0,0,6284,6303,5,777,0,0,6285,6286,5,279,0,0,6286,6303,3,768,384,0,
  	6287,6288,5,351,0,0,6288,6303,3,768,384,0,6289,6290,5,352,0,0,6290,6303,
  	3,768,384,0,6291,6292,5,353,0,0,6292,6303,3,768,384,0,6293,6294,5,411,
  	0,0,6294,6295,5,776,0,0,6295,6296,3,676,338,0,6296,6297,5,773,0,0,6297,
  	6298,3,676,338,0,6298,6299,5,777,0,0,6299,6303,1,0,0,0,6300,6301,5,412,
  	0,0,6301,6303,3,768,384,0,6302,6271,1,0,0,0,6302,6279,1,0,0,0,6302,6285,
  	1,0,0,0,6302,6287,1,0,0,0,6302,6289,1,0,0,0,6302,6291,1,0,0,0,6302,6293,
  	1,0,0,0,6302,6300,1,0,0,0,6303,719,1,0,0,0,6304,6306,5,776,0,0,6305,6307,
  	3,722,361,0,6306,6305,1,0,0,0,6306,6307,1,0,0,0,6307,6308,1,0,0,0,6308,
  	6309,5,777,0,0,6309,721,1,0,0,0,6310,6311,4,361,170,0,6311,6312,5,747,
  	0,0,6312,723,1,0,0,0,6313,6326,5,274,0,0,6314,6315,3,1142,571,0,6315,
  	6316,5,759,0,0,6316,6317,3,1142,571,0,6317,6327,1,0,0,0,6318,6323,3,726,
  	363,0,6319,6320,5,773,0,0,6320,6322,3,726,363,0,6321,6319,1,0,0,0,6322,
  	6325,1,0,0,0,6323,6321,1,0,0,0,6323,6324,1,0,0,0,6324,6327,1,0,0,0,6325,
  	6323,1,0,0,0,6326,6314,1,0,0,0,6326,6318,1,0,0,0,6327,725,1,0,0,0,6328,
  	6334,3,1142,571,0,6329,6331,7,33,0,0,6330,6332,5,476,0,0,6331,6330,1,
  	0,0,0,6331,6332,1,0,0,0,6332,6335,1,0,0,0,6333,6335,5,476,0,0,6334,6329,
  	1,0,0,0,6334,6333,1,0,0,0,6334,6335,1,0,0,0,6335,727,1,0,0,0,6336,6337,
  	7,95,0,0,6337,729,1,0,0,0,6338,6339,5,595,0,0,6339,6363,5,776,0,0,6340,
  	6343,3,676,338,0,6341,6342,5,203,0,0,6342,6344,3,676,338,0,6343,6341,
  	1,0,0,0,6343,6344,1,0,0,0,6344,6364,1,0,0,0,6345,6347,5,269,0,0,6346,
  	6348,3,676,338,0,6347,6346,1,0,0,0,6347,6348,1,0,0,0,6348,6349,1,0,0,
  	0,6349,6350,5,203,0,0,6350,6364,3,676,338,0,6351,6353,5,591,0,0,6352,
  	6354,3,676,338,0,6353,6352,1,0,0,0,6353,6354,1,0,0,0,6354,6355,1,0,0,
  	0,6355,6356,5,203,0,0,6356,6364,3,676,338,0,6357,6359,5,43,0,0,6358,6360,
  	3,676,338,0,6359,6358,1,0,0,0,6359,6360,1,0,0,0,6360,6361,1,0,0,0,6361,
  	6362,5,203,0,0,6362,6364,3,676,338,0,6363,6340,1,0,0,0,6363,6345,1,0,
  	0,0,6363,6351,1,0,0,0,6363,6357,1,0,0,0,6364,6365,1,0,0,0,6365,6366,5,
  	777,0,0,6366,731,1,0,0,0,6367,6368,5,563,0,0,6368,6369,5,776,0,0,6369,
  	6382,3,676,338,0,6370,6371,5,773,0,0,6371,6374,3,676,338,0,6372,6373,
  	5,773,0,0,6373,6375,3,676,338,0,6374,6372,1,0,0,0,6374,6375,1,0,0,0,6375,
  	6383,1,0,0,0,6376,6377,5,203,0,0,6377,6380,3,676,338,0,6378,6379,5,200,
  	0,0,6379,6381,3,676,338,0,6380,6378,1,0,0,0,6380,6381,1,0,0,0,6381,6383,
  	1,0,0,0,6382,6370,1,0,0,0,6382,6376,1,0,0,0,6383,6384,1,0,0,0,6384,6385,
  	5,777,0,0,6385,733,1,0,0,0,6386,6387,3,1126,563,0,6387,6389,5,776,0,0,
  	6388,6390,3,736,368,0,6389,6388,1,0,0,0,6389,6390,1,0,0,0,6390,6391,1,
  	0,0,0,6391,6392,5,777,0,0,6392,6401,1,0,0,0,6393,6394,3,1134,567,0,6394,
  	6396,5,776,0,0,6395,6397,3,756,378,0,6396,6395,1,0,0,0,6396,6397,1,0,
  	0,0,6397,6398,1,0,0,0,6398,6399,5,777,0,0,6399,6401,1,0,0,0,6400,6386,
  	1,0,0,0,6400,6393,1,0,0,0,6401,735,1,0,0,0,6402,6407,3,738,369,0,6403,
  	6404,5,773,0,0,6404,6406,3,738,369,0,6405,6403,1,0,0,0,6406,6409,1,0,
  	0,0,6407,6405,1,0,0,0,6407,6408,1,0,0,0,6408,737,1,0,0,0,6409,6407,1,
  	0,0,0,6410,6412,3,676,338,0,6411,6413,3,356,178,0,6412,6411,1,0,0,0,6412,
  	6413,1,0,0,0,6413,739,1,0,0,0,6414,6417,3,742,371,0,6415,6417,3,744,372,
  	0,6416,6414,1,0,0,0,6416,6415,1,0,0,0,6417,741,1,0,0,0,6418,6419,5,783,
  	0,0,6419,6422,3,1180,590,0,6420,6422,5,784,0,0,6421,6418,1,0,0,0,6421,
  	6420,1,0,0,0,6422,743,1,0,0,0,6423,6425,5,785,0,0,6424,6426,3,1194,597,
  	0,6425,6424,1,0,0,0,6425,6426,1,0,0,0,6426,6427,1,0,0,0,6427,6429,3,1180,
  	590,0,6428,6430,3,1138,569,0,6429,6428,1,0,0,0,6429,6430,1,0,0,0,6430,
  	745,1,0,0,0,6431,6432,4,373,171,0,6432,6434,3,1128,564,0,6433,6435,3,
  	1138,569,0,6434,6433,1,0,0,0,6434,6435,1,0,0,0,6435,6442,1,0,0,0,6436,
  	6437,4,373,172,0,6437,6439,3,1182,591,0,6438,6440,3,1138,569,0,6439,6438,
  	1,0,0,0,6439,6440,1,0,0,0,6440,6442,1,0,0,0,6441,6431,1,0,0,0,6441,6436,
  	1,0,0,0,6442,6446,1,0,0,0,6443,6444,5,128,0,0,6444,6446,3,1138,569,0,
  	6445,6441,1,0,0,0,6445,6443,1,0,0,0,6446,747,1,0,0,0,6447,6448,5,642,
  	0,0,6448,6449,3,676,338,0,6449,749,1,0,0,0,6450,6451,5,582,0,0,6451,6452,
  	3,676,338,0,6452,751,1,0,0,0,6453,6454,5,154,0,0,6454,6455,3,676,338,
  	0,6455,753,1,0,0,0,6456,6458,5,32,0,0,6457,6459,3,922,461,0,6458,6457,
  	1,0,0,0,6458,6459,1,0,0,0,6459,6502,1,0,0,0,6460,6462,5,60,0,0,6461,6463,
  	3,922,461,0,6462,6461,1,0,0,0,6462,6463,1,0,0,0,6463,6465,1,0,0,0,6464,
  	6466,3,926,463,0,6465,6464,1,0,0,0,6465,6466,1,0,0,0,6466,6502,1,0,0,
  	0,6467,6469,3,918,459,0,6468,6470,3,922,461,0,6469,6468,1,0,0,0,6469,
  	6470,1,0,0,0,6470,6502,1,0,0,0,6471,6473,5,512,0,0,6472,6474,5,249,0,
  	0,6473,6472,1,0,0,0,6473,6474,1,0,0,0,6474,6502,1,0,0,0,6475,6477,5,612,
  	0,0,6476,6478,5,249,0,0,6477,6476,1,0,0,0,6477,6478,1,0,0,0,6478,6502,
  	1,0,0,0,6479,6502,5,116,0,0,6480,6482,5,586,0,0,6481,6483,3,934,467,0,
  	6482,6481,1,0,0,0,6482,6483,1,0,0,0,6483,6502,1,0,0,0,6484,6486,5,113,
  	0,0,6485,6487,3,934,467,0,6486,6485,1,0,0,0,6486,6487,1,0,0,0,6487,6502,
  	1,0,0,0,6488,6490,5,126,0,0,6489,6491,3,1174,587,0,6490,6489,1,0,0,0,
  	6490,6491,1,0,0,0,6491,6502,1,0,0,0,6492,6493,4,377,173,0,6493,6502,5,
  	262,0,0,6494,6495,4,377,174,0,6495,6502,3,920,460,0,6496,6497,4,377,175,
  	0,6497,6499,5,195,0,0,6498,6500,3,1176,588,0,6499,6498,1,0,0,0,6499,6500,
  	1,0,0,0,6500,6502,1,0,0,0,6501,6456,1,0,0,0,6501,6460,1,0,0,0,6501,6467,
  	1,0,0,0,6501,6471,1,0,0,0,6501,6475,1,0,0,0,6501,6479,1,0,0,0,6501,6480,
  	1,0,0,0,6501,6484,1,0,0,0,6501,6488,1,0,0,0,6501,6492,1,0,0,0,6501,6494,
  	1,0,0,0,6501,6496,1,0,0,0,6502,755,1,0,0,0,6503,6508,3,676,338,0,6504,
  	6505,5,773,0,0,6505,6507,3,676,338,0,6506,6504,1,0,0,0,6507,6510,1,0,
  	0,0,6508,6506,1,0,0,0,6508,6509,1,0,0,0,6509,757,1,0,0,0,6510,6508,1,
  	0,0,0,6511,6512,5,60,0,0,6512,6515,5,506,0,0,6513,6515,5,58,0,0,6514,
  	6511,1,0,0,0,6514,6513,1,0,0,0,6515,759,1,0,0,0,6516,6517,7,96,0,0,6517,
  	761,1,0,0,0,6518,6519,7,97,0,0,6519,763,1,0,0,0,6520,6523,3,766,383,0,
  	6521,6523,7,98,0,0,6522,6520,1,0,0,0,6522,6521,1,0,0,0,6523,765,1,0,0,
  	0,6524,6525,7,99,0,0,6525,767,1,0,0,0,6526,6527,5,776,0,0,6527,6528,3,
  	756,378,0,6528,6529,5,777,0,0,6529,769,1,0,0,0,6530,6531,5,776,0,0,6531,
  	6532,3,676,338,0,6532,6533,5,777,0,0,6533,771,1,0,0,0,6534,6535,5,776,
  	0,0,6535,6536,3,688,344,0,6536,6537,5,777,0,0,6537,773,1,0,0,0,6538,6543,
  	3,776,388,0,6539,6540,5,773,0,0,6540,6542,3,776,388,0,6541,6539,1,0,0,
  	0,6542,6545,1,0,0,0,6543,6541,1,0,0,0,6543,6544,1,0,0,0,6544,775,1,0,
  	0,0,6545,6543,1,0,0,0,6546,6548,3,676,338,0,6547,6549,3,330,165,0,6548,
  	6547,1,0,0,0,6548,6549,1,0,0,0,6549,777,1,0,0,0,6550,6555,3,780,390,0,
  	6551,6552,5,773,0,0,6552,6554,3,780,390,0,6553,6551,1,0,0,0,6554,6557,
  	1,0,0,0,6555,6553,1,0,0,0,6555,6556,1,0,0,0,6556,779,1,0,0,0,6557,6555,
  	1,0,0,0,6558,6559,3,676,338,0,6559,781,1,0,0,0,6560,6561,4,391,176,0,
  	6561,6562,5,200,0,0,6562,6563,5,57,0,0,6563,6564,3,1162,581,0,6564,783,
  	1,0,0,0,6565,6579,3,2,1,0,6566,6579,3,786,393,0,6567,6579,3,788,394,0,
  	6568,6579,3,796,398,0,6569,6579,3,800,400,0,6570,6579,3,802,401,0,6571,
  	6579,3,808,404,0,6572,6579,3,810,405,0,6573,6579,3,838,419,0,6574,6579,
  	3,836,418,0,6575,6579,3,856,428,0,6576,6579,3,860,430,0,6577,6579,3,858,
  	429,0,6578,6565,1,0,0,0,6578,6566,1,0,0,0,6578,6567,1,0,0,0,6578,6568,
  	1,0,0,0,6578,6569,1,0,0,0,6578,6570,1,0,0,0,6578,6571,1,0,0,0,6578,6572,
  	1,0,0,0,6578,6573,1,0,0,0,6578,6574,1,0,0,0,6578,6575,1,0,0,0,6578,6576,
  	1,0,0,0,6578,6577,1,0,0,0,6579,785,1,0,0,0,6580,6581,5,475,0,0,6581,6582,
  	3,676,338,0,6582,787,1,0,0,0,6583,6584,5,231,0,0,6584,6585,3,790,395,
  	0,6585,6586,5,159,0,0,6586,6587,5,231,0,0,6587,789,1,0,0,0,6588,6589,
  	3,676,338,0,6589,6594,3,792,396,0,6590,6591,5,155,0,0,6591,6595,3,790,
  	395,0,6592,6593,5,154,0,0,6593,6595,3,794,397,0,6594,6590,1,0,0,0,6594,
  	6592,1,0,0,0,6594,6595,1,0,0,0,6595,791,1,0,0,0,6596,6597,5,582,0,0,6597,
  	6598,3,794,397,0,6598,793,1,0,0,0,6599,6600,3,784,392,0,6600,6601,5,774,
  	0,0,6601,6603,1,0,0,0,6602,6599,1,0,0,0,6603,6604,1,0,0,0,6604,6602,1,
  	0,0,0,6604,6605,1,0,0,0,6605,795,1,0,0,0,6606,6608,5,51,0,0,6607,6609,
  	3,676,338,0,6608,6607,1,0,0,0,6608,6609,1,0,0,0,6609,6613,1,0,0,0,6610,
  	6611,3,748,374,0,6611,6612,3,792,396,0,6612,6614,1,0,0,0,6613,6610,1,
  	0,0,0,6614,6615,1,0,0,0,6615,6613,1,0,0,0,6615,6616,1,0,0,0,6616,6618,
  	1,0,0,0,6617,6619,3,798,399,0,6618,6617,1,0,0,0,6618,6619,1,0,0,0,6619,
  	6620,1,0,0,0,6620,6621,5,159,0,0,6621,6622,5,51,0,0,6622,797,1,0,0,0,
  	6623,6624,5,154,0,0,6624,6625,3,794,397,0,6625,799,1,0,0,0,6626,6627,
  	3,804,402,0,6627,6629,3,806,403,0,6628,6630,3,1112,556,0,6629,6628,1,
  	0,0,0,6629,6630,1,0,0,0,6630,801,1,0,0,0,6631,6632,3,806,403,0,6632,803,
  	1,0,0,0,6633,6634,3,1110,555,0,6634,6635,5,775,0,0,6635,805,1,0,0,0,6636,
  	6638,5,29,0,0,6637,6639,3,818,409,0,6638,6637,1,0,0,0,6638,6639,1,0,0,
  	0,6639,6641,1,0,0,0,6640,6642,3,794,397,0,6641,6640,1,0,0,0,6641,6642,
  	1,0,0,0,6642,6643,1,0,0,0,6643,6644,5,159,0,0,6644,807,1,0,0,0,6645,6646,
  	3,804,402,0,6646,6648,3,810,405,0,6647,6649,3,1112,556,0,6648,6647,1,
  	0,0,0,6648,6649,1,0,0,0,6649,809,1,0,0,0,6650,6654,3,812,406,0,6651,6654,
  	3,814,407,0,6652,6654,3,816,408,0,6653,6650,1,0,0,0,6653,6651,1,0,0,0,
  	6653,6652,1,0,0,0,6654,811,1,0,0,0,6655,6656,5,294,0,0,6656,6657,3,794,
  	397,0,6657,6658,5,159,0,0,6658,6659,5,294,0,0,6659,813,1,0,0,0,6660,6661,
  	5,644,0,0,6661,6662,3,676,338,0,6662,6663,5,147,0,0,6663,6664,3,794,397,
  	0,6664,6665,5,159,0,0,6665,6666,5,644,0,0,6666,815,1,0,0,0,6667,6668,
  	5,457,0,0,6668,6669,3,794,397,0,6669,6670,5,613,0,0,6670,6671,3,676,338,
  	0,6671,6672,5,159,0,0,6672,6673,5,457,0,0,6673,817,1,0,0,0,6674,6675,
  	3,820,410,0,6675,6676,5,774,0,0,6676,6678,1,0,0,0,6677,6674,1,0,0,0,6678,
  	6679,1,0,0,0,6679,6677,1,0,0,0,6679,6680,1,0,0,0,6680,819,1,0,0,0,6681,
  	6686,3,822,411,0,6682,6686,3,824,412,0,6683,6686,3,830,415,0,6684,6686,
  	3,834,417,0,6685,6681,1,0,0,0,6685,6682,1,0,0,0,6685,6683,1,0,0,0,6685,
  	6684,1,0,0,0,6686,821,1,0,0,0,6687,6688,5,127,0,0,6688,6689,3,1130,565,
  	0,6689,6691,3,916,458,0,6690,6692,3,986,493,0,6691,6690,1,0,0,0,6691,
  	6692,1,0,0,0,6692,6695,1,0,0,0,6693,6694,5,128,0,0,6694,6696,3,676,338,
  	0,6695,6693,1,0,0,0,6695,6696,1,0,0,0,6696,823,1,0,0,0,6697,6698,5,127,
  	0,0,6698,6699,3,1128,564,0,6699,6700,5,83,0,0,6700,6701,5,200,0,0,6701,
  	6702,3,826,413,0,6702,825,1,0,0,0,6703,6706,3,1140,570,0,6704,6706,3,
  	828,414,0,6705,6703,1,0,0,0,6705,6704,1,0,0,0,6706,827,1,0,0,0,6707,6709,
  	5,526,0,0,6708,6710,5,627,0,0,6709,6708,1,0,0,0,6709,6710,1,0,0,0,6710,
  	6711,1,0,0,0,6711,6712,3,1160,580,0,6712,829,1,0,0,0,6713,6714,5,127,
  	0,0,6714,6715,7,100,0,0,6715,6716,5,219,0,0,6716,6717,5,200,0,0,6717,
  	6722,3,832,416,0,6718,6719,5,773,0,0,6719,6721,3,832,416,0,6720,6718,
  	1,0,0,0,6721,6724,1,0,0,0,6722,6720,1,0,0,0,6722,6723,1,0,0,0,6723,6725,
  	1,0,0,0,6724,6722,1,0,0,0,6725,6726,3,784,392,0,6726,831,1,0,0,0,6727,
  	6735,3,826,413,0,6728,6735,3,1128,564,0,6729,6735,5,527,0,0,6730,6731,
  	3,760,380,0,6731,6732,5,202,0,0,6732,6735,1,0,0,0,6733,6735,5,525,0,0,
  	6734,6727,1,0,0,0,6734,6728,1,0,0,0,6734,6729,1,0,0,0,6734,6730,1,0,0,
  	0,6734,6733,1,0,0,0,6735,833,1,0,0,0,6736,6737,5,127,0,0,6737,6738,3,
  	1128,564,0,6738,6739,5,106,0,0,6739,6740,5,200,0,0,6740,6741,3,266,133,
  	0,6741,835,1,0,0,0,6742,6743,5,260,0,0,6743,6744,3,1112,556,0,6744,837,
  	1,0,0,0,6745,6746,5,271,0,0,6746,6747,3,1112,556,0,6747,839,1,0,0,0,6748,
  	6752,5,207,0,0,6749,6753,5,101,0,0,6750,6751,4,420,177,0,6751,6753,5,
  	540,0,0,6752,6749,1,0,0,0,6752,6750,1,0,0,0,6752,6753,1,0,0,0,6753,6754,
  	1,0,0,0,6754,6773,5,138,0,0,6755,6760,3,844,422,0,6756,6757,5,773,0,0,
  	6757,6759,3,844,422,0,6758,6756,1,0,0,0,6759,6762,1,0,0,0,6760,6758,1,
  	0,0,0,6760,6761,1,0,0,0,6761,6774,1,0,0,0,6762,6760,1,0,0,0,6763,6764,
  	5,83,0,0,6764,6765,3,842,421,0,6765,6770,3,846,423,0,6766,6767,5,773,
  	0,0,6767,6769,3,846,423,0,6768,6766,1,0,0,0,6769,6772,1,0,0,0,6770,6768,
  	1,0,0,0,6770,6771,1,0,0,0,6771,6774,1,0,0,0,6772,6770,1,0,0,0,6773,6755,
  	1,0,0,0,6773,6763,1,0,0,0,6774,841,1,0,0,0,6775,6779,3,1148,574,0,6776,
  	6779,3,740,370,0,6777,6779,3,1134,567,0,6778,6775,1,0,0,0,6778,6776,1,
  	0,0,0,6778,6777,1,0,0,0,6779,843,1,0,0,0,6780,6783,3,740,370,0,6781,6783,
  	3,1128,564,0,6782,6780,1,0,0,0,6782,6781,1,0,0,0,6783,6784,1,0,0,0,6784,
  	6785,5,750,0,0,6785,6786,7,101,0,0,6786,845,1,0,0,0,6787,6790,3,740,370,
  	0,6788,6790,3,1128,564,0,6789,6787,1,0,0,0,6789,6788,1,0,0,0,6790,6791,
  	1,0,0,0,6791,6794,5,750,0,0,6792,6795,3,848,424,0,6793,6795,5,473,0,0,
  	6794,6792,1,0,0,0,6794,6793,1,0,0,0,6795,847,1,0,0,0,6796,6797,7,102,
  	0,0,6797,849,1,0,0,0,6798,6801,5,511,0,0,6799,6802,3,1128,564,0,6800,
  	6802,3,828,414,0,6801,6799,1,0,0,0,6801,6800,1,0,0,0,6802,6812,1,0,0,
  	0,6803,6804,5,506,0,0,6804,6809,3,854,427,0,6805,6806,5,773,0,0,6806,
  	6808,3,854,427,0,6807,6805,1,0,0,0,6808,6811,1,0,0,0,6809,6807,1,0,0,
  	0,6809,6810,1,0,0,0,6810,6813,1,0,0,0,6811,6809,1,0,0,0,6812,6803,1,0,
  	0,0,6812,6813,1,0,0,0,6813,851,1,0,0,0,6814,6817,5,469,0,0,6815,6818,
  	3,1128,564,0,6816,6818,3,828,414,0,6817,6815,1,0,0,0,6817,6816,1,0,0,
  	0,6817,6818,1,0,0,0,6818,6828,1,0,0,0,6819,6820,5,506,0,0,6820,6825,3,
  	854,427,0,6821,6822,5,773,0,0,6822,6824,3,854,427,0,6823,6821,1,0,0,0,
  	6824,6827,1,0,0,0,6825,6823,1,0,0,0,6825,6826,1,0,0,0,6826,6829,1,0,0,
  	0,6827,6825,1,0,0,0,6828,6819,1,0,0,0,6828,6829,1,0,0,0,6829,853,1,0,
  	0,0,6830,6831,3,848,424,0,6831,6832,5,750,0,0,6832,6833,3,842,421,0,6833,
  	855,1,0,0,0,6834,6835,5,387,0,0,6835,6836,3,1128,564,0,6836,857,1,0,0,
  	0,6837,6838,5,66,0,0,6838,6839,3,1128,564,0,6839,859,1,0,0,0,6840,6845,
  	5,186,0,0,6841,6843,5,367,0,0,6842,6841,1,0,0,0,6842,6843,1,0,0,0,6843,
  	6844,1,0,0,0,6844,6846,5,203,0,0,6845,6842,1,0,0,0,6845,6846,1,0,0,0,
  	6846,6847,1,0,0,0,6847,6848,3,1128,564,0,6848,6849,5,248,0,0,6849,6850,
  	3,1130,565,0,6850,861,1,0,0,0,6851,6852,5,21,0,0,6852,6865,3,676,338,
  	0,6853,6854,5,171,0,0,6854,6855,3,676,338,0,6855,6858,3,764,382,0,6856,
  	6857,5,542,0,0,6857,6859,3,676,338,0,6858,6856,1,0,0,0,6858,6859,1,0,
  	0,0,6859,6862,1,0,0,0,6860,6861,5,160,0,0,6861,6863,3,676,338,0,6862,
  	6860,1,0,0,0,6862,6863,1,0,0,0,6863,6865,1,0,0,0,6864,6851,1,0,0,0,6864,
  	6853,1,0,0,0,6865,863,1,0,0,0,6866,6867,3,1040,520,0,6867,6869,3,876,
  	438,0,6868,6870,3,866,433,0,6869,6868,1,0,0,0,6869,6870,1,0,0,0,6870,
  	865,1,0,0,0,6871,6872,4,433,178,0,6872,6875,3,868,434,0,6873,6875,3,886,
  	443,0,6874,6871,1,0,0,0,6874,6873,1,0,0,0,6875,867,1,0,0,0,6876,6877,
  	5,62,0,0,6877,6878,3,770,385,0,6878,869,1,0,0,0,6879,6881,5,371,0,0,6880,
  	6879,1,0,0,0,6880,6881,1,0,0,0,6881,6882,1,0,0,0,6882,6883,5,730,0,0,
  	6883,871,1,0,0,0,6884,6886,7,38,0,0,6885,6887,3,108,54,0,6886,6885,1,
  	0,0,0,6886,6887,1,0,0,0,6887,6888,1,0,0,0,6888,6892,3,898,449,0,6889,
  	6891,3,902,451,0,6890,6889,1,0,0,0,6891,6894,1,0,0,0,6892,6890,1,0,0,
  	0,6892,6893,1,0,0,0,6893,6960,1,0,0,0,6894,6892,1,0,0,0,6895,6897,5,205,
  	0,0,6896,6898,3,406,203,0,6897,6896,1,0,0,0,6897,6898,1,0,0,0,6898,6900,
  	1,0,0,0,6899,6901,3,1050,525,0,6900,6899,1,0,0,0,6900,6901,1,0,0,0,6901,
  	6902,1,0,0,0,6902,6906,3,898,449,0,6903,6905,3,910,455,0,6904,6903,1,
  	0,0,0,6905,6908,1,0,0,0,6906,6904,1,0,0,0,6906,6907,1,0,0,0,6907,6960,
  	1,0,0,0,6908,6906,1,0,0,0,6909,6911,5,523,0,0,6910,6912,3,406,203,0,6911,
  	6910,1,0,0,0,6911,6912,1,0,0,0,6912,6914,1,0,0,0,6913,6915,3,1050,525,
  	0,6914,6913,1,0,0,0,6914,6915,1,0,0,0,6915,6916,1,0,0,0,6916,6920,3,898,
  	449,0,6917,6919,3,912,456,0,6918,6917,1,0,0,0,6919,6922,1,0,0,0,6920,
  	6918,1,0,0,0,6920,6921,1,0,0,0,6921,6960,1,0,0,0,6922,6920,1,0,0,0,6923,
  	6925,3,874,437,0,6924,6923,1,0,0,0,6924,6925,1,0,0,0,6925,6957,1,0,0,
  	0,6926,6927,5,420,0,0,6927,6933,5,265,0,0,6928,6930,5,609,0,0,6929,6931,
  	3,406,203,0,6930,6929,1,0,0,0,6930,6931,1,0,0,0,6931,6933,1,0,0,0,6932,
  	6926,1,0,0,0,6932,6928,1,0,0,0,6933,6935,1,0,0,0,6934,6936,3,108,54,0,
  	6935,6934,1,0,0,0,6935,6936,1,0,0,0,6936,6937,1,0,0,0,6937,6941,3,898,
  	449,0,6938,6940,3,902,451,0,6939,6938,1,0,0,0,6940,6943,1,0,0,0,6941,
  	6939,1,0,0,0,6941,6942,1,0,0,0,6942,6958,1,0,0,0,6943,6941,1,0,0,0,6944,
  	6945,5,199,0,0,6945,6947,5,265,0,0,6946,6948,3,1050,525,0,6947,6946,1,
  	0,0,0,6947,6948,1,0,0,0,6948,6949,1,0,0,0,6949,6950,3,890,445,0,6950,
  	6951,3,886,443,0,6951,6958,1,0,0,0,6952,6955,3,868,434,0,6953,6954,4,
  	436,179,0,6954,6956,3,870,435,0,6955,6953,1,0,0,0,6955,6956,1,0,0,0,6956,
  	6958,1,0,0,0,6957,6932,1,0,0,0,6957,6944,1,0,0,0,6957,6952,1,0,0,0,6958,
  	6960,1,0,0,0,6959,6884,1,0,0,0,6959,6895,1,0,0,0,6959,6909,1,0,0,0,6959,
  	6924,1,0,0,0,6960,873,1,0,0,0,6961,6963,5,86,0,0,6962,6964,3,1128,564,
  	0,6963,6962,1,0,0,0,6963,6964,1,0,0,0,6964,875,1,0,0,0,6965,7001,3,916,
  	458,0,6966,6968,3,878,439,0,6967,6966,1,0,0,0,6968,6971,1,0,0,0,6969,
  	6967,1,0,0,0,6969,6970,1,0,0,0,6970,7002,1,0,0,0,6971,6969,1,0,0,0,6972,
  	6974,4,438,180,0,6973,6975,3,986,493,0,6974,6973,1,0,0,0,6974,6975,1,
  	0,0,0,6975,6978,1,0,0,0,6976,6977,5,209,0,0,6977,6979,5,12,0,0,6978,6976,
  	1,0,0,0,6978,6979,1,0,0,0,6979,6980,1,0,0,0,6980,6981,5,17,0,0,6981,6983,
  	3,770,385,0,6982,6984,7,103,0,0,6983,6982,1,0,0,0,6983,6984,1,0,0,0,6984,
  	6999,1,0,0,0,6985,6989,4,438,181,0,6986,6988,3,884,442,0,6987,6986,1,
  	0,0,0,6988,6991,1,0,0,0,6989,6987,1,0,0,0,6989,6990,1,0,0,0,6990,7000,
  	1,0,0,0,6991,6989,1,0,0,0,6992,6996,4,438,182,0,6993,6995,3,878,439,0,
  	6994,6993,1,0,0,0,6995,6998,1,0,0,0,6996,6994,1,0,0,0,6996,6997,1,0,0,
  	0,6997,7000,1,0,0,0,6998,6996,1,0,0,0,6999,6985,1,0,0,0,6999,6992,1,0,
  	0,0,7000,7002,1,0,0,0,7001,6969,1,0,0,0,7001,6972,1,0,0,0,7002,877,1,
  	0,0,0,7003,7005,5,371,0,0,7004,7003,1,0,0,0,7004,7005,1,0,0,0,7005,7006,
  	1,0,0,0,7006,7056,3,1170,585,0,7007,7008,4,439,183,0,7008,7009,5,371,
  	0,0,7009,7056,5,720,0,0,7010,7018,5,128,0,0,7011,7019,3,1150,575,0,7012,
  	7014,5,372,0,0,7013,7015,3,720,360,0,7014,7013,1,0,0,0,7014,7015,1,0,
  	0,0,7015,7019,1,0,0,0,7016,7017,4,439,184,0,7017,7019,3,770,385,0,7018,
  	7011,1,0,0,0,7018,7012,1,0,0,0,7018,7016,1,0,0,0,7019,7056,1,0,0,0,7020,
  	7021,5,383,0,0,7021,7022,5,614,0,0,7022,7024,5,372,0,0,7023,7025,3,720,
  	360,0,7024,7023,1,0,0,0,7024,7025,1,0,0,0,7025,7056,1,0,0,0,7026,7056,
  	5,24,0,0,7027,7028,5,501,0,0,7028,7029,5,128,0,0,7029,7056,5,627,0,0,
  	7030,7032,5,420,0,0,7031,7030,1,0,0,0,7031,7032,1,0,0,0,7032,7033,1,0,
  	0,0,7033,7056,5,265,0,0,7034,7036,5,609,0,0,7035,7037,5,265,0,0,7036,
  	7035,1,0,0,0,7036,7037,1,0,0,0,7037,7056,1,0,0,0,7038,7039,5,75,0,0,7039,
  	7056,3,1160,580,0,7040,7056,3,986,493,0,7041,7042,5,74,0,0,7042,7056,
  	3,880,440,0,7043,7044,5,553,0,0,7044,7056,3,882,441,0,7045,7046,4,439,
  	185,0,7046,7047,5,707,0,0,7047,7056,3,1146,573,0,7048,7050,4,439,186,
  	0,7049,7051,3,874,437,0,7050,7049,1,0,0,0,7050,7051,1,0,0,0,7051,7052,
  	1,0,0,0,7052,7056,3,868,434,0,7053,7054,4,439,187,0,7054,7056,3,870,435,
  	0,7055,7004,1,0,0,0,7055,7007,1,0,0,0,7055,7010,1,0,0,0,7055,7020,1,0,
  	0,0,7055,7026,1,0,0,0,7055,7027,1,0,0,0,7055,7031,1,0,0,0,7055,7034,1,
  	0,0,0,7055,7038,1,0,0,0,7055,7040,1,0,0,0,7055,7041,1,0,0,0,7055,7043,
  	1,0,0,0,7055,7045,1,0,0,0,7055,7048,1,0,0,0,7055,7053,1,0,0,0,7056,879,
  	1,0,0,0,7057,7058,7,104,0,0,7058,881,1,0,0,0,7059,7060,7,105,0,0,7060,
  	883,1,0,0,0,7061,7063,5,609,0,0,7062,7064,5,265,0,0,7063,7062,1,0,0,0,
  	7063,7064,1,0,0,0,7064,7076,1,0,0,0,7065,7066,5,75,0,0,7066,7076,3,1156,
  	578,0,7067,7069,3,760,380,0,7068,7067,1,0,0,0,7068,7069,1,0,0,0,7069,
  	7070,1,0,0,0,7070,7076,5,376,0,0,7071,7073,5,420,0,0,7072,7071,1,0,0,
  	0,7072,7073,1,0,0,0,7073,7074,1,0,0,0,7074,7076,5,265,0,0,7075,7061,1,
  	0,0,0,7075,7065,1,0,0,0,7075,7068,1,0,0,0,7075,7072,1,0,0,0,7076,885,
  	1,0,0,0,7077,7078,5,443,0,0,7078,7080,3,1102,551,0,7079,7081,3,1132,566,
  	0,7080,7079,1,0,0,0,7080,7081,1,0,0,0,7081,7084,1,0,0,0,7082,7083,5,320,
  	0,0,7083,7085,7,106,0,0,7084,7082,1,0,0,0,7084,7085,1,0,0,0,7085,7102,
  	1,0,0,0,7086,7087,5,383,0,0,7087,7088,5,614,0,0,7088,7092,3,888,444,0,
  	7089,7090,5,383,0,0,7090,7091,5,133,0,0,7091,7093,3,888,444,0,7092,7089,
  	1,0,0,0,7092,7093,1,0,0,0,7093,7103,1,0,0,0,7094,7095,5,383,0,0,7095,
  	7096,5,133,0,0,7096,7100,3,888,444,0,7097,7098,5,383,0,0,7098,7099,5,
  	614,0,0,7099,7101,3,888,444,0,7100,7097,1,0,0,0,7100,7101,1,0,0,0,7101,
  	7103,1,0,0,0,7102,7086,1,0,0,0,7102,7094,1,0,0,0,7102,7103,1,0,0,0,7103,
  	887,1,0,0,0,7104,7110,7,2,0,0,7105,7106,5,506,0,0,7106,7110,3,1170,585,
  	0,7107,7108,5,373,0,0,7108,7110,5,3,0,0,7109,7104,1,0,0,0,7109,7105,1,
  	0,0,0,7109,7107,1,0,0,0,7110,889,1,0,0,0,7111,7112,5,776,0,0,7112,7117,
  	3,892,446,0,7113,7114,5,773,0,0,7114,7116,3,892,446,0,7115,7113,1,0,0,
  	0,7116,7119,1,0,0,0,7117,7115,1,0,0,0,7117,7118,1,0,0,0,7118,7120,1,0,
  	0,0,7119,7117,1,0,0,0,7120,7121,5,777,0,0,7121,891,1,0,0,0,7122,7124,
  	3,1128,564,0,7123,7125,3,922,461,0,7124,7123,1,0,0,0,7124,7125,1,0,0,
  	0,7125,7127,1,0,0,0,7126,7128,3,330,165,0,7127,7126,1,0,0,0,7127,7128,
  	1,0,0,0,7128,893,1,0,0,0,7129,7130,5,776,0,0,7130,7135,3,896,448,0,7131,
  	7132,5,773,0,0,7132,7134,3,896,448,0,7133,7131,1,0,0,0,7134,7137,1,0,
  	0,0,7135,7133,1,0,0,0,7135,7136,1,0,0,0,7136,7138,1,0,0,0,7137,7135,1,
  	0,0,0,7138,7139,5,777,0,0,7139,895,1,0,0,0,7140,7146,3,892,446,0,7141,
  	7143,3,770,385,0,7142,7144,3,330,165,0,7143,7142,1,0,0,0,7143,7144,1,
  	0,0,0,7144,7146,1,0,0,0,7145,7140,1,0,0,0,7145,7141,1,0,0,0,7146,897,
  	1,0,0,0,7147,7148,4,449,188,0,7148,7152,3,894,447,0,7149,7150,4,449,189,
  	0,7150,7152,3,890,445,0,7151,7147,1,0,0,0,7151,7149,1,0,0,0,7152,899,
  	1,0,0,0,7153,7154,7,107,0,0,7154,901,1,0,0,0,7155,7158,3,904,452,0,7156,
  	7158,3,908,454,0,7157,7155,1,0,0,0,7157,7156,1,0,0,0,7158,903,1,0,0,0,
  	7159,7161,5,264,0,0,7160,7162,5,750,0,0,7161,7160,1,0,0,0,7161,7162,1,
  	0,0,0,7162,7163,1,0,0,0,7163,7169,3,1140,570,0,7164,7165,5,75,0,0,7165,
  	7169,3,1160,580,0,7166,7167,4,452,190,0,7167,7169,3,906,453,0,7168,7159,
  	1,0,0,0,7168,7164,1,0,0,0,7168,7166,1,0,0,0,7169,905,1,0,0,0,7170,7171,
  	7,108,0,0,7171,907,1,0,0,0,7172,7173,7,109,0,0,7173,7174,3,900,450,0,
  	7174,909,1,0,0,0,7175,7180,3,904,452,0,7176,7177,5,645,0,0,7177,7178,
  	5,401,0,0,7178,7180,3,1128,564,0,7179,7175,1,0,0,0,7179,7176,1,0,0,0,
  	7180,911,1,0,0,0,7181,7182,3,904,452,0,7182,913,1,0,0,0,7183,7184,3,916,
  	458,0,7184,7185,5,0,0,1,7185,915,1,0,0,0,7186,7188,7,110,0,0,7187,7189,
  	3,922,461,0,7188,7187,1,0,0,0,7188,7189,1,0,0,0,7189,7191,1,0,0,0,7190,
  	7192,3,924,462,0,7191,7190,1,0,0,0,7191,7192,1,0,0,0,7192,7334,1,0,0,
  	0,7193,7199,5,437,0,0,7194,7196,5,146,0,0,7195,7197,5,416,0,0,7196,7195,
  	1,0,0,0,7196,7197,1,0,0,0,7197,7199,1,0,0,0,7198,7193,1,0,0,0,7198,7194,
  	1,0,0,0,7199,7201,1,0,0,0,7200,7202,3,1178,589,0,7201,7200,1,0,0,0,7201,
  	7202,1,0,0,0,7202,7204,1,0,0,0,7203,7205,3,924,462,0,7204,7203,1,0,0,
  	0,7204,7205,1,0,0,0,7205,7334,1,0,0,0,7206,7208,7,111,0,0,7207,7209,3,
  	1174,587,0,7208,7207,1,0,0,0,7208,7209,1,0,0,0,7209,7211,1,0,0,0,7210,
  	7212,3,924,462,0,7211,7210,1,0,0,0,7211,7212,1,0,0,0,7212,7334,1,0,0,
  	0,7213,7215,5,37,0,0,7214,7216,3,922,461,0,7215,7214,1,0,0,0,7215,7216,
  	1,0,0,0,7216,7334,1,0,0,0,7217,7334,7,112,0,0,7218,7220,5,60,0,0,7219,
  	7221,3,922,461,0,7220,7219,1,0,0,0,7220,7221,1,0,0,0,7221,7223,1,0,0,
  	0,7222,7224,3,926,463,0,7223,7222,1,0,0,0,7223,7224,1,0,0,0,7224,7334,
  	1,0,0,0,7225,7227,3,918,459,0,7226,7228,3,922,461,0,7227,7226,1,0,0,0,
  	7227,7228,1,0,0,0,7228,7230,1,0,0,0,7229,7231,5,32,0,0,7230,7229,1,0,
  	0,0,7230,7231,1,0,0,0,7231,7334,1,0,0,0,7232,7234,5,32,0,0,7233,7235,
  	3,922,461,0,7234,7233,1,0,0,0,7234,7235,1,0,0,0,7235,7334,1,0,0,0,7236,
  	7237,5,60,0,0,7237,7240,5,633,0,0,7238,7240,5,629,0,0,7239,7236,1,0,0,
  	0,7239,7238,1,0,0,0,7240,7241,1,0,0,0,7241,7243,3,922,461,0,7242,7244,
  	3,926,463,0,7243,7242,1,0,0,0,7243,7244,1,0,0,0,7244,7334,1,0,0,0,7245,
  	7246,5,358,0,0,7246,7256,5,629,0,0,7247,7256,5,379,0,0,7248,7249,5,361,
  	0,0,7249,7256,5,629,0,0,7250,7251,5,358,0,0,7251,7252,5,60,0,0,7252,7256,
  	5,633,0,0,7253,7254,5,361,0,0,7254,7256,5,633,0,0,7255,7245,1,0,0,0,7255,
  	7247,1,0,0,0,7255,7248,1,0,0,0,7255,7250,1,0,0,0,7255,7253,1,0,0,0,7256,
  	7257,1,0,0,0,7257,7259,3,922,461,0,7258,7260,5,32,0,0,7259,7258,1,0,0,
  	0,7259,7260,1,0,0,0,7260,7334,1,0,0,0,7261,7262,5,628,0,0,7262,7334,3,
  	922,461,0,7263,7265,5,656,0,0,7264,7266,3,922,461,0,7265,7264,1,0,0,0,
  	7265,7266,1,0,0,0,7266,7268,1,0,0,0,7267,7269,3,924,462,0,7268,7267,1,
  	0,0,0,7268,7269,1,0,0,0,7269,7334,1,0,0,0,7270,7334,5,116,0,0,7271,7273,
  	5,586,0,0,7272,7274,3,934,467,0,7273,7272,1,0,0,0,7273,7274,1,0,0,0,7274,
  	7334,1,0,0,0,7275,7277,5,583,0,0,7276,7278,3,934,467,0,7277,7276,1,0,
  	0,0,7277,7278,1,0,0,0,7278,7334,1,0,0,0,7279,7281,5,113,0,0,7280,7282,
  	3,934,467,0,7281,7280,1,0,0,0,7281,7282,1,0,0,0,7282,7334,1,0,0,0,7283,
  	7334,5,587,0,0,7284,7286,5,39,0,0,7285,7287,3,922,461,0,7286,7285,1,0,
  	0,0,7286,7287,1,0,0,0,7287,7334,1,0,0,0,7288,7334,7,113,0,0,7289,7290,
  	5,293,0,0,7290,7334,5,628,0,0,7291,7295,5,293,0,0,7292,7293,5,60,0,0,
  	7293,7296,5,633,0,0,7294,7296,5,629,0,0,7295,7292,1,0,0,0,7295,7294,1,
  	0,0,0,7295,7296,1,0,0,0,7296,7298,1,0,0,0,7297,7299,3,926,463,0,7298,
  	7297,1,0,0,0,7298,7299,1,0,0,0,7299,7334,1,0,0,0,7300,7302,5,589,0,0,
  	7301,7303,3,926,463,0,7302,7301,1,0,0,0,7302,7303,1,0,0,0,7303,7334,1,
  	0,0,0,7304,7306,5,580,0,0,7305,7307,3,922,461,0,7306,7305,1,0,0,0,7306,
  	7307,1,0,0,0,7307,7309,1,0,0,0,7308,7310,3,926,463,0,7309,7308,1,0,0,
  	0,7309,7310,1,0,0,0,7310,7334,1,0,0,0,7311,7313,5,332,0,0,7312,7314,3,
  	926,463,0,7313,7312,1,0,0,0,7313,7314,1,0,0,0,7314,7334,1,0,0,0,7315,
  	7317,5,291,0,0,7316,7318,3,926,463,0,7317,7316,1,0,0,0,7317,7318,1,0,
  	0,0,7318,7334,1,0,0,0,7319,7320,5,164,0,0,7320,7322,3,1152,576,0,7321,
  	7323,3,926,463,0,7322,7321,1,0,0,0,7322,7323,1,0,0,0,7323,7334,1,0,0,
  	0,7324,7325,5,506,0,0,7325,7327,3,1152,576,0,7326,7328,3,926,463,0,7327,
  	7326,1,0,0,0,7327,7328,1,0,0,0,7328,7334,1,0,0,0,7329,7334,5,501,0,0,
  	7330,7331,4,458,191,0,7331,7334,5,262,0,0,7332,7334,7,114,0,0,7333,7186,
  	1,0,0,0,7333,7198,1,0,0,0,7333,7206,1,0,0,0,7333,7213,1,0,0,0,7333,7217,
  	1,0,0,0,7333,7218,1,0,0,0,7333,7225,1,0,0,0,7333,7232,1,0,0,0,7333,7239,
  	1,0,0,0,7333,7255,1,0,0,0,7333,7261,1,0,0,0,7333,7263,1,0,0,0,7333,7270,
  	1,0,0,0,7333,7271,1,0,0,0,7333,7275,1,0,0,0,7333,7279,1,0,0,0,7333,7283,
  	1,0,0,0,7333,7284,1,0,0,0,7333,7288,1,0,0,0,7333,7289,1,0,0,0,7333,7291,
  	1,0,0,0,7333,7300,1,0,0,0,7333,7304,1,0,0,0,7333,7311,1,0,0,0,7333,7315,
  	1,0,0,0,7333,7319,1,0,0,0,7333,7324,1,0,0,0,7333,7329,1,0,0,0,7333,7330,
  	1,0,0,0,7333,7332,1,0,0,0,7334,917,1,0,0,0,7335,7339,5,361,0,0,7336,7337,
  	5,358,0,0,7337,7339,5,60,0,0,7338,7335,1,0,0,0,7338,7336,1,0,0,0,7339,
  	919,1,0,0,0,7340,7346,5,437,0,0,7341,7343,5,146,0,0,7342,7344,5,416,0,
  	0,7343,7342,1,0,0,0,7343,7344,1,0,0,0,7344,7346,1,0,0,0,7345,7340,1,0,
  	0,0,7345,7341,1,0,0,0,7346,921,1,0,0,0,7347,7350,5,776,0,0,7348,7351,
  	3,1146,573,0,7349,7351,5,790,0,0,7350,7348,1,0,0,0,7350,7349,1,0,0,0,
  	7351,7352,1,0,0,0,7352,7353,5,777,0,0,7353,923,1,0,0,0,7354,7356,7,115,
  	0,0,7355,7354,1,0,0,0,7356,7357,1,0,0,0,7357,7355,1,0,0,0,7357,7358,1,
  	0,0,0,7358,925,1,0,0,0,7359,7374,3,928,464,0,7360,7374,3,930,465,0,7361,
  	7374,5,46,0,0,7362,7363,3,758,379,0,7363,7365,3,936,468,0,7364,7366,5,
  	32,0,0,7365,7364,1,0,0,0,7365,7366,1,0,0,0,7366,7374,1,0,0,0,7367,7371,
  	5,32,0,0,7368,7369,3,758,379,0,7369,7370,3,936,468,0,7370,7372,1,0,0,
  	0,7371,7368,1,0,0,0,7371,7372,1,0,0,0,7372,7374,1,0,0,0,7373,7359,1,0,
  	0,0,7373,7360,1,0,0,0,7373,7361,1,0,0,0,7373,7362,1,0,0,0,7373,7367,1,
  	0,0,0,7374,927,1,0,0,0,7375,7377,5,19,0,0,7376,7378,5,32,0,0,7377,7376,
  	1,0,0,0,7377,7378,1,0,0,0,7378,7382,1,0,0,0,7379,7380,5,32,0,0,7380,7382,
  	5,19,0,0,7381,7375,1,0,0,0,7381,7379,1,0,0,0,7382,929,1,0,0,0,7383,7385,
  	5,606,0,0,7384,7386,5,32,0,0,7385,7384,1,0,0,0,7385,7386,1,0,0,0,7386,
  	7390,1,0,0,0,7387,7388,5,32,0,0,7388,7390,5,606,0,0,7389,7383,1,0,0,0,
  	7389,7387,1,0,0,0,7390,931,1,0,0,0,7391,7392,5,776,0,0,7392,7393,3,1142,
  	571,0,7393,7394,5,777,0,0,7394,933,1,0,0,0,7395,7396,5,776,0,0,7396,7397,
  	5,747,0,0,7397,7398,5,777,0,0,7398,935,1,0,0,0,7399,7404,3,1180,590,0,
  	7400,7404,5,32,0,0,7401,7402,4,468,192,0,7402,7404,5,128,0,0,7403,7399,
  	1,0,0,0,7403,7400,1,0,0,0,7403,7401,1,0,0,0,7404,937,1,0,0,0,7405,7411,
  	3,1180,590,0,7406,7407,4,469,193,0,7407,7411,5,128,0,0,7408,7409,4,469,
  	194,0,7409,7411,5,32,0,0,7410,7405,1,0,0,0,7410,7406,1,0,0,0,7410,7408,
  	1,0,0,0,7411,939,1,0,0,0,7412,7419,3,944,472,0,7413,7415,5,773,0,0,7414,
  	7413,1,0,0,0,7414,7415,1,0,0,0,7415,7416,1,0,0,0,7416,7418,3,944,472,
  	0,7417,7414,1,0,0,0,7418,7421,1,0,0,0,7419,7417,1,0,0,0,7419,7420,1,0,
  	0,0,7420,941,1,0,0,0,7421,7419,1,0,0,0,7422,7424,3,944,472,0,7423,7422,
  	1,0,0,0,7424,7425,1,0,0,0,7425,7423,1,0,0,0,7425,7426,1,0,0,0,7426,943,
  	1,0,0,0,7427,7429,5,163,0,0,7428,7430,5,750,0,0,7429,7428,1,0,0,0,7429,
  	7430,1,0,0,0,7430,7431,1,0,0,0,7431,7557,3,1094,547,0,7432,7433,4,472,
  	195,0,7433,7435,5,721,0,0,7434,7436,3,1190,595,0,7435,7434,1,0,0,0,7435,
  	7436,1,0,0,0,7436,7439,1,0,0,0,7437,7440,5,376,0,0,7438,7440,3,1180,590,
  	0,7439,7437,1,0,0,0,7439,7438,1,0,0,0,7440,7557,1,0,0,0,7441,7443,5,323,
  	0,0,7442,7444,5,750,0,0,7443,7442,1,0,0,0,7443,7444,1,0,0,0,7444,7445,
  	1,0,0,0,7445,7557,3,1144,572,0,7446,7448,5,344,0,0,7447,7449,5,750,0,
  	0,7448,7447,1,0,0,0,7448,7449,1,0,0,0,7449,7450,1,0,0,0,7450,7557,3,1144,
  	572,0,7451,7453,5,25,0,0,7452,7454,5,750,0,0,7453,7452,1,0,0,0,7453,7454,
  	1,0,0,0,7454,7455,1,0,0,0,7455,7557,3,1140,570,0,7456,7458,5,406,0,0,
  	7457,7459,5,750,0,0,7458,7457,1,0,0,0,7458,7459,1,0,0,0,7459,7460,1,0,
  	0,0,7460,7557,3,1154,577,0,7461,7463,5,75,0,0,7462,7464,5,750,0,0,7463,
  	7462,1,0,0,0,7463,7464,1,0,0,0,7464,7465,1,0,0,0,7465,7557,3,1154,577,
  	0,7466,7467,4,472,196,0,7467,7469,5,81,0,0,7468,7470,5,750,0,0,7469,7468,
  	1,0,0,0,7469,7470,1,0,0,0,7470,7471,1,0,0,0,7471,7557,3,1156,578,0,7472,
  	7473,4,472,197,0,7473,7475,5,158,0,0,7474,7476,5,750,0,0,7475,7474,1,
  	0,0,0,7475,7476,1,0,0,0,7476,7477,1,0,0,0,7477,7557,3,1156,578,0,7478,
  	7480,5,24,0,0,7479,7481,5,750,0,0,7480,7479,1,0,0,0,7480,7481,1,0,0,0,
  	7481,7482,1,0,0,0,7482,7557,3,1144,572,0,7483,7485,5,399,0,0,7484,7486,
  	5,750,0,0,7485,7484,1,0,0,0,7485,7486,1,0,0,0,7486,7487,1,0,0,0,7487,
  	7557,3,946,473,0,7488,7490,7,116,0,0,7489,7491,5,750,0,0,7490,7489,1,
  	0,0,0,7490,7491,1,0,0,0,7491,7492,1,0,0,0,7492,7557,3,946,473,0,7493,
  	7495,7,117,0,0,7494,7496,5,750,0,0,7495,7494,1,0,0,0,7495,7496,1,0,0,
  	0,7496,7497,1,0,0,0,7497,7557,3,1140,570,0,7498,7500,5,132,0,0,7499,7501,
  	5,750,0,0,7500,7499,1,0,0,0,7500,7501,1,0,0,0,7501,7502,1,0,0,0,7502,
  	7557,3,1140,570,0,7503,7505,5,486,0,0,7504,7506,5,750,0,0,7505,7504,1,
  	0,0,0,7505,7506,1,0,0,0,7506,7507,1,0,0,0,7507,7557,7,118,0,0,7508,7510,
  	5,608,0,0,7509,7511,5,750,0,0,7510,7509,1,0,0,0,7510,7511,1,0,0,0,7511,
  	7512,1,0,0,0,7512,7513,5,776,0,0,7513,7514,3,1104,552,0,7514,7515,5,777,
  	0,0,7515,7557,1,0,0,0,7516,7557,3,952,476,0,7517,7557,3,948,474,0,7518,
  	7520,5,243,0,0,7519,7521,5,750,0,0,7520,7519,1,0,0,0,7520,7521,1,0,0,
  	0,7521,7522,1,0,0,0,7522,7557,7,119,0,0,7523,7524,5,112,0,0,7524,7526,
  	5,139,0,0,7525,7527,5,750,0,0,7526,7525,1,0,0,0,7526,7527,1,0,0,0,7527,
  	7528,1,0,0,0,7528,7557,3,1156,578,0,7529,7530,5,236,0,0,7530,7532,5,139,
  	0,0,7531,7533,5,750,0,0,7532,7531,1,0,0,0,7532,7533,1,0,0,0,7533,7534,
  	1,0,0,0,7534,7557,3,1156,578,0,7535,7541,5,572,0,0,7536,7538,4,472,198,
  	0,7537,7539,5,750,0,0,7538,7537,1,0,0,0,7538,7539,1,0,0,0,7539,7542,1,
  	0,0,0,7540,7542,1,0,0,0,7541,7536,1,0,0,0,7541,7540,1,0,0,0,7542,7543,
  	1,0,0,0,7543,7557,3,1128,564,0,7544,7545,5,553,0,0,7545,7557,7,120,0,
  	0,7546,7548,5,84,0,0,7547,7549,5,750,0,0,7548,7547,1,0,0,0,7548,7549,
  	1,0,0,0,7549,7550,1,0,0,0,7550,7557,3,1156,578,0,7551,7553,5,264,0,0,
  	7552,7554,5,750,0,0,7553,7552,1,0,0,0,7553,7554,1,0,0,0,7554,7555,1,0,
  	0,0,7555,7557,3,1140,570,0,7556,7427,1,0,0,0,7556,7432,1,0,0,0,7556,7441,
  	1,0,0,0,7556,7446,1,0,0,0,7556,7451,1,0,0,0,7556,7456,1,0,0,0,7556,7461,
  	1,0,0,0,7556,7466,1,0,0,0,7556,7472,1,0,0,0,7556,7478,1,0,0,0,7556,7483,
  	1,0,0,0,7556,7488,1,0,0,0,7556,7493,1,0,0,0,7556,7498,1,0,0,0,7556,7503,
  	1,0,0,0,7556,7508,1,0,0,0,7556,7516,1,0,0,0,7556,7517,1,0,0,0,7556,7518,
  	1,0,0,0,7556,7523,1,0,0,0,7556,7529,1,0,0,0,7556,7535,1,0,0,0,7556,7544,
  	1,0,0,0,7556,7546,1,0,0,0,7556,7551,1,0,0,0,7557,945,1,0,0,0,7558,7561,
  	3,1140,570,0,7559,7561,5,128,0,0,7560,7558,1,0,0,0,7560,7559,1,0,0,0,
  	7561,947,1,0,0,0,7562,7564,5,128,0,0,7563,7562,1,0,0,0,7563,7564,1,0,
  	0,0,7564,7565,1,0,0,0,7565,7567,5,69,0,0,7566,7568,5,750,0,0,7567,7566,
  	1,0,0,0,7567,7568,1,0,0,0,7568,7569,1,0,0,0,7569,7570,3,938,469,0,7570,
  	949,1,0,0,0,7571,7573,5,128,0,0,7572,7571,1,0,0,0,7572,7573,1,0,0,0,7573,
  	7574,1,0,0,0,7574,7576,5,158,0,0,7575,7577,5,750,0,0,7576,7575,1,0,0,
  	0,7576,7577,1,0,0,0,7577,7578,1,0,0,0,7578,7579,3,1154,577,0,7579,951,
  	1,0,0,0,7580,7582,5,128,0,0,7581,7580,1,0,0,0,7581,7582,1,0,0,0,7582,
  	7583,1,0,0,0,7583,7585,3,758,379,0,7584,7586,5,750,0,0,7585,7584,1,0,
  	0,0,7585,7586,1,0,0,0,7586,7587,1,0,0,0,7587,7588,3,936,468,0,7588,953,
  	1,0,0,0,7589,7590,5,405,0,0,7590,7591,5,45,0,0,7591,7594,3,956,478,0,
  	7592,7593,5,404,0,0,7593,7595,3,1142,571,0,7594,7592,1,0,0,0,7594,7595,
  	1,0,0,0,7595,7597,1,0,0,0,7596,7598,3,958,479,0,7597,7596,1,0,0,0,7597,
  	7598,1,0,0,0,7598,7600,1,0,0,0,7599,7601,3,962,481,0,7600,7599,1,0,0,
  	0,7600,7601,1,0,0,0,7601,955,1,0,0,0,7602,7604,5,277,0,0,7603,7602,1,
  	0,0,0,7603,7604,1,0,0,0,7604,7605,1,0,0,0,7605,7607,5,265,0,0,7606,7608,
  	3,960,480,0,7607,7606,1,0,0,0,7607,7608,1,0,0,0,7608,7609,1,0,0,0,7609,
  	7611,5,776,0,0,7610,7612,3,1130,565,0,7611,7610,1,0,0,0,7611,7612,1,0,
  	0,0,7612,7613,1,0,0,0,7613,7636,5,777,0,0,7614,7616,5,277,0,0,7615,7614,
  	1,0,0,0,7615,7616,1,0,0,0,7616,7617,1,0,0,0,7617,7618,5,220,0,0,7618,
  	7619,5,776,0,0,7619,7620,3,686,343,0,7620,7621,5,777,0,0,7621,7636,1,
  	0,0,0,7622,7633,7,121,0,0,7623,7624,5,776,0,0,7624,7625,3,686,343,0,7625,
  	7626,5,777,0,0,7626,7634,1,0,0,0,7627,7628,5,71,0,0,7628,7630,5,776,0,
  	0,7629,7631,3,1130,565,0,7630,7629,1,0,0,0,7630,7631,1,0,0,0,7631,7632,
  	1,0,0,0,7632,7634,5,777,0,0,7633,7623,1,0,0,0,7633,7627,1,0,0,0,7634,
  	7636,1,0,0,0,7635,7603,1,0,0,0,7635,7615,1,0,0,0,7635,7622,1,0,0,0,7636,
  	957,1,0,0,0,7637,7638,5,561,0,0,7638,7640,5,45,0,0,7639,7641,5,277,0,
  	0,7640,7639,1,0,0,0,7640,7641,1,0,0,0,7641,7652,1,0,0,0,7642,7643,5,220,
  	0,0,7643,7644,5,776,0,0,7644,7645,3,686,343,0,7645,7646,5,777,0,0,7646,
  	7653,1,0,0,0,7647,7649,5,265,0,0,7648,7650,3,960,480,0,7649,7648,1,0,
  	0,0,7649,7650,1,0,0,0,7650,7651,1,0,0,0,7651,7653,3,1132,566,0,7652,7642,
  	1,0,0,0,7652,7647,1,0,0,0,7653,7656,1,0,0,0,7654,7655,5,560,0,0,7655,
  	7657,3,1142,571,0,7656,7654,1,0,0,0,7656,7657,1,0,0,0,7657,959,1,0,0,
  	0,7658,7659,4,480,199,0,7659,7660,5,9,0,0,7660,7661,5,750,0,0,7661,7662,
  	3,1142,571,0,7662,961,1,0,0,0,7663,7664,5,776,0,0,7664,7669,3,964,482,
  	0,7665,7666,5,773,0,0,7666,7668,3,964,482,0,7667,7665,1,0,0,0,7668,7671,
  	1,0,0,0,7669,7667,1,0,0,0,7669,7670,1,0,0,0,7670,7672,1,0,0,0,7671,7669,
  	1,0,0,0,7672,7673,5,777,0,0,7673,963,1,0,0,0,7674,7675,5,405,0,0,7675,
  	7686,3,1128,564,0,7676,7677,5,626,0,0,7677,7678,5,273,0,0,7678,7681,5,
  	581,0,0,7679,7682,3,972,486,0,7680,7682,5,329,0,0,7681,7679,1,0,0,0,7681,
  	7680,1,0,0,0,7682,7687,1,0,0,0,7683,7684,5,626,0,0,7684,7685,5,251,0,
  	0,7685,7687,3,966,483,0,7686,7676,1,0,0,0,7686,7683,1,0,0,0,7686,7687,
  	1,0,0,0,7687,7691,1,0,0,0,7688,7690,3,968,484,0,7689,7688,1,0,0,0,7690,
  	7693,1,0,0,0,7691,7689,1,0,0,0,7691,7692,1,0,0,0,7692,7705,1,0,0,0,7693,
  	7691,1,0,0,0,7694,7695,5,776,0,0,7695,7700,3,970,485,0,7696,7697,5,773,
  	0,0,7697,7699,3,970,485,0,7698,7696,1,0,0,0,7699,7702,1,0,0,0,7700,7698,
  	1,0,0,0,7700,7701,1,0,0,0,7701,7703,1,0,0,0,7702,7700,1,0,0,0,7703,7704,
  	5,777,0,0,7704,7706,1,0,0,0,7705,7694,1,0,0,0,7705,7706,1,0,0,0,7706,
  	965,1,0,0,0,7707,7720,3,972,486,0,7708,7709,5,776,0,0,7709,7714,3,972,
  	486,0,7710,7711,5,773,0,0,7711,7713,3,972,486,0,7712,7710,1,0,0,0,7713,
  	7716,1,0,0,0,7714,7712,1,0,0,0,7714,7715,1,0,0,0,7715,7717,1,0,0,0,7716,
  	7714,1,0,0,0,7717,7718,5,777,0,0,7718,7720,1,0,0,0,7719,7707,1,0,0,0,
  	7719,7708,1,0,0,0,7720,967,1,0,0,0,7721,7723,5,572,0,0,7722,7724,5,750,
  	0,0,7723,7722,1,0,0,0,7723,7724,1,0,0,0,7724,7725,1,0,0,0,7725,7756,3,
  	1128,564,0,7726,7728,5,553,0,0,7727,7726,1,0,0,0,7727,7728,1,0,0,0,7728,
  	7729,1,0,0,0,7729,7731,5,163,0,0,7730,7732,5,750,0,0,7731,7730,1,0,0,
  	0,7731,7732,1,0,0,0,7732,7733,1,0,0,0,7733,7756,3,1094,547,0,7734,7736,
  	5,368,0,0,7735,7737,5,750,0,0,7736,7735,1,0,0,0,7736,7737,1,0,0,0,7737,
  	7738,1,0,0,0,7738,7756,3,1142,571,0,7739,7741,7,122,0,0,7740,7742,5,750,
  	0,0,7741,7740,1,0,0,0,7741,7742,1,0,0,0,7742,7743,1,0,0,0,7743,7756,3,
  	1142,571,0,7744,7745,7,123,0,0,7745,7747,5,139,0,0,7746,7748,5,750,0,
  	0,7747,7746,1,0,0,0,7747,7748,1,0,0,0,7748,7749,1,0,0,0,7749,7756,3,1160,
  	580,0,7750,7752,5,75,0,0,7751,7753,5,750,0,0,7752,7751,1,0,0,0,7752,7753,
  	1,0,0,0,7753,7754,1,0,0,0,7754,7756,3,1160,580,0,7755,7721,1,0,0,0,7755,
  	7727,1,0,0,0,7755,7734,1,0,0,0,7755,7739,1,0,0,0,7755,7744,1,0,0,0,7755,
  	7750,1,0,0,0,7756,969,1,0,0,0,7757,7758,5,561,0,0,7758,7762,3,1180,590,
  	0,7759,7761,3,968,484,0,7760,7759,1,0,0,0,7761,7764,1,0,0,0,7762,7760,
  	1,0,0,0,7762,7763,1,0,0,0,7763,971,1,0,0,0,7764,7762,1,0,0,0,7765,7766,
  	5,776,0,0,7766,7771,3,974,487,0,7767,7768,5,773,0,0,7768,7770,3,974,487,
  	0,7769,7767,1,0,0,0,7770,7773,1,0,0,0,7771,7769,1,0,0,0,7771,7772,1,0,
  	0,0,7772,7774,1,0,0,0,7773,7771,1,0,0,0,7774,7775,5,777,0,0,7775,973,
  	1,0,0,0,7776,7779,3,686,343,0,7777,7779,5,329,0,0,7778,7776,1,0,0,0,7778,
  	7777,1,0,0,0,7779,975,1,0,0,0,7780,7781,5,130,0,0,7781,7782,5,750,0,0,
  	7782,7783,3,1026,513,0,7783,977,1,0,0,0,7784,7785,5,231,0,0,7785,7786,
  	5,174,0,0,7786,979,1,0,0,0,7787,7788,5,231,0,0,7788,7789,3,760,380,0,
  	7789,7790,5,174,0,0,7790,981,1,0,0,0,7791,7793,7,124,0,0,7792,7791,1,
  	0,0,0,7792,7793,1,0,0,0,7793,7794,1,0,0,0,7794,7795,3,984,492,0,7795,
  	983,1,0,0,0,7796,7797,3,1108,554,0,7797,7798,3,988,494,0,7798,985,1,0,
  	0,0,7799,7800,5,69,0,0,7800,7801,3,938,469,0,7801,987,1,0,0,0,7802,7804,
  	3,916,458,0,7803,7805,3,986,493,0,7804,7803,1,0,0,0,7804,7805,1,0,0,0,
  	7805,989,1,0,0,0,7806,7807,5,776,0,0,7807,7808,3,1058,529,0,7808,7809,
  	5,773,0,0,7809,7810,3,1058,529,0,7810,7811,5,777,0,0,7811,991,1,0,0,0,
  	7812,7817,3,1074,537,0,7813,7814,5,773,0,0,7814,7816,3,1074,537,0,7815,
  	7813,1,0,0,0,7816,7819,1,0,0,0,7817,7815,1,0,0,0,7817,7818,1,0,0,0,7818,
  	993,1,0,0,0,7819,7817,1,0,0,0,7820,7825,3,996,498,0,7821,7822,5,773,0,
  	0,7822,7824,3,996,498,0,7823,7821,1,0,0,0,7824,7827,1,0,0,0,7825,7823,
  	1,0,0,0,7825,7826,1,0,0,0,7826,995,1,0,0,0,7827,7825,1,0,0,0,7828,7829,
  	3,1046,523,0,7829,7832,5,750,0,0,7830,7833,3,676,338,0,7831,7833,5,128,
  	0,0,7832,7830,1,0,0,0,7832,7831,1,0,0,0,7833,997,1,0,0,0,7834,7835,3,
  	758,379,0,7835,7836,3,936,468,0,7836,999,1,0,0,0,7837,7839,5,71,0,0,7838,
  	7840,3,1002,501,0,7839,7838,1,0,0,0,7840,7841,1,0,0,0,7841,7839,1,0,0,
  	0,7841,7842,1,0,0,0,7842,1001,1,0,0,0,7843,7844,5,579,0,0,7844,7845,5,
  	45,0,0,7845,7856,3,1156,578,0,7846,7848,5,392,0,0,7847,7846,1,0,0,0,7847,
  	7848,1,0,0,0,7848,7849,1,0,0,0,7849,7850,5,157,0,0,7850,7851,5,45,0,0,
  	7851,7856,3,1156,578,0,7852,7853,5,167,0,0,7853,7854,5,45,0,0,7854,7856,
  	3,1156,578,0,7855,7843,1,0,0,0,7855,7847,1,0,0,0,7855,7852,1,0,0,0,7856,
  	1003,1,0,0,0,7857,7859,5,278,0,0,7858,7860,3,1006,503,0,7859,7858,1,0,
  	0,0,7860,7861,1,0,0,0,7861,7859,1,0,0,0,7861,7862,1,0,0,0,7862,1005,1,
  	0,0,0,7863,7864,7,125,0,0,7864,7865,5,45,0,0,7865,7866,3,1156,578,0,7866,
  	1007,1,0,0,0,7867,7872,3,1026,513,0,7868,7869,5,773,0,0,7869,7871,3,1026,
  	513,0,7870,7868,1,0,0,0,7871,7874,1,0,0,0,7872,7870,1,0,0,0,7872,7873,
  	1,0,0,0,7873,1009,1,0,0,0,7874,7872,1,0,0,0,7875,7880,3,1014,507,0,7876,
  	7877,5,773,0,0,7877,7879,3,1014,507,0,7878,7876,1,0,0,0,7879,7882,1,0,
  	0,0,7880,7878,1,0,0,0,7880,7881,1,0,0,0,7881,1011,1,0,0,0,7882,7880,1,
  	0,0,0,7883,7888,3,1016,508,0,7884,7885,5,773,0,0,7885,7887,3,1016,508,
  	0,7886,7884,1,0,0,0,7887,7890,1,0,0,0,7888,7886,1,0,0,0,7888,7889,1,0,
  	0,0,7889,1013,1,0,0,0,7890,7888,1,0,0,0,7891,7918,3,1026,513,0,7892,7916,
  	5,230,0,0,7893,7896,5,45,0,0,7894,7895,4,507,200,0,7895,7897,5,406,0,
  	0,7896,7894,1,0,0,0,7896,7897,1,0,0,0,7897,7898,1,0,0,0,7898,7917,3,1156,
  	578,0,7899,7900,5,645,0,0,7900,7906,3,1180,590,0,7901,7902,5,17,0,0,7902,
  	7907,3,1158,579,0,7903,7904,4,507,201,0,7904,7905,5,45,0,0,7905,7907,
  	3,1156,578,0,7906,7901,1,0,0,0,7906,7903,1,0,0,0,7906,7907,1,0,0,0,7907,
  	7917,1,0,0,0,7908,7911,4,507,202,0,7909,7910,5,645,0,0,7910,7912,3,1180,
  	590,0,7911,7909,1,0,0,0,7911,7912,1,0,0,0,7912,7913,1,0,0,0,7913,7914,
  	5,45,0,0,7914,7915,5,734,0,0,7915,7917,5,406,0,0,7916,7893,1,0,0,0,7916,
  	7899,1,0,0,0,7916,7908,1,0,0,0,7917,7919,1,0,0,0,7918,7892,1,0,0,0,7918,
  	7919,1,0,0,0,7919,1015,1,0,0,0,7920,7949,3,1026,513,0,7921,7944,5,230,
  	0,0,7922,7923,5,645,0,0,7923,7925,3,1180,590,0,7924,7922,1,0,0,0,7924,
  	7925,1,0,0,0,7925,7926,1,0,0,0,7926,7927,5,45,0,0,7927,7930,3,1156,578,
  	0,7928,7929,5,458,0,0,7929,7931,3,1156,578,0,7930,7928,1,0,0,0,7930,7931,
  	1,0,0,0,7931,7933,1,0,0,0,7932,7934,3,1018,509,0,7933,7932,1,0,0,0,7933,
  	7934,1,0,0,0,7934,7945,1,0,0,0,7935,7936,5,645,0,0,7936,7942,3,1180,590,
  	0,7937,7938,5,17,0,0,7938,7940,3,1158,579,0,7939,7941,3,1018,509,0,7940,
  	7939,1,0,0,0,7940,7941,1,0,0,0,7941,7943,1,0,0,0,7942,7937,1,0,0,0,7942,
  	7943,1,0,0,0,7943,7945,1,0,0,0,7944,7924,1,0,0,0,7944,7935,1,0,0,0,7944,
  	7945,1,0,0,0,7945,7950,1,0,0,0,7946,7948,3,1020,510,0,7947,7946,1,0,0,
  	0,7947,7948,1,0,0,0,7948,7950,1,0,0,0,7949,7921,1,0,0,0,7949,7947,1,0,
  	0,0,7950,1017,1,0,0,0,7951,7952,5,727,0,0,7952,7953,5,101,0,0,7953,7954,
  	5,406,0,0,7954,1019,1,0,0,0,7955,7956,5,141,0,0,7956,7957,5,728,0,0,7957,
  	7958,5,406,0,0,7958,1021,1,0,0,0,7959,7960,5,458,0,0,7960,7961,3,1156,
  	578,0,7961,1023,1,0,0,0,7962,7966,3,1180,590,0,7963,7964,5,783,0,0,7964,
  	7967,3,1180,590,0,7965,7967,5,784,0,0,7966,7963,1,0,0,0,7966,7965,1,0,
  	0,0,7966,7967,1,0,0,0,7967,1025,1,0,0,0,7968,7974,3,1024,512,0,7969,7971,
  	5,105,0,0,7970,7972,3,1188,594,0,7971,7970,1,0,0,0,7971,7972,1,0,0,0,
  	7972,7974,1,0,0,0,7973,7968,1,0,0,0,7973,7969,1,0,0,0,7974,1027,1,0,0,
  	0,7975,7976,5,275,0,0,7976,7977,3,1154,577,0,7977,1029,1,0,0,0,7978,7981,
  	3,1028,514,0,7979,7981,3,358,179,0,7980,7978,1,0,0,0,7980,7979,1,0,0,
  	0,7981,1031,1,0,0,0,7982,7983,7,126,0,0,7983,1033,1,0,0,0,7984,7985,7,
  	127,0,0,7985,1035,1,0,0,0,7986,7987,4,518,203,0,7987,7988,5,405,0,0,7988,
  	7989,3,1132,566,0,7989,1037,1,0,0,0,7990,7996,3,1138,569,0,7991,7993,
  	3,1134,567,0,7992,7994,3,1138,569,0,7993,7992,1,0,0,0,7993,7994,1,0,0,
  	0,7994,7996,1,0,0,0,7995,7990,1,0,0,0,7995,7991,1,0,0,0,7996,1039,1,0,
  	0,0,7997,7998,4,520,204,0,7998,8002,3,1128,564,0,7999,8000,4,520,205,
  	0,8000,8002,3,1038,519,0,8001,7997,1,0,0,0,8001,7999,1,0,0,0,8002,1041,
  	1,0,0,0,8003,8004,3,1128,564,0,8004,1043,1,0,0,0,8005,8006,5,776,0,0,
  	8006,8011,3,1042,521,0,8007,8008,5,773,0,0,8008,8010,3,1042,521,0,8009,
  	8007,1,0,0,0,8010,8013,1,0,0,0,8011,8009,1,0,0,0,8011,8012,1,0,0,0,8012,
  	8014,1,0,0,0,8013,8011,1,0,0,0,8014,8015,5,777,0,0,8015,1045,1,0,0,0,
  	8016,8017,3,1038,519,0,8017,1047,1,0,0,0,8018,8021,3,1046,523,0,8019,
  	8021,3,1054,527,0,8020,8018,1,0,0,0,8020,8019,1,0,0,0,8021,1049,1,0,0,
  	0,8022,8023,3,1128,564,0,8023,1051,1,0,0,0,8024,8025,3,1038,519,0,8025,
  	1053,1,0,0,0,8026,8027,3,1128,564,0,8027,8031,5,772,0,0,8028,8029,3,1128,
  	564,0,8029,8030,5,772,0,0,8030,8032,1,0,0,0,8031,8028,1,0,0,0,8031,8032,
  	1,0,0,0,8032,8033,1,0,0,0,8033,8034,5,760,0,0,8034,1055,1,0,0,0,8035,
  	8036,3,1128,564,0,8036,1057,1,0,0,0,8037,8038,3,1128,564,0,8038,1059,
  	1,0,0,0,8039,8040,3,1134,567,0,8040,1061,1,0,0,0,8041,8042,3,1134,567,
  	0,8042,1063,1,0,0,0,8043,8044,3,1134,567,0,8044,1065,1,0,0,0,8045,8046,
  	3,1134,567,0,8046,1067,1,0,0,0,8047,8048,3,1134,567,0,8048,1069,1,0,0,
  	0,8049,8050,3,1134,567,0,8050,1071,1,0,0,0,8051,8054,3,1134,567,0,8052,
  	8054,3,1138,569,0,8053,8051,1,0,0,0,8053,8052,1,0,0,0,8054,1073,1,0,0,
  	0,8055,8058,3,1134,567,0,8056,8058,3,1138,569,0,8057,8055,1,0,0,0,8057,
  	8056,1,0,0,0,8058,1075,1,0,0,0,8059,8060,3,1128,564,0,8060,1077,1,0,0,
  	0,8061,8062,3,1128,564,0,8062,1079,1,0,0,0,8063,8064,3,1128,564,0,8064,
  	1081,1,0,0,0,8065,8066,3,1128,564,0,8066,1083,1,0,0,0,8067,8068,3,1134,
  	567,0,8068,1085,1,0,0,0,8069,8070,3,1134,567,0,8070,1087,1,0,0,0,8071,
  	8072,3,1128,564,0,8072,1089,1,0,0,0,8073,8074,3,1180,590,0,8074,1091,
  	1,0,0,0,8075,8076,3,1180,590,0,8076,1093,1,0,0,0,8077,8078,3,1180,590,
  	0,8078,1095,1,0,0,0,8079,8082,3,1134,567,0,8080,8082,3,1138,569,0,8081,
  	8079,1,0,0,0,8081,8080,1,0,0,0,8082,1097,1,0,0,0,8083,8084,3,1058,529,
  	0,8084,8085,3,1138,569,0,8085,1099,1,0,0,0,8086,8094,3,1128,564,0,8087,
  	8088,5,772,0,0,8088,8095,5,760,0,0,8089,8092,3,1138,569,0,8090,8091,5,
  	772,0,0,8091,8093,5,760,0,0,8092,8090,1,0,0,0,8092,8093,1,0,0,0,8093,
  	8095,1,0,0,0,8094,8087,1,0,0,0,8094,8089,1,0,0,0,8094,8095,1,0,0,0,8095,
  	1101,1,0,0,0,8096,8099,3,1134,567,0,8097,8099,3,1138,569,0,8098,8096,
  	1,0,0,0,8098,8097,1,0,0,0,8099,1103,1,0,0,0,8100,8105,3,1102,551,0,8101,
  	8102,5,773,0,0,8102,8104,3,1102,551,0,8103,8101,1,0,0,0,8104,8107,1,0,
  	0,0,8105,8103,1,0,0,0,8105,8106,1,0,0,0,8106,1105,1,0,0,0,8107,8105,1,
  	0,0,0,8108,8113,3,1100,550,0,8109,8110,5,773,0,0,8110,8112,3,1100,550,
  	0,8111,8109,1,0,0,0,8112,8115,1,0,0,0,8113,8111,1,0,0,0,8113,8114,1,0,
  	0,0,8114,1107,1,0,0,0,8115,8113,1,0,0,0,8116,8117,3,1128,564,0,8117,1109,
  	1,0,0,0,8118,8121,3,1126,563,0,8119,8121,3,1204,602,0,8120,8118,1,0,0,
  	0,8120,8119,1,0,0,0,8121,1111,1,0,0,0,8122,8123,3,1110,555,0,8123,1113,
  	1,0,0,0,8124,8127,3,1126,563,0,8125,8127,3,1210,605,0,8126,8124,1,0,0,
  	0,8126,8125,1,0,0,0,8127,1115,1,0,0,0,8128,8129,3,1114,557,0,8129,1117,
  	1,0,0,0,8130,8131,3,1128,564,0,8131,1119,1,0,0,0,8132,8133,3,1154,577,
  	0,8133,1121,1,0,0,0,8134,8135,3,1128,564,0,8135,1123,1,0,0,0,8136,8137,
  	3,1128,564,0,8137,1125,1,0,0,0,8138,8142,7,128,0,0,8139,8140,4,563,206,
  	0,8140,8142,5,798,0,0,8141,8138,1,0,0,0,8141,8139,1,0,0,0,8142,1127,1,
  	0,0,0,8143,8146,3,1126,563,0,8144,8146,3,1198,599,0,8145,8143,1,0,0,0,
  	8145,8144,1,0,0,0,8146,1129,1,0,0,0,8147,8152,3,1128,564,0,8148,8149,
  	5,773,0,0,8149,8151,3,1128,564,0,8150,8148,1,0,0,0,8151,8154,1,0,0,0,
  	8152,8150,1,0,0,0,8152,8153,1,0,0,0,8153,1131,1,0,0,0,8154,8152,1,0,0,
  	0,8155,8156,5,776,0,0,8156,8157,3,1130,565,0,8157,8158,5,777,0,0,8158,
  	1133,1,0,0,0,8159,8161,3,1128,564,0,8160,8162,3,1138,569,0,8161,8160,
  	1,0,0,0,8161,8162,1,0,0,0,8162,1135,1,0,0,0,8163,8168,3,1128,564,0,8164,
  	8166,3,1138,569,0,8165,8167,3,1138,569,0,8166,8165,1,0,0,0,8166,8167,
  	1,0,0,0,8167,8169,1,0,0,0,8168,8164,1,0,0,0,8168,8169,1,0,0,0,8169,8175,
  	1,0,0,0,8170,8171,4,568,207,0,8171,8172,3,1138,569,0,8172,8173,3,1138,
  	569,0,8173,8175,1,0,0,0,8174,8163,1,0,0,0,8174,8170,1,0,0,0,8175,1137,
  	1,0,0,0,8176,8177,5,772,0,0,8177,8178,3,1128,564,0,8178,1139,1,0,0,0,
  	8179,8180,7,129,0,0,8180,1141,1,0,0,0,8181,8182,7,130,0,0,8182,1143,1,
  	0,0,0,8183,8184,7,131,0,0,8184,1145,1,0,0,0,8185,8191,5,747,0,0,8186,
  	8187,4,573,208,0,8187,8191,5,788,0,0,8188,8191,5,749,0,0,8189,8191,5,
  	748,0,0,8190,8185,1,0,0,0,8190,8186,1,0,0,0,8190,8188,1,0,0,0,8190,8189,
  	1,0,0,0,8191,1147,1,0,0,0,8192,8202,3,1160,580,0,8193,8202,3,1166,583,
  	0,8194,8202,3,1172,586,0,8195,8202,3,1170,585,0,8196,8202,3,1168,584,
  	0,8197,8199,5,794,0,0,8198,8197,1,0,0,0,8198,8199,1,0,0,0,8199,8200,1,
  	0,0,0,8200,8202,7,132,0,0,8201,8192,1,0,0,0,8201,8193,1,0,0,0,8201,8194,
  	1,0,0,0,8201,8195,1,0,0,0,8201,8196,1,0,0,0,8201,8198,1,0,0,0,8202,1149,
  	1,0,0,0,8203,8209,3,1148,574,0,8204,8205,5,758,0,0,8205,8209,3,1140,570,
  	0,8206,8207,5,759,0,0,8207,8209,3,1140,570,0,8208,8203,1,0,0,0,8208,8204,
  	1,0,0,0,8208,8206,1,0,0,0,8209,1151,1,0,0,0,8210,8211,5,776,0,0,8211,
  	8216,3,1156,578,0,8212,8213,5,773,0,0,8213,8215,3,1156,578,0,8214,8212,
  	1,0,0,0,8215,8218,1,0,0,0,8216,8214,1,0,0,0,8216,8217,1,0,0,0,8217,8219,
  	1,0,0,0,8218,8216,1,0,0,0,8219,8220,5,777,0,0,8220,1153,1,0,0,0,8221,
  	8225,5,799,0,0,8222,8223,4,577,209,0,8223,8225,5,798,0,0,8224,8221,1,
  	0,0,0,8224,8222,1,0,0,0,8225,1155,1,0,0,0,8226,8230,3,1154,577,0,8227,
  	8230,5,788,0,0,8228,8230,5,789,0,0,8229,8226,1,0,0,0,8229,8227,1,0,0,
  	0,8229,8228,1,0,0,0,8230,1157,1,0,0,0,8231,8235,3,1154,577,0,8232,8233,
  	4,579,210,0,8233,8235,5,788,0,0,8234,8231,1,0,0,0,8234,8232,1,0,0,0,8235,
  	1159,1,0,0,0,8236,8238,5,794,0,0,8237,8236,1,0,0,0,8237,8238,1,0,0,0,
  	8238,8239,1,0,0,0,8239,8242,3,1154,577,0,8240,8242,5,796,0,0,8241,8237,
  	1,0,0,0,8241,8240,1,0,0,0,8242,8246,1,0,0,0,8243,8245,3,1154,577,0,8244,
  	8243,1,0,0,0,8245,8248,1,0,0,0,8246,8244,1,0,0,0,8246,8247,1,0,0,0,8247,
  	1161,1,0,0,0,8248,8246,1,0,0,0,8249,8250,3,1154,577,0,8250,1163,1,0,0,
  	0,8251,8256,3,1154,577,0,8252,8253,5,773,0,0,8253,8255,3,1154,577,0,8254,
  	8252,1,0,0,0,8255,8258,1,0,0,0,8256,8254,1,0,0,0,8256,8257,1,0,0,0,8257,
  	1165,1,0,0,0,8258,8256,1,0,0,0,8259,8260,7,131,0,0,8260,1167,1,0,0,0,
  	8261,8262,7,133,0,0,8262,1169,1,0,0,0,8263,8264,7,134,0,0,8264,1171,1,
  	0,0,0,8265,8266,5,116,0,0,8266,8272,5,799,0,0,8267,8268,5,586,0,0,8268,
  	8272,5,799,0,0,8269,8270,5,583,0,0,8270,8272,5,799,0,0,8271,8265,1,0,
  	0,0,8271,8267,1,0,0,0,8271,8269,1,0,0,0,8272,1173,1,0,0,0,8273,8276,3,
  	922,461,0,8274,8276,3,1178,589,0,8275,8273,1,0,0,0,8275,8274,1,0,0,0,
  	8276,1175,1,0,0,0,8277,8278,3,1178,589,0,8278,1177,1,0,0,0,8279,8280,
  	5,776,0,0,8280,8281,5,747,0,0,8281,8282,5,773,0,0,8282,8283,5,747,0,0,
  	8283,8284,5,777,0,0,8284,1179,1,0,0,0,8285,8288,3,1128,564,0,8286,8288,
  	3,1154,577,0,8287,8285,1,0,0,0,8287,8286,1,0,0,0,8288,1181,1,0,0,0,8289,
  	8292,3,1126,563,0,8290,8292,3,1212,606,0,8291,8289,1,0,0,0,8291,8290,
  	1,0,0,0,8292,1183,1,0,0,0,8293,8296,3,1114,557,0,8294,8296,3,1154,577,
  	0,8295,8293,1,0,0,0,8295,8294,1,0,0,0,8296,1185,1,0,0,0,8297,8300,3,1146,
  	573,0,8298,8300,3,1126,563,0,8299,8297,1,0,0,0,8299,8298,1,0,0,0,8300,
  	1187,1,0,0,0,8301,8302,5,776,0,0,8302,8303,5,777,0,0,8303,1189,1,0,0,
  	0,8304,8305,7,135,0,0,8305,1191,1,0,0,0,8306,8307,7,136,0,0,8307,1193,
  	1,0,0,0,8308,8309,5,214,0,0,8309,8315,5,772,0,0,8310,8311,5,284,0,0,8311,
  	8315,5,772,0,0,8312,8313,5,502,0,0,8313,8315,5,772,0,0,8314,8308,1,0,
  	0,0,8314,8310,1,0,0,0,8314,8312,1,0,0,0,8315,1195,1,0,0,0,8316,8317,5,
  	658,0,0,8317,8327,5,772,0,0,8318,8319,5,673,0,0,8319,8327,5,772,0,0,8320,
  	8321,5,214,0,0,8321,8327,5,772,0,0,8322,8323,5,284,0,0,8323,8327,5,772,
  	0,0,8324,8325,5,502,0,0,8325,8327,5,772,0,0,8326,8316,1,0,0,0,8326,8318,
  	1,0,0,0,8326,8320,1,0,0,0,8326,8322,1,0,0,0,8326,8324,1,0,0,0,8327,1197,
  	1,0,0,0,8328,8336,4,599,211,0,8329,8337,3,1204,602,0,8330,8337,3,1216,
  	608,0,8331,8337,5,173,0,0,8332,8333,4,599,212,0,8333,8337,5,510,0,0,8334,
  	8335,4,599,213,0,8335,8337,5,714,0,0,8336,8329,1,0,0,0,8336,8330,1,0,
  	0,0,8336,8331,1,0,0,0,8336,8332,1,0,0,0,8336,8334,1,0,0,0,8337,8346,1,
  	0,0,0,8338,8344,3,1208,604,0,8339,8344,3,1200,600,0,8340,8344,3,1202,
  	601,0,8341,8344,3,1206,603,0,8342,8344,3,1214,607,0,8343,8338,1,0,0,0,
  	8343,8339,1,0,0,0,8343,8340,1,0,0,0,8343,8341,1,0,0,0,8343,8342,1,0,0,
  	0,8344,8346,1,0,0,0,8345,8328,1,0,0,0,8345,8343,1,0,0,0,8346,1199,1,0,
  	0,0,8347,8348,7,137,0,0,8348,1201,1,0,0,0,8349,8350,7,138,0,0,8350,1203,
  	1,0,0,0,8351,8362,4,602,214,0,8352,8363,3,1218,609,0,8353,8363,5,170,
  	0,0,8354,8363,5,188,0,0,8355,8363,5,369,0,0,8356,8363,5,423,0,0,8357,
  	8363,5,427,0,0,8358,8363,5,451,0,0,8359,8363,5,459,0,0,8360,8363,5,709,
  	0,0,8361,8363,5,565,0,0,8362,8352,1,0,0,0,8362,8353,1,0,0,0,8362,8354,
  	1,0,0,0,8362,8355,1,0,0,0,8362,8356,1,0,0,0,8362,8357,1,0,0,0,8362,8358,
  	1,0,0,0,8362,8359,1,0,0,0,8362,8360,1,0,0,0,8362,8361,1,0,0,0,8363,8370,
  	1,0,0,0,8364,8368,3,1208,604,0,8365,8368,3,1206,603,0,8366,8368,3,1214,
  	607,0,8367,8364,1,0,0,0,8367,8365,1,0,0,0,8367,8366,1,0,0,0,8368,8370,
  	1,0,0,0,8369,8351,1,0,0,0,8369,8367,1,0,0,0,8370,1205,1,0,0,0,8371,8372,
  	7,139,0,0,8372,1207,1,0,0,0,8373,8377,7,140,0,0,8374,8375,4,604,215,0,
  	8375,8377,7,141,0,0,8376,8373,1,0,0,0,8376,8374,1,0,0,0,8377,1209,1,0,
  	0,0,8378,8381,4,605,216,0,8379,8382,3,1218,609,0,8380,8382,3,1216,608,
  	0,8381,8379,1,0,0,0,8381,8380,1,0,0,0,8382,8389,1,0,0,0,8383,8387,3,1208,
  	604,0,8384,8387,3,1202,601,0,8385,8387,3,1214,607,0,8386,8383,1,0,0,0,
  	8386,8384,1,0,0,0,8386,8385,1,0,0,0,8387,8389,1,0,0,0,8388,8378,1,0,0,
  	0,8388,8386,1,0,0,0,8389,1211,1,0,0,0,8390,8395,3,1208,604,0,8391,8395,
  	3,1200,600,0,8392,8395,3,1202,601,0,8393,8395,3,1206,603,0,8394,8390,
  	1,0,0,0,8394,8391,1,0,0,0,8394,8392,1,0,0,0,8394,8393,1,0,0,0,8395,1213,
  	1,0,0,0,8396,8397,7,136,0,0,8397,1215,1,0,0,0,8398,8404,7,142,0,0,8399,
  	8400,4,608,217,0,8400,8404,5,510,0,0,8401,8402,4,608,218,0,8402,8404,
  	5,234,0,0,8403,8398,1,0,0,0,8403,8399,1,0,0,0,8403,8401,1,0,0,0,8404,
  	1217,1,0,0,0,8405,8415,7,143,0,0,8406,8407,4,609,219,0,8407,8415,5,510,
  	0,0,8408,8409,4,609,220,0,8409,8415,7,144,0,0,8410,8411,4,609,221,0,8411,
  	8415,7,145,0,0,8412,8413,4,609,222,0,8413,8415,5,660,0,0,8414,8405,1,
  	0,0,0,8414,8406,1,0,0,0,8414,8408,1,0,0,0,8414,8410,1,0,0,0,8414,8412,
  	1,0,0,0,8415,1219,1,0,0,0,1123,1223,1227,1230,1232,1268,1276,1281,1297,
  	1304,1311,1314,1321,1326,1329,1334,1340,1342,1346,1350,1359,1363,1368,
  	1374,1381,1385,1390,1395,1402,1405,1411,1414,1421,1431,1436,1441,1449,
  	1455,1459,1464,1473,1479,1485,1491,1500,1506,1515,1529,1533,1539,1543,
  	1549,1553,1558,1561,1567,1573,1579,1583,1588,1592,1596,1604,1606,1619,
  	1627,1635,1639,1668,1684,1687,1696,1701,1707,1712,1716,1721,1725,1729,
  	1733,1737,1741,1743,1754,1762,1771,1776,1779,1784,1791,1799,1803,1808,
  	1815,1820,1825,1833,1837,1842,1845,1848,1851,1858,1865,1869,1893,1897,
  	1903,1910,1913,1917,1924,1927,1930,1933,1942,1949,1954,1957,1960,1966,
  	1972,1975,1980,1990,1993,1999,2005,2015,2018,2026,2032,2043,2046,2051,
  	2070,2073,2076,2082,2085,2087,2093,2103,2113,2116,2119,2124,2130,2143,
  	2147,2152,2161,2178,2197,2206,2209,2217,2222,2226,2233,2238,2253,2257,
  	2263,2269,2275,2281,2287,2292,2296,2304,2310,2316,2321,2324,2327,2336,
  	2339,2350,2362,2371,2375,2384,2387,2393,2395,2399,2406,2419,2426,2432,
  	2435,2452,2472,2476,2482,2488,2494,2499,2506,2513,2518,2521,2525,2529,
  	2534,2538,2542,2548,2553,2556,2560,2566,2570,2574,2582,2590,2599,2608,
  	2621,2624,2628,2634,2642,2647,2650,2653,2656,2659,2661,2667,2669,2684,
  	2690,2697,2700,2702,2704,2714,2716,2720,2723,2726,2730,2735,2741,2744,
  	2747,2753,2756,2765,2774,2778,2782,2788,2793,2798,2803,2807,2813,2824,
  	2827,2832,2838,2841,2844,2847,2850,2864,2867,2871,2875,2881,2886,2890,
  	2895,2898,2902,2908,2912,2916,2925,2930,2934,2938,2941,2945,2948,2950,
  	2954,2960,2964,2966,2970,2974,2978,2985,2987,2996,3002,3007,3010,3013,
  	3016,3019,3023,3038,3042,3048,3051,3054,3060,3065,3069,3072,3080,3082,
  	3095,3107,3112,3115,3118,3123,3129,3145,3165,3174,3178,3185,3190,3199,
  	3206,3217,3224,3233,3242,3254,3259,3266,3270,3276,3281,3286,3290,3296,
  	3302,3304,3307,3311,3321,3326,3331,3338,3347,3355,3360,3364,3370,3373,
  	3376,3380,3384,3394,3398,3401,3404,3409,3415,3419,3425,3428,3430,3435,
  	3447,3456,3469,3472,3477,3484,3488,3492,3494,3508,3515,3524,3530,3539,
  	3543,3547,3557,3559,3567,3574,3579,3583,3587,3590,3596,3599,3602,3608,
  	3615,3620,3624,3627,3630,3633,3635,3639,3647,3653,3657,3662,3665,3668,
  	3671,3673,3678,3687,3700,3702,3706,3712,3715,3718,3724,3731,3733,3741,
  	3747,3752,3755,3762,3764,3773,3782,3791,3799,3803,3810,3813,3815,3823,
  	3829,3839,3846,3940,3944,3950,3964,3972,3975,3987,3992,3998,4005,4012,
  	4019,4026,4033,4040,4043,4050,4058,4066,4076,4082,4086,4090,4095,4098,
  	4100,4109,4115,4122,4127,4132,4137,4140,4147,4160,4166,4172,4179,4187,
  	4193,4205,4207,4213,4217,4219,4223,4236,4242,4250,4261,4265,4278,4285,
  	4291,4298,4300,4310,4318,4321,4326,4330,4336,4339,4344,4355,4357,4369,
  	4374,4382,4388,4390,4392,4398,4410,4415,4417,4421,4427,4430,4433,4443,
  	4445,4451,4458,4464,4474,4478,4483,4500,4516,4521,4529,4537,4542,4548,
  	4551,4553,4562,4568,4574,4576,4580,4591,4601,4606,4611,4616,4624,4628,
  	4633,4642,4654,4668,4677,4679,4686,4693,4697,4703,4711,4718,4722,4728,
  	4735,4738,4747,4753,4758,4781,4784,4800,4805,4808,4812,4815,4829,4835,
  	4840,4843,4845,4849,4854,4856,4868,4874,4896,4900,4902,4910,4914,4923,
  	4933,4940,4943,4947,4950,4953,4957,4960,4964,4967,4972,4975,4980,4983,
  	4989,4993,4999,5002,5011,5013,5019,5023,5026,5029,5033,5039,5042,5045,
  	5055,5059,5068,5071,5076,5079,5082,5086,5089,5094,5098,5106,5119,5137,
  	5142,5147,5155,5161,5163,5167,5170,5184,5194,5198,5206,5209,5213,5223,
  	5227,5234,5239,5247,5252,5258,5265,5270,5276,5283,5293,5295,5303,5308,
  	5312,5315,5322,5327,5331,5342,5350,5354,5357,5360,5364,5368,5373,5379,
  	5383,5394,5397,5400,5403,5411,5415,5420,5428,5436,5442,5460,5470,5476,
  	5490,5493,5497,5508,5510,5519,5531,5533,5540,5546,5552,5560,5571,5575,
  	5604,5606,5614,5618,5635,5642,5656,5668,5674,5681,5684,5718,5726,5728,
  	5740,5745,5751,5759,5766,5772,5777,5783,5788,5793,5799,5804,5810,5818,
  	5826,5834,5842,5847,5853,5858,5862,5866,5871,5873,5892,5896,5903,5915,
  	5918,5922,5927,5932,5936,5946,5955,5957,5960,5969,5976,5989,5994,6001,
  	6007,6033,6064,6084,6090,6094,6121,6133,6146,6150,6154,6182,6238,6248,
  	6252,6264,6269,6282,6302,6306,6323,6326,6331,6334,6343,6347,6353,6359,
  	6363,6374,6380,6382,6389,6396,6400,6407,6412,6416,6421,6425,6429,6434,
  	6439,6441,6445,6458,6462,6465,6469,6473,6477,6482,6486,6490,6499,6501,
  	6508,6514,6522,6543,6548,6555,6578,6594,6604,6608,6615,6618,6629,6638,
  	6641,6648,6653,6679,6685,6691,6695,6705,6709,6722,6734,6752,6760,6770,
  	6773,6778,6782,6789,6794,6801,6809,6812,6817,6825,6828,6842,6845,6858,
  	6862,6864,6869,6874,6880,6886,6892,6897,6900,6906,6911,6914,6920,6924,
  	6930,6932,6935,6941,6947,6955,6957,6959,6963,6969,6974,6978,6983,6989,
  	6996,6999,7001,7004,7014,7018,7024,7031,7036,7050,7055,7063,7068,7072,
  	7075,7080,7084,7092,7100,7102,7109,7117,7124,7127,7135,7143,7145,7151,
  	7157,7161,7168,7179,7188,7191,7196,7198,7201,7204,7208,7211,7215,7220,
  	7223,7227,7230,7234,7239,7243,7255,7259,7265,7268,7273,7277,7281,7286,
  	7295,7298,7302,7306,7309,7313,7317,7322,7327,7333,7338,7343,7345,7350,
  	7357,7365,7371,7373,7377,7381,7385,7389,7403,7410,7414,7419,7425,7429,
  	7435,7439,7443,7448,7453,7458,7463,7469,7475,7480,7485,7490,7495,7500,
  	7505,7510,7520,7526,7532,7538,7541,7548,7553,7556,7560,7563,7567,7572,
  	7576,7581,7585,7594,7597,7600,7603,7607,7611,7615,7630,7633,7635,7640,
  	7649,7652,7656,7669,7681,7686,7691,7700,7705,7714,7719,7723,7727,7731,
  	7736,7741,7747,7752,7755,7762,7771,7778,7792,7804,7817,7825,7832,7841,
  	7847,7855,7861,7872,7880,7888,7896,7906,7911,7916,7918,7924,7930,7933,
  	7940,7942,7944,7947,7949,7966,7971,7973,7980,7993,7995,8001,8011,8020,
  	8031,8053,8057,8081,8092,8094,8098,8105,8113,8120,8126,8141,8145,8152,
  	8161,8166,8168,8174,8190,8198,8201,8208,8216,8224,8229,8234,8237,8241,
  	8246,8256,8271,8275,8287,8291,8295,8299,8314,8326,8336,8343,8345,8362,
  	8367,8369,8376,8381,8386,8388,8394,8403,8414
  };
  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 = std::move(staticData);
}

}

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

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

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

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

      default:
        break;
      }
      setState(1230);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::SEMICOLON_SYMBOL: {
          setState(1225);
          match(MySQLParser::SEMICOLON_SYMBOL);
          setState(1227);
          _errHandler->sync(this);

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

          default:
            break;
          }
          break;
        }

        case MySQLParser::EOF: {
          setState(1229);
          match(MySQLParser::EOF);
          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;
}

//----------------- 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::InstallUninstallStatmentContext* MySQLParser::SimpleStatementContext::installUninstallStatment() {
  return getRuleContext<MySQLParser::InstallUninstallStatmentContext>(0);
}

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

MySQLParser::ShowStatementContext* MySQLParser::SimpleStatementContext::showStatement() {
  return getRuleContext<MySQLParser::ShowStatementContext>(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::GetDiagnosticsContext* MySQLParser::SimpleStatementContext::getDiagnostics() {
  return getRuleContext<MySQLParser::GetDiagnosticsContext>(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(1268);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1234);
      alterStatement();
      break;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(1257);
      installUninstallStatment();
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(1258);
      setStatement();
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(1259);
      showStatement();
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(1260);

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

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(1262);
      otherAdministrativeStatement();
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(1263);
      utilityStatement();
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(1264);

      if (!(serverVersion >= 50604)) throw FailedPredicateException(this, "serverVersion >= 50604");
      setState(1265);
      getDiagnostics();
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(1266);
      signalStatement();
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(1267);
      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);
}

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

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

MySQLParser::TextOrIdentifierContext* MySQLParser::AlterStatementContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

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

tree::TerminalNode* MySQLParser::AlterStatementContext::KEY_SYMBOL() {
  return getToken(MySQLParser::KEY_SYMBOL, 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(1270);
    match(MySQLParser::ALTER_SYMBOL);
    setState(1297);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
    case 1: {
      setState(1271);
      alterTable();
      break;
    }

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

    case 3: {
      setState(1273);
      match(MySQLParser::PROCEDURE_SYMBOL);
      setState(1274);
      procedureRef();
      setState(1276);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 75) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 75)) & 4611686018427420673) != 0) || _la == MySQLParser::LANGUAGE_SYMBOL || ((((_la - 347) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 347)) & 83886081) != 0) || _la == MySQLParser::READS_SYMBOL || _la == MySQLParser::SQL_SYMBOL) {
        setState(1275);
        routineAlterOptions();
      }
      break;
    }

    case 4: {
      setState(1278);
      match(MySQLParser::FUNCTION_SYMBOL);
      setState(1279);
      functionRef();
      setState(1281);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 75) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 75)) & 4611686018427420673) != 0) || _la == MySQLParser::LANGUAGE_SYMBOL || ((((_la - 347) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 347)) & 83886081) != 0) || _la == MySQLParser::READS_SYMBOL || _la == MySQLParser::SQL_SYMBOL) {
        setState(1280);
        routineAlterOptions();
      }
      break;
    }

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

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

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

    case 8: {
      setState(1286);

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

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

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

    case 11: {
      setState(1290);

      if (!(serverVersion >= 50713)) throw FailedPredicateException(this, "serverVersion >= 50713");
      setState(1291);
      match(MySQLParser::INSTANCE_SYMBOL);
      setState(1292);
      match(MySQLParser::ROTATE_SYMBOL);
      setState(1293);
      textOrIdentifier();
      setState(1294);
      match(MySQLParser::MASTER_SYMBOL);
      setState(1295);
      match(MySQLParser::KEY_SYMBOL);
      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::CreateDatabaseOptionContext *> MySQLParser::AlterDatabaseContext::createDatabaseOption() {
  return getRuleContexts<MySQLParser::CreateDatabaseOptionContext>();
}

MySQLParser::CreateDatabaseOptionContext* MySQLParser::AlterDatabaseContext::createDatabaseOption(size_t i) {
  return getRuleContext<MySQLParser::CreateDatabaseOptionContext>(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(1299);
    match(MySQLParser::DATABASE_SYMBOL);
    setState(1300);
    schemaRef();
    setState(1311);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
    case 1: {
      setState(1302); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(1301);
                createDatabaseOption();
                break;
              }

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

    case 2: {
      setState(1306);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(1307);
      match(MySQLParser::UPGRADE_SYMBOL);
      setState(1308);
      match(MySQLParser::DATA_SYMBOL);
      setState(1309);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(1310);
      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;
}

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

tree::TerminalNode* MySQLParser::AlterEventContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 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, 8, MySQLParser::RuleAlterEvent);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(1313);
      definerClause();
    }
    setState(1316);
    match(MySQLParser::EVENT_SYMBOL);
    setState(1317);
    eventRef();
    setState(1321);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {
    case 1: {
      setState(1318);
      match(MySQLParser::ON_SYMBOL);
      setState(1319);
      match(MySQLParser::SCHEDULE_SYMBOL);
      setState(1320);
      schedule();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == MySQLParser::ON_SYMBOL) {
      setState(1323);
      match(MySQLParser::ON_SYMBOL);
      setState(1324);
      match(MySQLParser::COMPLETION_SYMBOL);
      setState(1326);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(1325);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(1328);
      match(MySQLParser::PRESERVE_SYMBOL);
    }
    setState(1334);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::RENAME_SYMBOL) {
      setState(1331);
      match(MySQLParser::RENAME_SYMBOL);
      setState(1332);
      match(MySQLParser::TO_SYMBOL);
      setState(1333);
      identifier();
    }
    setState(1342);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ENABLE_SYMBOL: {
        setState(1336);
        match(MySQLParser::ENABLE_SYMBOL);
        break;
      }

      case MySQLParser::DISABLE_SYMBOL: {
        setState(1337);
        match(MySQLParser::DISABLE_SYMBOL);
        setState(1340);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ON_SYMBOL) {
          setState(1338);
          match(MySQLParser::ON_SYMBOL);
          setState(1339);
          match(MySQLParser::SLAVE_SYMBOL);
        }
        break;
      }

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

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

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMENT_SYMBOL) {
      setState(1344);
      match(MySQLParser::COMMENT_SYMBOL);
      setState(1345);
      textLiteral();
    }
    setState(1350);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DO_SYMBOL) {
      setState(1348);
      match(MySQLParser::DO_SYMBOL);
      setState(1349);
      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, 10, MySQLParser::RuleAlterLogfileGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1352);
    match(MySQLParser::LOGFILE_SYMBOL);
    setState(1353);
    match(MySQLParser::GROUP_SYMBOL);
    setState(1354);
    logfileGroupRef();
    setState(1355);
    match(MySQLParser::ADD_SYMBOL);
    setState(1356);
    match(MySQLParser::UNDOFILE_SYMBOL);
    setState(1357);
    textLiteral();
    setState(1359);
    _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(1358);
      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, 12, MySQLParser::RuleAlterLogfileGroupOptions);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(1362);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(1365);
      alterLogfileGroupOption();
      setState(1370);
      _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, 14, MySQLParser::RuleAlterLogfileGroupOption);

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

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

      case MySQLParser::NO_WAIT_SYMBOL:
      case MySQLParser::WAIT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(1373);
        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, 16, MySQLParser::RuleAlterServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1376);
    match(MySQLParser::SERVER_SYMBOL);
    setState(1377);
    serverRef();
    setState(1378);
    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);
}

tree::TerminalNode* MySQLParser::AlterTableContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 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, 18, MySQLParser::RuleAlterTable);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
    case 1: {
      setState(1380);
      onlineOption();
      break;
    }

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

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

      if (!(serverVersion < 50700)) throw FailedPredicateException(this, "serverVersion < 50700");
      setState(1384);
      match(MySQLParser::IGNORE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(1387);
    match(MySQLParser::TABLE_SYMBOL);
    setState(1388);
    tableRef();
    setState(1390);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx)) {
    case 1: {
      setState(1389);
      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, 20, MySQLParser::RuleAlterTableActions);

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

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

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

      default:
        break;
      }
      break;
    }

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

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

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

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

      default:
        break;
      }
      setState(1404);
      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, 22, MySQLParser::RuleAlterCommandList);

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

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

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

      default:
        break;
      }
      setState(1413);
      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, 24, MySQLParser::RuleAlterCommandsModifierList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1416);
    alterCommandsModifier();
    setState(1421);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1417);
        match(MySQLParser::COMMA_SYMBOL);
        setState(1418);
        alterCommandsModifier(); 
      }
      setState(1423);
      _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);
}


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, 26, MySQLParser::RuleStandaloneAlterCommands);
  size_t _la = 0;

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

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

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

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

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(1430);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::SECONDARY_LOAD_SYMBOL

      || _la == MySQLParser::SECONDARY_UNLOAD_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;
}

//----------------- 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, 28, MySQLParser::RuleAlterPartition);
  size_t _la = 0;

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

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

        case MySQLParser::PARTITIONS_SYMBOL: {
          setState(1439);
          match(MySQLParser::PARTITIONS_SYMBOL);
          setState(1440);
          real_ulong_number();
          break;
        }

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1443);
      match(MySQLParser::DROP_SYMBOL);
      setState(1444);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1445);
      identifierList();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1446);
      match(MySQLParser::REBUILD_SYMBOL);
      setState(1447);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1449);
      _errHandler->sync(this);

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

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

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1452);
      match(MySQLParser::OPTIMIZE_SYMBOL);
      setState(1453);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1455);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1457);
      allOrPartitionNameList();
      setState(1459);
      _errHandler->sync(this);

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

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1461);
      match(MySQLParser::ANALYZE_SYMBOL);
      setState(1462);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1464);
      _errHandler->sync(this);

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

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

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1467);
      match(MySQLParser::CHECK_SYMBOL);
      setState(1468);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1469);
      allOrPartitionNameList();
      setState(1473);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::CHANGED_SYMBOL || ((((_la - 180) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 180)) & 1048593) != 0) || _la == MySQLParser::MEDIUM_SYMBOL || _la == MySQLParser::QUICK_SYMBOL) {
        setState(1470);
        checkOption();
        setState(1475);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1476);
      match(MySQLParser::REPAIR_SYMBOL);
      setState(1477);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1479);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1481);
      allOrPartitionNameList();
      setState(1485);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL || _la == MySQLParser::USE_FRM_SYMBOL) {
        setState(1482);
        repairType();
        setState(1487);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1488);
      match(MySQLParser::COALESCE_SYMBOL);
      setState(1489);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1491);
      _errHandler->sync(this);

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

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1494);
      match(MySQLParser::TRUNCATE_SYMBOL);
      setState(1495);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1496);
      allOrPartitionNameList();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1497);
      match(MySQLParser::REORGANIZE_SYMBOL);
      setState(1498);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1500);
      _errHandler->sync(this);

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
      case 1: {
        setState(1502);
        identifierList();
        setState(1503);
        match(MySQLParser::INTO_SYMBOL);
        setState(1504);
        partitionDefinitions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1508);
      match(MySQLParser::EXCHANGE_SYMBOL);
      setState(1509);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1510);
      identifier();
      setState(1511);
      match(MySQLParser::WITH_SYMBOL);
      setState(1512);
      match(MySQLParser::TABLE_SYMBOL);
      setState(1513);
      tableRef();
      setState(1515);
      _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

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

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(1518);
      match(MySQLParser::DISCARD_SYMBOL);
      setState(1519);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1520);
      allOrPartitionNameList();
      setState(1521);
      match(MySQLParser::TABLESPACE_SYMBOL);
      break;
    }

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

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(1524);
      match(MySQLParser::IMPORT_SYMBOL);
      setState(1525);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(1526);
      allOrPartitionNameList();
      setState(1527);
      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, 30, MySQLParser::RuleAlterList);
  size_t _la = 0;

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

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

    default:
      break;
    }
    setState(1543);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(1535);
      match(MySQLParser::COMMA_SYMBOL);
      setState(1539);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
      case 1: {
        setState(1536);
        alterListItem();
        break;
      }

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

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

      default:
        break;
      }
      setState(1545);
      _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, 32, MySQLParser::RuleAlterCommandsModifier);

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

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

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1548);
      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::ExprWithParenthesesContext* MySQLParser::AlterListItemContext::exprWithParentheses() {
  return getRuleContext<MySQLParser::ExprWithParenthesesContext>(0);
}

MySQLParser::SignedLiteralContext* MySQLParser::AlterListItemContext::signedLiteral() {
  return getRuleContext<MySQLParser::SignedLiteralContext>(0);
}

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

MySQLParser::VisibilityContext* MySQLParser::AlterListItemContext::visibility() {
  return getRuleContext<MySQLParser::VisibilityContext>(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, 34, MySQLParser::RuleAlterListItem);
  size_t _la = 0;

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

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

      default:
        break;
      }
      setState(1567);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 54, _ctx)) {
      case 1: {
        setState(1555);
        identifier();
        setState(1556);
        fieldDefinition();
        setState(1558);
        _errHandler->sync(this);

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

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

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

      case 2: {
        setState(1563);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(1564);
        tableElementList();
        setState(1565);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

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

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

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

      default:
        break;
      }
      setState(1575);
      columnInternalRef();
      setState(1576);
      identifier();
      setState(1577);
      fieldDefinition();
      setState(1579);
      _errHandler->sync(this);

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

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

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

      default:
        break;
      }
      setState(1585);
      columnInternalRef();
      setState(1586);
      fieldDefinition();
      setState(1588);
      _errHandler->sync(this);

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

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1590);
      match(MySQLParser::DROP_SYMBOL);
      setState(1619);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
      case 1: {
        setState(1592);
        _errHandler->sync(this);

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

        default:
          break;
        }
        setState(1594);
        columnInternalRef();
        setState(1596);
        _errHandler->sync(this);

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

      case 2: {
        setState(1598);
        match(MySQLParser::FOREIGN_SYMBOL);
        setState(1599);
        match(MySQLParser::KEY_SYMBOL);
        setState(1606);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 62, _ctx)) {
        case 1: {
          setState(1600);

          if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
          setState(1601);
          columnInternalRef();
          break;
        }

        case 2: {
          setState(1602);

          if (!(serverVersion < 50700)) throw FailedPredicateException(this, "serverVersion < 50700");
          setState(1604);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
          case 1: {
            setState(1603);
            columnInternalRef();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        }
        break;
      }

      case 3: {
        setState(1608);
        match(MySQLParser::PRIMARY_SYMBOL);
        setState(1609);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      case 4: {
        setState(1610);
        keyOrIndex();
        setState(1611);
        indexRef();
        break;
      }

      case 5: {
        setState(1613);

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

      case 6: {
        setState(1616);

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

      default:
        break;
      }
      break;
    }

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

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

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

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

      default:
        break;
      }
      setState(1629);
      columnInternalRef();
      setState(1639);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::SET_SYMBOL: {
          setState(1630);
          match(MySQLParser::SET_SYMBOL);
          setState(1631);
          match(MySQLParser::DEFAULT_SYMBOL);
          setState(1635);
          _errHandler->sync(this);
          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 65, _ctx)) {
          case 1: {
            setState(1632);

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

          case 2: {
            setState(1634);
            signedLiteral();
            break;
          }

          default:
            break;
          }
          break;
        }

        case MySQLParser::DROP_SYMBOL: {
          setState(1637);
          match(MySQLParser::DROP_SYMBOL);
          setState(1638);
          match(MySQLParser::DEFAULT_SYMBOL);
          break;
        }

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

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(1642);
      match(MySQLParser::ALTER_SYMBOL);
      setState(1643);
      match(MySQLParser::INDEX_SYMBOL);
      setState(1644);
      indexRef();
      setState(1645);
      visibility();
      break;
    }

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

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(1648);
      match(MySQLParser::ALTER_SYMBOL);
      setState(1649);
      match(MySQLParser::CHECK_SYMBOL);
      setState(1650);
      identifier();
      setState(1651);
      constraintEnforcement();
      break;
    }

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

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(1654);
      match(MySQLParser::ALTER_SYMBOL);
      setState(1655);
      match(MySQLParser::CONSTRAINT_SYMBOL);
      setState(1656);
      identifier();
      setState(1657);
      constraintEnforcement();
      break;
    }

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(1660);
      match(MySQLParser::RENAME_SYMBOL);
      setState(1661);
      match(MySQLParser::COLUMN_SYMBOL);
      setState(1662);
      columnInternalRef();
      setState(1663);
      match(MySQLParser::TO_SYMBOL);
      setState(1664);
      identifier();
      break;
    }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 67, _ctx)) {
      case 1: {
        setState(1667);
        _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(1670);
      tableName();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1671);

      if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
      setState(1672);
      match(MySQLParser::RENAME_SYMBOL);
      setState(1673);
      keyOrIndex();
      setState(1674);
      indexRef();
      setState(1675);
      match(MySQLParser::TO_SYMBOL);
      setState(1676);
      indexName();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(1678);
      match(MySQLParser::CONVERT_SYMBOL);
      setState(1679);
      match(MySQLParser::TO_SYMBOL);
      setState(1680);
      charset();
      setState(1684);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 68, _ctx)) {
      case 1: {
        setState(1681);

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

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

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

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

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

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(1690);
      match(MySQLParser::ORDER_SYMBOL);
      setState(1691);
      match(MySQLParser::BY_SYMBOL);
      setState(1692);
      alterOrderList();
      break;
    }

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

      if (!(serverVersion >= 50708 && serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion >= 50708 && serverVersion < 80000");
      setState(1694);
      match(MySQLParser::UPGRADE_SYMBOL);
      setState(1695);
      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, 36, MySQLParser::RulePlace);

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

      case MySQLParser::FIRST_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(1700);
        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, 38, MySQLParser::RuleRestrict);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1703);
    _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, 40, 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(1705);
    identifier();
    setState(1707);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
      setState(1706);
      direction();
    }
    setState(1716);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 74, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1709);
        match(MySQLParser::COMMA_SYMBOL);
        setState(1710);
        identifier();
        setState(1712);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
          setState(1711);
          direction();
        } 
      }
      setState(1718);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 74, _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, 42, MySQLParser::RuleAlterAlgorithmOption);

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

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

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

    case 2: {
      setState(1724);
      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, 44, MySQLParser::RuleAlterLockOption);

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

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

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

    case 2: {
      setState(1732);
      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, 46, MySQLParser::RuleIndexLockAndAlgorithm);
  size_t _la = 0;

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

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

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

        _la = _input->LA(1);
        if (_la == MySQLParser::ALGORITHM_SYMBOL) {
          setState(1740);
          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, 48, MySQLParser::RuleWithValidation);
  size_t _la = 0;

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

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

    || _la == MySQLParser::WITHOUT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1747);
    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, 50, MySQLParser::RuleRemovePartitioning);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1749);
    match(MySQLParser::REMOVE_SYMBOL);
    setState(1750);
    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, 52, MySQLParser::RuleAllOrPartitionNameList);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1753);
      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);
}

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

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

tree::TerminalNode* MySQLParser::AlterTablespaceContext::ACCESSIBLE_SYMBOL() {
  return getToken(MySQLParser::ACCESSIBLE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::READ_ONLY_SYMBOL() {
  return getToken(MySQLParser::READ_ONLY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterTablespaceContext::READ_WRITE_SYMBOL() {
  return getToken(MySQLParser::READ_WRITE_SYMBOL, 0);
}

std::vector<MySQLParser::ChangeTablespaceOptionContext *> MySQLParser::AlterTablespaceContext::changeTablespaceOption() {
  return getRuleContexts<MySQLParser::ChangeTablespaceOptionContext>();
}

MySQLParser::ChangeTablespaceOptionContext* MySQLParser::AlterTablespaceContext::changeTablespaceOption(size_t i) {
  return getRuleContext<MySQLParser::ChangeTablespaceOptionContext>(i);
}

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

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


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, 54, MySQLParser::RuleAlterTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1756);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(1757);
    tablespaceRef();
    setState(1791);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx)) {
    case 1: {
      setState(1758);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ADD_SYMBOL || _la == MySQLParser::DROP_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1759);
      match(MySQLParser::DATAFILE_SYMBOL);
      setState(1760);
      textLiteral();
      setState(1762);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::AUTOEXTEND_SIZE_SYMBOL || _la == MySQLParser::ENCRYPTION_SYMBOL

      || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::MAX_SIZE_SYMBOL

      || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL) {
        setState(1761);
        alterTablespaceOptions();
      }
      break;
    }

    case 2: {
      setState(1764);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(1784);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::EOF:
        case MySQLParser::SEMICOLON_SYMBOL: {
          break;
        }

        case MySQLParser::CHANGE_SYMBOL: {
          setState(1766);
          match(MySQLParser::CHANGE_SYMBOL);
          setState(1767);
          match(MySQLParser::DATAFILE_SYMBOL);
          setState(1768);
          textLiteral();
          setState(1779);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::AUTOEXTEND_SIZE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::MAX_SIZE_SYMBOL) {
            setState(1769);
            changeTablespaceOption();
            setState(1776);
            _errHandler->sync(this);
            _la = _input->LA(1);
            while (_la == MySQLParser::AUTOEXTEND_SIZE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::MAX_SIZE_SYMBOL || _la == MySQLParser::COMMA_SYMBOL) {
              setState(1771);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == MySQLParser::COMMA_SYMBOL) {
                setState(1770);
                match(MySQLParser::COMMA_SYMBOL);
              }
              setState(1773);
              changeTablespaceOption();
              setState(1778);
              _errHandler->sync(this);
              _la = _input->LA(1);
            }
          }
          break;
        }

        case MySQLParser::READ_ONLY_SYMBOL:
        case MySQLParser::READ_WRITE_SYMBOL: {
          setState(1781);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::READ_ONLY_SYMBOL

          || _la == MySQLParser::READ_WRITE_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          break;
        }

        case MySQLParser::NOT_SYMBOL: {
          setState(1782);
          match(MySQLParser::NOT_SYMBOL);
          setState(1783);
          match(MySQLParser::ACCESSIBLE_SYMBOL);
          break;
        }

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

    case 3: {
      setState(1786);
      match(MySQLParser::RENAME_SYMBOL);
      setState(1787);
      match(MySQLParser::TO_SYMBOL);
      setState(1788);
      identifier();
      break;
    }

    case 4: {
      setState(1789);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(1790);
      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, 56, MySQLParser::RuleAlterUndoTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1793);
    match(MySQLParser::UNDO_SYMBOL);
    setState(1794);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(1795);
    tablespaceRef();
    setState(1796);
    match(MySQLParser::SET_SYMBOL);
    setState(1797);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ACTIVE_SYMBOL

    || _la == MySQLParser::INACTIVE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1799);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(1798);
      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, 58, MySQLParser::RuleUndoTableSpaceOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1801);
    undoTableSpaceOption();
    setState(1808);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::COMMA_SYMBOL) {
      setState(1803);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(1802);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(1805);
      undoTableSpaceOption();
      setState(1810);
      _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, 60, MySQLParser::RuleUndoTableSpaceOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1811);
    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, 62, MySQLParser::RuleAlterTablespaceOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1813);
    alterTablespaceOption();
    setState(1820);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::AUTOEXTEND_SIZE_SYMBOL || _la == MySQLParser::ENCRYPTION_SYMBOL

    || _la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::INITIAL_SIZE_SYMBOL || _la == MySQLParser::MAX_SIZE_SYMBOL

    || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL || _la == MySQLParser::COMMA_SYMBOL) {
      setState(1815);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(1814);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(1817);
      alterTablespaceOption();
      setState(1822);
      _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;
}

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


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, 64, MySQLParser::RuleAlterTablespaceOption);

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

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

        default:
          break;
        }
        setState(1827);
        sizeNumber();
        break;
      }

      case MySQLParser::AUTOEXTEND_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(1828);
        tsOptionAutoextendSize();
        break;
      }

      case MySQLParser::MAX_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(1829);
        tsOptionMaxSize();
        break;
      }

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

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

      case MySQLParser::ENCRYPTION_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(1832);
        tsOptionEncryption();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  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, 66, MySQLParser::RuleChangeTablespaceOption);

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

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

        default:
          break;
        }
        setState(1839);
        sizeNumber();
        break;
      }

      case MySQLParser::AUTOEXTEND_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(1840);
        tsOptionAutoextendSize();
        break;
      }

      case MySQLParser::MAX_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(1841);
        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, 68, MySQLParser::RuleAlterView);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL) {
      setState(1844);
      viewAlgorithm();
    }
    setState(1848);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(1847);
      definerClause();
    }
    setState(1851);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SQL_SYMBOL) {
      setState(1850);
      viewSuid();
    }
    setState(1853);
    match(MySQLParser::VIEW_SYMBOL);
    setState(1854);
    viewRef();
    setState(1855);
    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::ViewSelectContext* MySQLParser::ViewTailContext::viewSelect() {
  return getRuleContext<MySQLParser::ViewSelectContext>(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, 70, MySQLParser::RuleViewTail);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(1857);
      columnInternalRefList();
    }
    setState(1860);
    match(MySQLParser::AS_SYMBOL);
    setState(1861);
    viewSelect();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ViewSelectContext ------------------------------------------------------------------

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

MySQLParser::QueryExpressionOrParensContext* MySQLParser::ViewSelectContext::queryExpressionOrParens() {
  return getRuleContext<MySQLParser::QueryExpressionOrParensContext>(0);
}

MySQLParser::ViewCheckOptionContext* MySQLParser::ViewSelectContext::viewCheckOption() {
  return getRuleContext<MySQLParser::ViewCheckOptionContext>(0);
}


size_t MySQLParser::ViewSelectContext::getRuleIndex() const {
  return MySQLParser::RuleViewSelect;
}

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

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


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

MySQLParser::ViewSelectContext* MySQLParser::viewSelect() {
  ViewSelectContext *_localctx = _tracker.createInstance<ViewSelectContext>(_ctx, getState());
  enterRule(_localctx, 72, MySQLParser::RuleViewSelect);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::WITH_SYMBOL) {
      setState(1864);
      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, 74, MySQLParser::RuleViewCheckOption);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::CASCADED_SYMBOL || _la == MySQLParser::LOCAL_SYMBOL) {
      setState(1868);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CASCADED_SYMBOL || _la == MySQLParser::LOCAL_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(1871);
    match(MySQLParser::CHECK_SYMBOL);
    setState(1872);
    match(MySQLParser::OPTION_SYMBOL);
   
  }
  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);
}


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, 76, MySQLParser::RuleCreateStatement);

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

    case 2: {
      setState(1876);
      createTable();
      break;
    }

    case 3: {
      setState(1877);
      createFunction();
      break;
    }

    case 4: {
      setState(1878);
      createProcedure();
      break;
    }

    case 5: {
      setState(1879);
      createUdf();
      break;
    }

    case 6: {
      setState(1880);
      createLogfileGroup();
      break;
    }

    case 7: {
      setState(1881);
      createView();
      break;
    }

    case 8: {
      setState(1882);
      createTrigger();
      break;
    }

    case 9: {
      setState(1883);
      createIndex();
      break;
    }

    case 10: {
      setState(1884);
      createServer();
      break;
    }

    case 11: {
      setState(1885);
      createTablespace();
      break;
    }

    case 12: {
      setState(1886);
      createEvent();
      break;
    }

    case 13: {
      setState(1887);

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

    case 14: {
      setState(1889);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(1890);
      createSpatialReference();
      break;
    }

    case 15: {
      setState(1891);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(1892);
      createUndoTablespace();
      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, 78, MySQLParser::RuleCreateDatabase);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
    case 1: {
      setState(1896);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(1899);
    schemaName();
    setState(1903);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1900);
        createDatabaseOption(); 
      }
      setState(1905);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _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, 80, MySQLParser::RuleCreateDatabaseOption);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1907);
      defaultCollation();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1908);

      if (!(serverVersion >= 80016)) throw FailedPredicateException(this, "serverVersion >= 80016");
      setState(1909);
      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::CreateTableOptionsContext* MySQLParser::CreateTableContext::createTableOptions() {
  return getRuleContext<MySQLParser::CreateTableOptionsContext>(0);
}

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

MySQLParser::DuplicateAsQueryExpressionContext* MySQLParser::CreateTableContext::duplicateAsQueryExpression() {
  return getRuleContext<MySQLParser::DuplicateAsQueryExpressionContext>(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, 82, MySQLParser::RuleCreateTable);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::TEMPORARY_SYMBOL) {
      setState(1912);
      match(MySQLParser::TEMPORARY_SYMBOL);
    }
    setState(1915);
    match(MySQLParser::TABLE_SYMBOL);
    setState(1917);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx)) {
    case 1: {
      setState(1916);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(1919);
    tableName();
    setState(1942);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx)) {
    case 1: {
      setState(1924);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx)) {
      case 1: {
        setState(1920);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(1921);
        tableElementList();
        setState(1922);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx)) {
      case 1: {
        setState(1926);
        createTableOptions();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx)) {
      case 1: {
        setState(1929);
        partitionClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
      case 1: {
        setState(1932);
        duplicateAsQueryExpression();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(1935);
      match(MySQLParser::LIKE_SYMBOL);
      setState(1936);
      tableRef();
      break;
    }

    case 3: {
      setState(1937);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(1938);
      match(MySQLParser::LIKE_SYMBOL);
      setState(1939);
      tableRef();
      setState(1940);
      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, 84, MySQLParser::RuleTableElementList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1944);
    tableElement();
    setState(1949);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(1945);
      match(MySQLParser::COMMA_SYMBOL);
      setState(1946);
      tableElement();
      setState(1951);
      _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, 86, MySQLParser::RuleTableElement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1953);
      tableConstraintDef();
      break;
    }

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

  return _localctx;
}

//----------------- DuplicateAsQueryExpressionContext ------------------------------------------------------------------

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

MySQLParser::QueryExpressionOrParensContext* MySQLParser::DuplicateAsQueryExpressionContext::queryExpressionOrParens() {
  return getRuleContext<MySQLParser::QueryExpressionOrParensContext>(0);
}

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

tree::TerminalNode* MySQLParser::DuplicateAsQueryExpressionContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::DuplicateAsQueryExpressionContext::IGNORE_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SYMBOL, 0);
}


size_t MySQLParser::DuplicateAsQueryExpressionContext::getRuleIndex() const {
  return MySQLParser::RuleDuplicateAsQueryExpression;
}

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

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


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

MySQLParser::DuplicateAsQueryExpressionContext* MySQLParser::duplicateAsQueryExpression() {
  DuplicateAsQueryExpressionContext *_localctx = _tracker.createInstance<DuplicateAsQueryExpressionContext>(_ctx, getState());
  enterRule(_localctx, 88, MySQLParser::RuleDuplicateAsQueryExpression);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 117, _ctx)) {
    case 1: {
      setState(1956);
      _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(1960);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 118, _ctx)) {
    case 1: {
      setState(1959);
      match(MySQLParser::AS_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(1962);
    queryExpressionOrParens();
   
  }
  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::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, 90, MySQLParser::RuleQueryExpressionOrParens);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1965);
      queryExpressionParens();
      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, 92, MySQLParser::RuleCreateRoutine);
  size_t _la = 0;

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

    case 2: {
      setState(1970);
      createFunction();
      break;
    }

    case 3: {
      setState(1971);
      createUdf();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == MySQLParser::SEMICOLON_SYMBOL) {
      setState(1974);
      match(MySQLParser::SEMICOLON_SYMBOL);
    }
    setState(1977);
    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::CompoundStatementContext* MySQLParser::CreateProcedureContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateProcedureContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(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, 94, 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(1980);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(1979);
      definerClause();
    }
    setState(1982);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(1983);
    procedureName();
    setState(1984);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(1993);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
    case 1: {
      setState(1985);
      procedureParameter();
      setState(1990);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(1986);
        match(MySQLParser::COMMA_SYMBOL);
        setState(1987);
        procedureParameter();
        setState(1992);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
    setState(1995);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(1999);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1996);
        routineCreateOption(); 
      }
      setState(2001);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
    }
    setState(2002);
    compoundStatement();
   
  }
  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::CompoundStatementContext* MySQLParser::CreateFunctionContext::compoundStatement() {
  return getRuleContext<MySQLParser::CompoundStatementContext>(0);
}

MySQLParser::DefinerClauseContext* MySQLParser::CreateFunctionContext::definerClause() {
  return getRuleContext<MySQLParser::DefinerClauseContext>(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, 96, 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(2005);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2004);
      definerClause();
    }
    setState(2007);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(2008);
    functionName();
    setState(2009);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(2018);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx)) {
    case 1: {
      setState(2010);
      functionParameter();
      setState(2015);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(2011);
        match(MySQLParser::COMMA_SYMBOL);
        setState(2012);
        functionParameter();
        setState(2017);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    default:
      break;
    }
    setState(2020);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(2021);
    match(MySQLParser::RETURNS_SYMBOL);
    setState(2022);
    typeWithOptCollate();
    setState(2026);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2023);
        routineCreateOption(); 
      }
      setState(2028);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx);
    }
    setState(2029);
    compoundStatement();
   
  }
  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);
}


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, 98, MySQLParser::RuleCreateUdf);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::AGGREGATE_SYMBOL) {
      setState(2031);
      match(MySQLParser::AGGREGATE_SYMBOL);
    }
    setState(2034);
    match(MySQLParser::FUNCTION_SYMBOL);
    setState(2035);
    udfName();
    setState(2036);
    match(MySQLParser::RETURNS_SYMBOL);
    setState(2037);
    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(2038);
    match(MySQLParser::SONAME_SYMBOL);
    setState(2039);
    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);
}


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, 100, MySQLParser::RuleRoutineCreateOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2046);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::COMMENT_SYMBOL:
      case MySQLParser::CONTAINS_SYMBOL:
      case MySQLParser::LANGUAGE_SYMBOL:
      case MySQLParser::MODIFIES_SYMBOL:
      case MySQLParser::NO_SYMBOL:
      case MySQLParser::READS_SYMBOL:
      case MySQLParser::SQL_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2041);
        routineOption();
        break;
      }

      case MySQLParser::DETERMINISTIC_SYMBOL:
      case MySQLParser::NOT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2043);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NOT_SYMBOL) {
          setState(2042);
          match(MySQLParser::NOT_SYMBOL);
        }
        setState(2045);
        match(MySQLParser::DETERMINISTIC_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;
}

//----------------- RoutineAlterOptionsContext ------------------------------------------------------------------

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

std::vector<MySQLParser::RoutineCreateOptionContext *> MySQLParser::RoutineAlterOptionsContext::routineCreateOption() {
  return getRuleContexts<MySQLParser::RoutineCreateOptionContext>();
}

MySQLParser::RoutineCreateOptionContext* MySQLParser::RoutineAlterOptionsContext::routineCreateOption(size_t i) {
  return getRuleContext<MySQLParser::RoutineCreateOptionContext>(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, 102, MySQLParser::RuleRoutineAlterOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2049); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(2048);
      routineCreateOption();
      setState(2051); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (((((_la - 75) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 75)) & 4611686018427420673) != 0) || _la == MySQLParser::LANGUAGE_SYMBOL || ((((_la - 347) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 347)) & 83886081) != 0) || _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::SQL_SYMBOL() {
  return getToken(MySQLParser::SQL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoutineOptionContext::LANGUAGE_SYMBOL() {
  return getToken(MySQLParser::LANGUAGE_SYMBOL, 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, 104, MySQLParser::RuleRoutineOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2070);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2053);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::COMMENT_SYMBOL);
        setState(2054);
        textLiteral();
        break;
      }

      case MySQLParser::LANGUAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2055);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::LANGUAGE_SYMBOL);
        setState(2056);
        match(MySQLParser::SQL_SYMBOL);
        break;
      }

      case MySQLParser::NO_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2057);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::NO_SYMBOL);
        setState(2058);
        match(MySQLParser::SQL_SYMBOL);
        break;
      }

      case MySQLParser::CONTAINS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2059);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::CONTAINS_SYMBOL);
        setState(2060);
        match(MySQLParser::SQL_SYMBOL);
        break;
      }

      case MySQLParser::READS_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(2061);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::READS_SYMBOL);
        setState(2062);
        match(MySQLParser::SQL_SYMBOL);
        setState(2063);
        match(MySQLParser::DATA_SYMBOL);
        break;
      }

      case MySQLParser::MODIFIES_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(2064);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::MODIFIES_SYMBOL);
        setState(2065);
        match(MySQLParser::SQL_SYMBOL);
        setState(2066);
        match(MySQLParser::DATA_SYMBOL);
        break;
      }

      case MySQLParser::SQL_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(2067);
        antlrcpp::downCast<RoutineOptionContext *>(_localctx)->option = match(MySQLParser::SQL_SYMBOL);
        setState(2068);
        match(MySQLParser::SECURITY_SYMBOL);
        setState(2069);
        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::CreateIndexTargetContext* MySQLParser::CreateIndexContext::createIndexTarget() {
  return getRuleContext<MySQLParser::CreateIndexTargetContext>(0);
}

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

MySQLParser::IndexNameContext* MySQLParser::CreateIndexContext::indexName() {
  return getRuleContext<MySQLParser::IndexNameContext>(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);
}

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

MySQLParser::IndexTypeClauseContext* MySQLParser::CreateIndexContext::indexTypeClause() {
  return getRuleContext<MySQLParser::IndexTypeClauseContext>(0);
}

MySQLParser::IndexNameAndTypeContext* MySQLParser::CreateIndexContext::indexNameAndType() {
  return getRuleContext<MySQLParser::IndexNameAndTypeContext>(0);
}


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, 106, 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(2073);
    _errHandler->sync(this);

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

    || _la == MySQLParser::ONLINE_SYMBOL) {
      setState(2072);
      onlineOption();
    }
    setState(2116);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INDEX_SYMBOL:
      case MySQLParser::UNIQUE_SYMBOL: {
        setState(2076);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::UNIQUE_SYMBOL) {
          setState(2075);
          match(MySQLParser::UNIQUE_SYMBOL);
        }
        setState(2078);
        antlrcpp::downCast<CreateIndexContext *>(_localctx)->type = match(MySQLParser::INDEX_SYMBOL);
        setState(2087);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 139, _ctx)) {
        case 1: {
          setState(2079);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(2080);
          indexName();
          setState(2082);
          _errHandler->sync(this);

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

          || _la == MySQLParser::USING_SYMBOL) {
            setState(2081);
            indexTypeClause();
          }
          break;
        }

        case 2: {
          setState(2085);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 138, _ctx)) {
          case 1: {
            setState(2084);
            indexNameAndType();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        }
        setState(2089);
        createIndexTarget();
        setState(2093);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2090);
            indexOption(); 
          }
          setState(2095);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 140, _ctx);
        }
        break;
      }

      case MySQLParser::FULLTEXT_SYMBOL: {
        setState(2096);
        antlrcpp::downCast<CreateIndexContext *>(_localctx)->type = match(MySQLParser::FULLTEXT_SYMBOL);
        setState(2097);
        match(MySQLParser::INDEX_SYMBOL);
        setState(2098);
        indexName();
        setState(2099);
        createIndexTarget();
        setState(2103);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2100);
            fulltextIndexOption(); 
          }
          setState(2105);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx);
        }
        break;
      }

      case MySQLParser::SPATIAL_SYMBOL: {
        setState(2106);
        antlrcpp::downCast<CreateIndexContext *>(_localctx)->type = match(MySQLParser::SPATIAL_SYMBOL);
        setState(2107);
        match(MySQLParser::INDEX_SYMBOL);
        setState(2108);
        indexName();
        setState(2109);
        createIndexTarget();
        setState(2113);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2110);
            spatialIndexOption(); 
          }
          setState(2115);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 142, _ctx);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(2119);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
      setState(2118);
      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, 108, MySQLParser::RuleIndexNameAndType);

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 145, _ctx)) {
      case 1: {
        setState(2122);
        match(MySQLParser::USING_SYMBOL);
        setState(2123);
        indexType();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2126);
      indexName();
      setState(2127);
      match(MySQLParser::TYPE_SYMBOL);
      setState(2128);
      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::KeyListVariantsContext* MySQLParser::CreateIndexTargetContext::keyListVariants() {
  return getRuleContext<MySQLParser::KeyListVariantsContext>(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, 110, MySQLParser::RuleCreateIndexTarget);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2132);
    match(MySQLParser::ON_SYMBOL);
    setState(2133);
    tableRef();
    setState(2134);
    keyListVariants();
   
  }
  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);
}

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

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

tree::TerminalNode* MySQLParser::CreateLogfileGroupContext::REDOFILE_SYMBOL() {
  return getToken(MySQLParser::REDOFILE_SYMBOL, 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, 112, MySQLParser::RuleCreateLogfileGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2136);
    match(MySQLParser::LOGFILE_SYMBOL);
    setState(2137);
    match(MySQLParser::GROUP_SYMBOL);
    setState(2138);
    logfileGroupName();
    setState(2139);
    match(MySQLParser::ADD_SYMBOL);
    setState(2140);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::REDOFILE_SYMBOL || _la == MySQLParser::UNDOFILE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2141);
    textLiteral();
    setState(2143);
    _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(2142);
      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, 114, MySQLParser::RuleLogfileGroupOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2145);
    logfileGroupOption();
    setState(2152);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_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 || _la == MySQLParser::COMMA_SYMBOL) {
      setState(2147);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(2146);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(2149);
      logfileGroupOption();
      setState(2154);
      _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, 116, MySQLParser::RuleLogfileGroupOption);

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

      case MySQLParser::REDO_BUFFER_SIZE_SYMBOL:
      case MySQLParser::UNDO_BUFFER_SIZE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2156);
        tsOptionUndoRedoBufferSize();
        break;
      }

      case MySQLParser::NODEGROUP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2157);
        tsOptionNodegroup();
        break;
      }

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

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

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(2160);
        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, 118, MySQLParser::RuleCreateServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2163);
    match(MySQLParser::SERVER_SYMBOL);
    setState(2164);
    serverName();
    setState(2165);
    match(MySQLParser::FOREIGN_SYMBOL);
    setState(2166);
    match(MySQLParser::DATA_SYMBOL);
    setState(2167);
    match(MySQLParser::WRAPPER_SYMBOL);
    setState(2168);
    textOrIdentifier();
    setState(2169);
    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, 120, MySQLParser::RuleServerOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2171);
    match(MySQLParser::OPTIONS_SYMBOL);
    setState(2172);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(2173);
    serverOption();
    setState(2178);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2174);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2175);
      serverOption();
      setState(2180);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2181);
    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, 122, MySQLParser::RuleServerOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2197);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::HOST_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2183);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::HOST_SYMBOL);
        setState(2184);
        textLiteral();
        break;
      }

      case MySQLParser::DATABASE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2185);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::DATABASE_SYMBOL);
        setState(2186);
        textLiteral();
        break;
      }

      case MySQLParser::USER_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2187);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::USER_SYMBOL);
        setState(2188);
        textLiteral();
        break;
      }

      case MySQLParser::PASSWORD_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2189);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::PASSWORD_SYMBOL);
        setState(2190);
        textLiteral();
        break;
      }

      case MySQLParser::SOCKET_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(2191);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::SOCKET_SYMBOL);
        setState(2192);
        textLiteral();
        break;
      }

      case MySQLParser::OWNER_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(2193);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::OWNER_SYMBOL);
        setState(2194);
        textLiteral();
        break;
      }

      case MySQLParser::PORT_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(2195);
        antlrcpp::downCast<ServerOptionContext *>(_localctx)->option = match(MySQLParser::PORT_SYMBOL);
        setState(2196);
        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, 124, MySQLParser::RuleCreateTablespace);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2199);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2200);
    tablespaceName();
    setState(2201);
    tsDataFileName();
    setState(2206);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx)) {
    case 1: {
      setState(2202);
      match(MySQLParser::USE_SYMBOL);
      setState(2203);
      match(MySQLParser::LOGFILE_SYMBOL);
      setState(2204);
      match(MySQLParser::GROUP_SYMBOL);
      setState(2205);
      logfileGroupRef();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 154, _ctx)) {
    case 1: {
      setState(2208);
      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, 126, MySQLParser::RuleCreateUndoTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2211);
    match(MySQLParser::UNDO_SYMBOL);
    setState(2212);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2213);
    tablespaceName();
    setState(2214);
    match(MySQLParser::ADD_SYMBOL);
    setState(2215);
    tsDataFile();
    setState(2217);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(2216);
      undoTableSpaceOptions();
    }
   
  }
  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, 128, MySQLParser::RuleTsDataFileName);

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

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2222);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 156, _ctx)) {
      case 1: {
        setState(2220);
        match(MySQLParser::ADD_SYMBOL);
        setState(2221);
        tsDataFile();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2224);
      match(MySQLParser::ADD_SYMBOL);
      setState(2225);
      tsDataFile();
      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, 130, MySQLParser::RuleTsDataFile);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2228);
    match(MySQLParser::DATAFILE_SYMBOL);
    setState(2229);
    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, 132, MySQLParser::RuleTablespaceOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2231);
    tablespaceOption();
    setState(2238);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 159, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2233);
        _errHandler->sync(this);

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

        default:
          break;
        }
        setState(2235);
        tablespaceOption(); 
      }
      setState(2240);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 159, _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, 134, MySQLParser::RuleTablespaceOption);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2242);
      tsOptionAutoextendSize();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2243);
      tsOptionMaxSize();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2244);
      tsOptionExtentSize();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2245);
      tsOptionNodegroup();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2246);
      tsOptionEngine();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2247);
      tsOptionWait();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(2248);
      tsOptionComment();
      break;
    }

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

      if (!(serverVersion >= 50707)) throw FailedPredicateException(this, "serverVersion >= 50707");
      setState(2250);
      tsOptionFileblockSize();
      break;
    }

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

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2252);
      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, 136, MySQLParser::RuleTsOptionInitialSize);

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

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

    default:
      break;
    }
    setState(2259);
    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, 138, MySQLParser::RuleTsOptionUndoRedoBufferSize);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2261);
    _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(2263);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(2265);
    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, 140, MySQLParser::RuleTsOptionAutoextendSize);

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

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

    default:
      break;
    }
    setState(2271);
    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, 142, MySQLParser::RuleTsOptionMaxSize);

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

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

    default:
      break;
    }
    setState(2277);
    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, 144, MySQLParser::RuleTsOptionExtentSize);

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

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

    default:
      break;
    }
    setState(2283);
    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, 146, MySQLParser::RuleTsOptionNodegroup);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::EQUAL_OPERATOR) {
      setState(2286);
      match(MySQLParser::EQUAL_OPERATOR);
    }
    setState(2289);
    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, 148, MySQLParser::RuleTsOptionEngine);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::STORAGE_SYMBOL) {
      setState(2291);
      match(MySQLParser::STORAGE_SYMBOL);
    }
    setState(2294);
    match(MySQLParser::ENGINE_SYMBOL);
    setState(2296);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(2298);
    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, 150, MySQLParser::RuleTsOptionWait);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2300);
    _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, 152, MySQLParser::RuleTsOptionComment);

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

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

    default:
      break;
    }
    setState(2306);
    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, 154, MySQLParser::RuleTsOptionFileblockSize);

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

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

    default:
      break;
    }
    setState(2312);
    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, 156, MySQLParser::RuleTsOptionEncryption);

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

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

    default:
      break;
    }
    setState(2318);
    textStringLiteral();
   
  }
  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);
}


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, 158, MySQLParser::RuleCreateView);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL || _la == MySQLParser::OR_SYMBOL) {
      setState(2320);
      viewReplaceOrAlgorithm();
    }
    setState(2324);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2323);
      definerClause();
    }
    setState(2327);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SQL_SYMBOL) {
      setState(2326);
      viewSuid();
    }
    setState(2329);
    match(MySQLParser::VIEW_SYMBOL);
    setState(2330);
    viewName();
    setState(2331);
    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, 160, MySQLParser::RuleViewReplaceOrAlgorithm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2339);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::OR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2333);
        match(MySQLParser::OR_SYMBOL);
        setState(2334);
        match(MySQLParser::REPLACE_SYMBOL);
        setState(2336);
        _errHandler->sync(this);

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

      case MySQLParser::ALGORITHM_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2338);
        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, 162, MySQLParser::RuleViewAlgorithm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2341);
    match(MySQLParser::ALGORITHM_SYMBOL);
    setState(2342);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(2343);
    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, 164, MySQLParser::RuleViewSuid);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2345);
    match(MySQLParser::SQL_SYMBOL);
    setState(2346);
    match(MySQLParser::SECURITY_SYMBOL);
    setState(2347);
    _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::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, 166, MySQLParser::RuleCreateTrigger);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2349);
      definerClause();
    }
    setState(2352);
    match(MySQLParser::TRIGGER_SYMBOL);
    setState(2353);
    triggerName();
    setState(2354);
    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(2355);
    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(2356);
    match(MySQLParser::ON_SYMBOL);
    setState(2357);
    tableRef();
    setState(2358);
    match(MySQLParser::FOR_SYMBOL);
    setState(2359);
    match(MySQLParser::EACH_SYMBOL);
    setState(2360);
    match(MySQLParser::ROW_SYMBOL);
    setState(2362);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 178, _ctx)) {
    case 1: {
      setState(2361);
      triggerFollowsPrecedesClause();
      break;
    }

    default:
      break;
    }
    setState(2364);
    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, 168, MySQLParser::RuleTriggerFollowsPrecedesClause);
  size_t _la = 0;

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

    if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
    setState(2367);
    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(2368);
    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);
}

tree::TerminalNode* MySQLParser::CreateEventContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 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, 170, MySQLParser::RuleCreateEvent);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFINER_SYMBOL) {
      setState(2370);
      definerClause();
    }
    setState(2373);
    match(MySQLParser::EVENT_SYMBOL);
    setState(2375);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 180, _ctx)) {
    case 1: {
      setState(2374);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2377);
    eventName();
    setState(2378);
    match(MySQLParser::ON_SYMBOL);
    setState(2379);
    match(MySQLParser::SCHEDULE_SYMBOL);
    setState(2380);
    schedule();
    setState(2387);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ON_SYMBOL) {
      setState(2381);
      match(MySQLParser::ON_SYMBOL);
      setState(2382);
      match(MySQLParser::COMPLETION_SYMBOL);
      setState(2384);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(2383);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(2386);
      match(MySQLParser::PRESERVE_SYMBOL);
    }
    setState(2395);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ENABLE_SYMBOL: {
        setState(2389);
        match(MySQLParser::ENABLE_SYMBOL);
        break;
      }

      case MySQLParser::DISABLE_SYMBOL: {
        setState(2390);
        match(MySQLParser::DISABLE_SYMBOL);
        setState(2393);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ON_SYMBOL) {
          setState(2391);
          match(MySQLParser::ON_SYMBOL);
          setState(2392);
          match(MySQLParser::SLAVE_SYMBOL);
        }
        break;
      }

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

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

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMENT_SYMBOL) {
      setState(2397);
      match(MySQLParser::COMMENT_SYMBOL);
      setState(2398);
      textLiteral();
    }
    setState(2401);
    match(MySQLParser::DO_SYMBOL);
    setState(2402);
    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, 172, MySQLParser::RuleCreateRole);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 186, _ctx)) {
    case 1: {
      setState(2405);
      ifNotExists();
      break;
    }

    default:
      break;
    }
    setState(2408);
    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, 174, MySQLParser::RuleCreateSpatialReference);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2435);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::OR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2410);
        match(MySQLParser::OR_SYMBOL);
        setState(2411);
        match(MySQLParser::REPLACE_SYMBOL);
        setState(2412);
        match(MySQLParser::SPATIAL_SYMBOL);
        setState(2413);
        match(MySQLParser::REFERENCE_SYMBOL);
        setState(2414);
        match(MySQLParser::SYSTEM_SYMBOL);
        setState(2415);
        real_ulonglong_number();
        setState(2419);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::NAME_SYMBOL || ((((_la - 715) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 715)) & 7) != 0)) {
          setState(2416);
          srsAttribute();
          setState(2421);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case MySQLParser::SPATIAL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2422);
        match(MySQLParser::SPATIAL_SYMBOL);
        setState(2423);
        match(MySQLParser::REFERENCE_SYMBOL);
        setState(2424);
        match(MySQLParser::SYSTEM_SYMBOL);
        setState(2426);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 188, _ctx)) {
        case 1: {
          setState(2425);
          ifNotExists();
          break;
        }

        default:
          break;
        }
        setState(2428);
        real_ulonglong_number();
        setState(2432);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::NAME_SYMBOL || ((((_la - 715) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 715)) & 7) != 0)) {
          setState(2429);
          srsAttribute();
          setState(2434);
          _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, 176, MySQLParser::RuleSrsAttribute);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2452);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::NAME_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(2437);
        match(MySQLParser::NAME_SYMBOL);
        setState(2438);
        match(MySQLParser::TEXT_SYMBOL);
        setState(2439);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::DEFINITION_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2440);
        match(MySQLParser::DEFINITION_SYMBOL);
        setState(2441);
        match(MySQLParser::TEXT_SYMBOL);
        setState(2442);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::ORGANIZATION_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(2443);
        match(MySQLParser::ORGANIZATION_SYMBOL);
        setState(2444);
        textStringNoLinebreak();
        setState(2445);
        match(MySQLParser::IDENTIFIED_SYMBOL);
        setState(2446);
        match(MySQLParser::BY_SYMBOL);
        setState(2447);
        real_ulonglong_number();
        break;
      }

      case MySQLParser::DESCRIPTION_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(2449);
        match(MySQLParser::DESCRIPTION_SYMBOL);
        setState(2450);
        match(MySQLParser::TEXT_SYMBOL);
        setState(2451);
        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);
}


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, 178, MySQLParser::RuleDropStatement);

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

    case 2: {
      setState(2456);
      dropEvent();
      break;
    }

    case 3: {
      setState(2457);
      dropFunction();
      break;
    }

    case 4: {
      setState(2458);
      dropProcedure();
      break;
    }

    case 5: {
      setState(2459);
      dropIndex();
      break;
    }

    case 6: {
      setState(2460);
      dropLogfileGroup();
      break;
    }

    case 7: {
      setState(2461);
      dropServer();
      break;
    }

    case 8: {
      setState(2462);
      dropTable();
      break;
    }

    case 9: {
      setState(2463);
      dropTableSpace();
      break;
    }

    case 10: {
      setState(2464);
      dropTrigger();
      break;
    }

    case 11: {
      setState(2465);
      dropView();
      break;
    }

    case 12: {
      setState(2466);

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

    case 13: {
      setState(2468);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(2469);
      dropSpatialReference();
      break;
    }

    case 14: {
      setState(2470);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(2471);
      dropUndoTablespace();
      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, 180, MySQLParser::RuleDropDatabase);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 193, _ctx)) {
    case 1: {
      setState(2475);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2478);
    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, 182, MySQLParser::RuleDropEvent);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 194, _ctx)) {
    case 1: {
      setState(2481);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2484);
    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, 184, MySQLParser::RuleDropFunction);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 195, _ctx)) {
    case 1: {
      setState(2487);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2490);
    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, 186, MySQLParser::RuleDropProcedure);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 196, _ctx)) {
    case 1: {
      setState(2493);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2496);
    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, 188, MySQLParser::RuleDropIndex);
  size_t _la = 0;

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

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

    || _la == MySQLParser::ONLINE_SYMBOL) {
      setState(2498);
      onlineOption();
    }
    setState(2501);
    antlrcpp::downCast<DropIndexContext *>(_localctx)->type = match(MySQLParser::INDEX_SYMBOL);
    setState(2502);
    indexRef();
    setState(2503);
    match(MySQLParser::ON_SYMBOL);
    setState(2504);
    tableRef();
    setState(2506);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ALGORITHM_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
      setState(2505);
      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, 190, MySQLParser::RuleDropLogfileGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2508);
    match(MySQLParser::LOGFILE_SYMBOL);
    setState(2509);
    match(MySQLParser::GROUP_SYMBOL);
    setState(2510);
    logfileGroupRef();
    setState(2521);
    _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(2511);
      dropLogfileGroupOption();
      setState(2518);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL || _la == MySQLParser::COMMA_SYMBOL) {
        setState(2513);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(2512);
          match(MySQLParser::COMMA_SYMBOL);
        }
        setState(2515);
        dropLogfileGroupOption();
        setState(2520);
        _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, 192, MySQLParser::RuleDropLogfileGroupOption);

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

      case MySQLParser::ENGINE_SYMBOL:
      case MySQLParser::STORAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(2524);
        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, 194, MySQLParser::RuleDropServer);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 203, _ctx)) {
    case 1: {
      setState(2528);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2531);
    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, 196, MySQLParser::RuleDropTable);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::TEMPORARY_SYMBOL) {
      setState(2533);
      match(MySQLParser::TEMPORARY_SYMBOL);
    }
    setState(2536);
    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(2538);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
    case 1: {
      setState(2537);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2540);
    tableRefList();
    setState(2542);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL) {
      setState(2541);
      _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, 198, MySQLParser::RuleDropTableSpace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2544);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2545);
    tablespaceRef();
    setState(2556);
    _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(2546);
      dropLogfileGroupOption();
      setState(2553);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::NO_WAIT_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL || _la == MySQLParser::WAIT_SYMBOL || _la == MySQLParser::COMMA_SYMBOL) {
        setState(2548);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(2547);
          match(MySQLParser::COMMA_SYMBOL);
        }
        setState(2550);
        dropLogfileGroupOption();
        setState(2555);
        _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, 200, MySQLParser::RuleDropTrigger);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx)) {
    case 1: {
      setState(2559);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2562);
    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, 202, MySQLParser::RuleDropView);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 211, _ctx)) {
    case 1: {
      setState(2565);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2568);
    viewRefList();
    setState(2570);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL) {
      setState(2569);
      _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, 204, MySQLParser::RuleDropRole);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 213, _ctx)) {
    case 1: {
      setState(2573);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2576);
    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, 206, MySQLParser::RuleDropSpatialReference);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2578);
    match(MySQLParser::SPATIAL_SYMBOL);
    setState(2579);
    match(MySQLParser::REFERENCE_SYMBOL);
    setState(2580);
    match(MySQLParser::SYSTEM_SYMBOL);
    setState(2582);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 214, _ctx)) {
    case 1: {
      setState(2581);
      ifExists();
      break;
    }

    default:
      break;
    }
    setState(2584);
    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, 208, MySQLParser::RuleDropUndoTablespace);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2586);
    match(MySQLParser::UNDO_SYMBOL);
    setState(2587);
    match(MySQLParser::TABLESPACE_SYMBOL);
    setState(2588);
    tablespaceRef();
    setState(2590);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ENGINE_SYMBOL || _la == MySQLParser::STORAGE_SYMBOL) {
      setState(2589);
      undoTableSpaceOptions();
    }
   
  }
  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, 210, MySQLParser::RuleRenameTableStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2592);
    match(MySQLParser::RENAME_SYMBOL);
    setState(2593);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TABLES_SYMBOL

    || _la == MySQLParser::TABLE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2594);
    renamePair();
    setState(2599);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2595);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2596);
      renamePair();
      setState(2601);
      _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, 212, MySQLParser::RuleRenamePair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2602);
    tableRef();
    setState(2603);
    match(MySQLParser::TO_SYMBOL);
    setState(2604);
    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, 214, MySQLParser::RuleTruncateTableStatement);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 217, _ctx)) {
    case 1: {
      setState(2607);
      match(MySQLParser::TABLE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(2610);
    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, 216, MySQLParser::RuleImportStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2612);
    match(MySQLParser::IMPORT_SYMBOL);
    setState(2613);
    match(MySQLParser::TABLE_SYMBOL);
    setState(2614);
    match(MySQLParser::FROM_SYMBOL);
    setState(2615);
    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, 218, MySQLParser::RuleCallStatement);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(2619);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(2621);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 218, _ctx)) {
      case 1: {
        setState(2620);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(2623);
      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, 220, 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(2628);
    _errHandler->sync(this);

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

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

    default:
      break;
    }
    setState(2630);
    match(MySQLParser::DELETE_SYMBOL);
    setState(2634);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 221, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2631);
        deleteStatementOption(); 
      }
      setState(2636);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 221, _ctx);
    }
    setState(2669);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx)) {
    case 1: {
      setState(2637);
      match(MySQLParser::FROM_SYMBOL);
      setState(2661);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 228, _ctx)) {
      case 1: {
        setState(2638);
        tableAliasRefList();
        setState(2639);
        match(MySQLParser::USING_SYMBOL);
        setState(2640);
        tableReferenceList();
        setState(2642);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WHERE_SYMBOL) {
          setState(2641);
          whereClause();
        }
        break;
      }

      case 2: {
        setState(2644);
        tableRef();
        setState(2647);
        _errHandler->sync(this);

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

          if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
          setState(2646);
          tableAlias();
          break;
        }

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

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 224, _ctx)) {
        case 1: {
          setState(2649);
          partitionDelete();
          break;
        }

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

        _la = _input->LA(1);
        if (_la == MySQLParser::WHERE_SYMBOL) {
          setState(2652);
          whereClause();
        }
        setState(2656);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ORDER_SYMBOL) {
          setState(2655);
          orderClause();
        }
        setState(2659);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LIMIT_SYMBOL) {
          setState(2658);
          simpleLimitClause();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(2663);
      tableAliasRefList();
      setState(2664);
      match(MySQLParser::FROM_SYMBOL);
      setState(2665);
      tableReferenceList();
      setState(2667);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WHERE_SYMBOL) {
        setState(2666);
        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, 222, MySQLParser::RulePartitionDelete);

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

    if (!(serverVersion >= 50602)) throw FailedPredicateException(this, "serverVersion >= 50602");
    setState(2672);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(2673);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(2674);
    identifierList();
    setState(2675);
    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, 224, MySQLParser::RuleDeleteStatementOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2677);
    _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, 226, MySQLParser::RuleDoStatement);

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

      if (!(serverVersion < 50709)) throw FailedPredicateException(this, "serverVersion < 50709");
      setState(2681);
      exprList();
      break;
    }

    case 2: {
      setState(2682);

      if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
      setState(2683);
      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, 228, MySQLParser::RuleHandlerStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2686);
    match(MySQLParser::HANDLER_SYMBOL);
    setState(2704);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 236, _ctx)) {
    case 1: {
      setState(2687);
      tableRef();
      setState(2688);
      match(MySQLParser::OPEN_SYMBOL);
      setState(2690);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 232, _ctx)) {
      case 1: {
        setState(2689);
        tableAlias();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(2692);
      identifier();
      setState(2702);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::CLOSE_SYMBOL: {
          setState(2693);
          match(MySQLParser::CLOSE_SYMBOL);
          break;
        }

        case MySQLParser::READ_SYMBOL: {
          setState(2694);
          match(MySQLParser::READ_SYMBOL);
          setState(2695);
          handlerReadOrScan();
          setState(2697);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::WHERE_SYMBOL) {
            setState(2696);
            whereClause();
          }
          setState(2700);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::LIMIT_SYMBOL) {
            setState(2699);
            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, 230, MySQLParser::RuleHandlerReadOrScan);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2716);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 238, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2706);
      _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(2707);
      identifier();
      setState(2714);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::FIRST_SYMBOL:
        case MySQLParser::LAST_SYMBOL:
        case MySQLParser::NEXT_SYMBOL:
        case MySQLParser::PREV_SYMBOL: {
          setState(2708);
          _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(2709);
          _la = _input->LA(1);
          if (!(((((_la - 750) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 750)) & 121) != 0))) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(2710);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(2711);
          values();
          setState(2712);
          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, 232, MySQLParser::RuleInsertStatement);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 239, _ctx)) {
    case 1: {
      setState(2719);
      insertLockOption();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx)) {
    case 1: {
      setState(2722);
      match(MySQLParser::IGNORE_SYMBOL);
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 241, _ctx)) {
    case 1: {
      setState(2725);
      match(MySQLParser::INTO_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(2728);
    tableRef();
    setState(2730);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 242, _ctx)) {
    case 1: {
      setState(2729);
      usePartition();
      break;
    }

    default:
      break;
    }
    setState(2744);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx)) {
    case 1: {
      setState(2732);
      insertFromConstructor();
      setState(2735);
      _errHandler->sync(this);

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

        if (!( serverVersion >= 80018)) throw FailedPredicateException(this, " serverVersion >= 80018");
        setState(2734);
        valuesReference();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(2737);
      match(MySQLParser::SET_SYMBOL);
      setState(2738);
      updateList();
      setState(2741);
      _errHandler->sync(this);

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

        if (!( serverVersion >= 80018)) throw FailedPredicateException(this, " serverVersion >= 80018");
        setState(2740);
        valuesReference();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      setState(2743);
      insertQueryExpression();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == MySQLParser::ON_SYMBOL) {
      setState(2746);
      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, 234, MySQLParser::RuleInsertLockOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2749);
    _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, 236, MySQLParser::RuleInsertFromConstructor);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(2751);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(2753);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _ctx)) {
      case 1: {
        setState(2752);
        fields();
        break;
      }

      default:
        break;
      }
      setState(2755);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
    }
    setState(2758);
    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, 238, MySQLParser::RuleFields);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2760);
    insertIdentifier();
    setState(2765);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2761);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2762);
      insertIdentifier();
      setState(2767);
      _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, 240, MySQLParser::RuleInsertValues);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2768);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::VALUES_SYMBOL

    || _la == MySQLParser::VALUE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(2769);
    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::QueryExpressionOrParensContext* MySQLParser::InsertQueryExpressionContext::queryExpressionOrParens() {
  return getRuleContext<MySQLParser::QueryExpressionOrParensContext>(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, 242, MySQLParser::RuleInsertQueryExpression);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2772);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(2774);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 250, _ctx)) {
      case 1: {
        setState(2773);
        fields();
        break;
      }

      default:
        break;
      }
      setState(2776);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(2777);
      queryExpressionOrParens();
      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, 244, MySQLParser::RuleValueList);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      setState(2781);
      values();
      break;
    }

    default:
      break;
    }
    setState(2784);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(2793);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 254, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2785);
        match(MySQLParser::COMMA_SYMBOL);
        setState(2786);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(2788);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx)) {
        case 1: {
          setState(2787);
          values();
          break;
        }

        default:
          break;
        }
        setState(2790);
        match(MySQLParser::CLOSE_PAR_SYMBOL); 
      }
      setState(2795);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 254, _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, 246, MySQLParser::RuleValues);
  size_t _la = 0;

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

    case 2: {
      setState(2797);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(2807);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2800);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2803);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 256, _ctx)) {
      case 1: {
        setState(2801);
        expr(0);
        break;
      }

      case 2: {
        setState(2802);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(2809);
      _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, 248, MySQLParser::RuleValuesReference);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(2812);
      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, 250, MySQLParser::RuleInsertUpdateList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2815);
    match(MySQLParser::ON_SYMBOL);
    setState(2816);
    match(MySQLParser::DUPLICATE_SYMBOL);
    setState(2817);
    match(MySQLParser::KEY_SYMBOL);
    setState(2818);
    match(MySQLParser::UPDATE_SYMBOL);
    setState(2819);
    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);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::INFILE_SYMBOL() {
  return getToken(MySQLParser::INFILE_SYMBOL, 0);
}

MySQLParser::TextLiteralContext* MySQLParser::LoadStatementContext::textLiteral() {
  return getRuleContext<MySQLParser::TextLiteralContext>(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);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

MySQLParser::UsePartitionContext* MySQLParser::LoadStatementContext::usePartition() {
  return getRuleContext<MySQLParser::UsePartitionContext>(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);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::LOW_PRIORITY_SYMBOL() {
  return getToken(MySQLParser::LOW_PRIORITY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::LoadStatementContext::CONCURRENT_SYMBOL() {
  return getToken(MySQLParser::CONCURRENT_SYMBOL, 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, 252, MySQLParser::RuleLoadStatement);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::CONCURRENT_SYMBOL || _la == MySQLParser::LOW_PRIORITY_SYMBOL) {
      setState(2823);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CONCURRENT_SYMBOL || _la == MySQLParser::LOW_PRIORITY_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(2827);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LOCAL_SYMBOL) {
      setState(2826);
      match(MySQLParser::LOCAL_SYMBOL);
    }
    setState(2829);
    match(MySQLParser::INFILE_SYMBOL);
    setState(2830);
    textLiteral();
    setState(2832);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::REPLACE_SYMBOL) {
      setState(2831);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::REPLACE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(2834);
    match(MySQLParser::INTO_SYMBOL);
    setState(2835);
    match(MySQLParser::TABLE_SYMBOL);
    setState(2836);
    tableRef();
    setState(2838);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 262, _ctx)) {
    case 1: {
      setState(2837);
      usePartition();
      break;
    }

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

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

    || _la == MySQLParser::CHAR_SYMBOL) {
      setState(2840);
      charsetClause();
    }
    setState(2844);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ROWS_SYMBOL) {
      setState(2843);
      xmlRowsIdentifiedBy();
    }
    setState(2847);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COLUMNS_SYMBOL) {
      setState(2846);
      fieldsClause();
    }
    setState(2850);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LINES_SYMBOL) {
      setState(2849);
      linesClause();
    }
    setState(2852);
    loadDataFileTail();
   
  }
  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, 254, MySQLParser::RuleDataOrXml);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2854);
    _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;
}

//----------------- 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, 256, MySQLParser::RuleXmlRowsIdentifiedBy);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2856);
    match(MySQLParser::ROWS_SYMBOL);
    setState(2857);
    match(MySQLParser::IDENTIFIED_SYMBOL);
    setState(2858);
    match(MySQLParser::BY_SYMBOL);
    setState(2859);
    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, 258, MySQLParser::RuleLoadDataFileTail);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::IGNORE_SYMBOL) {
      setState(2861);
      match(MySQLParser::IGNORE_SYMBOL);
      setState(2862);
      match(MySQLParser::INT_NUMBER);
      setState(2863);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LINES_SYMBOL || _la == MySQLParser::ROWS_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(2867);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(2866);
      loadDataFileTargetList();
    }
    setState(2871);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::SET_SYMBOL) {
      setState(2869);
      match(MySQLParser::SET_SYMBOL);
      setState(2870);
      updateList();
    }
   
  }
  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, 260, MySQLParser::RuleLoadDataFileTargetList);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 270, _ctx)) {
    case 1: {
      setState(2874);
      fieldOrVariableList();
      break;
    }

    default:
      break;
    }
    setState(2877);
    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, 262, MySQLParser::RuleFieldOrVariableList);
  size_t _la = 0;

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

    case 2: {
      setState(2880);
      userVariable();
      break;
    }

    default:
      break;
    }
    setState(2890);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(2883);
      match(MySQLParser::COMMA_SYMBOL);
      setState(2886);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 272, _ctx)) {
      case 1: {
        setState(2884);
        columnRef();
        break;
      }

      case 2: {
        setState(2885);
        userVariable();
        break;
      }

      default:
        break;
      }
      setState(2892);
      _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;
}

//----------------- 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, 264, MySQLParser::RuleReplaceStatement);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 274, _ctx)) {
    case 1: {
      setState(2894);
      _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(2898);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 275, _ctx)) {
    case 1: {
      setState(2897);
      match(MySQLParser::INTO_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(2900);
    tableRef();
    setState(2902);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 276, _ctx)) {
    case 1: {
      setState(2901);
      usePartition();
      break;
    }

    default:
      break;
    }
    setState(2908);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 277, _ctx)) {
    case 1: {
      setState(2904);
      insertFromConstructor();
      break;
    }

    case 2: {
      setState(2905);
      match(MySQLParser::SET_SYMBOL);
      setState(2906);
      updateList();
      break;
    }

    case 3: {
      setState(2907);
      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::QueryExpressionParensContext* MySQLParser::SelectStatementContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(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, 266, MySQLParser::RuleSelectStatement);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
        setState(2911);
        lockingClauseList();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2914);
      queryExpressionParens();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2915);
      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);
}


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, 268, MySQLParser::RuleSelectStatementWithInto);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2930);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 281, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2918);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(2919);
      selectStatementWithInto();
      setState(2920);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2922);
      queryExpression();
      setState(2923);
      intoClause();
      setState(2925);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
        setState(2924);
        lockingClauseList();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2927);
      lockingClauseList();
      setState(2928);
      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::QueryExpressionParensContext* MySQLParser::QueryExpressionContext::queryExpressionParens() {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(0);
}

MySQLParser::WithClauseContext* MySQLParser::QueryExpressionContext::withClause() {
  return getRuleContext<MySQLParser::WithClauseContext>(0);
}

MySQLParser::ProcedureAnalyseClauseContext* MySQLParser::QueryExpressionContext::procedureAnalyseClause() {
  return getRuleContext<MySQLParser::ProcedureAnalyseClauseContext>(0);
}

MySQLParser::OrderClauseContext* MySQLParser::QueryExpressionContext::orderClause() {
  return getRuleContext<MySQLParser::OrderClauseContext>(0);
}

MySQLParser::LimitClauseContext* MySQLParser::QueryExpressionContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(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, 270, MySQLParser::RuleQueryExpression);

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

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

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

    default:
      break;
    }
    setState(2950);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 287, _ctx)) {
    case 1: {
      setState(2936);
      queryExpressionBody();
      setState(2938);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 283, _ctx)) {
      case 1: {
        setState(2937);
        orderClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 284, _ctx)) {
      case 1: {
        setState(2940);
        limitClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(2943);
      queryExpressionParens();
      setState(2945);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 285, _ctx)) {
      case 1: {
        setState(2944);
        orderClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 286, _ctx)) {
      case 1: {
        setState(2947);
        limitClause();
        break;
      }

      default:
        break;
      }
      break;
    }

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

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

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(2953);
      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) {
}

std::vector<MySQLParser::QueryPrimaryContext *> MySQLParser::QueryExpressionBodyContext::queryPrimary() {
  return getRuleContexts<MySQLParser::QueryPrimaryContext>();
}

MySQLParser::QueryPrimaryContext* MySQLParser::QueryExpressionBodyContext::queryPrimary(size_t i) {
  return getRuleContext<MySQLParser::QueryPrimaryContext>(i);
}

std::vector<MySQLParser::QueryExpressionParensContext *> MySQLParser::QueryExpressionBodyContext::queryExpressionParens() {
  return getRuleContexts<MySQLParser::QueryExpressionParensContext>();
}

MySQLParser::QueryExpressionParensContext* MySQLParser::QueryExpressionBodyContext::queryExpressionParens(size_t i) {
  return getRuleContext<MySQLParser::QueryExpressionParensContext>(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<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, 272, MySQLParser::RuleQueryExpressionBody);

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

    case 2: {
      setState(2957);
      queryExpressionParens();
      setState(2958);
      match(MySQLParser::UNION_SYMBOL);
      setState(2960);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 289, _ctx)) {
      case 1: {
        setState(2959);
        unionOption();
        break;
      }

      default:
        break;
      }
      setState(2964);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 290, _ctx)) {
      case 1: {
        setState(2962);
        queryPrimary();
        break;
      }

      case 2: {
        setState(2963);
        queryExpressionParens();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
    setState(2978);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2968);
        match(MySQLParser::UNION_SYMBOL);
        setState(2970);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 292, _ctx)) {
        case 1: {
          setState(2969);
          unionOption();
          break;
        }

        default:
          break;
        }
        setState(2974);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx)) {
        case 1: {
          setState(2972);
          queryPrimary();
          break;
        }

        case 2: {
          setState(2973);
          queryExpressionParens();
          break;
        }

        default:
          break;
        } 
      }
      setState(2980);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _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::QueryExpressionContext* MySQLParser::QueryExpressionParensContext::queryExpression() {
  return getRuleContext<MySQLParser::QueryExpressionContext>(0);
}

MySQLParser::LockingClauseListContext* MySQLParser::QueryExpressionParensContext::lockingClauseList() {
  return getRuleContext<MySQLParser::LockingClauseListContext>(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, 274, MySQLParser::RuleQueryExpressionParens);
  size_t _la = 0;

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

    case 2: {
      setState(2983);
      queryExpression();
      setState(2985);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL || _la == MySQLParser::LOCK_SYMBOL) {
        setState(2984);
        lockingClauseList();
      }
      break;
    }

    default:
      break;
    }
    setState(2989);
    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, 276, MySQLParser::RuleQueryPrimary);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2992);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(2993);
      tableValueConstructor();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2994);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(2995);
      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);
}


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, 278, MySQLParser::RuleQuerySpecification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2998);
    match(MySQLParser::SELECT_SYMBOL);
    setState(3002);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2999);
        selectOption(); 
      }
      setState(3004);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx);
    }
    setState(3005);
    selectItemList();
    setState(3007);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 299, _ctx)) {
    case 1: {
      setState(3006);
      intoClause();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 300, _ctx)) {
    case 1: {
      setState(3009);
      fromClause();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx)) {
    case 1: {
      setState(3012);
      whereClause();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 302, _ctx)) {
    case 1: {
      setState(3015);
      groupByClause();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 303, _ctx)) {
    case 1: {
      setState(3018);
      havingClause();
      break;
    }

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

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3022);
      windowClause();
      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, 280, MySQLParser::RuleSubquery);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3025);
    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, 282, MySQLParser::RuleQuerySpecOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3027);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ALL_SYMBOL || _la == MySQLParser::DISTINCT_SYMBOL || _la == MySQLParser::HIGH_PRIORITY_SYMBOL || ((((_la - 531) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 531)) & 16777259) != 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, 284, MySQLParser::RuleLimitClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3029);
    match(MySQLParser::LIMIT_SYMBOL);
    setState(3030);
    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, 286, MySQLParser::RuleSimpleLimitClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3032);
    match(MySQLParser::LIMIT_SYMBOL);
    setState(3033);
    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, 288, MySQLParser::RuleLimitOptions);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 305, _ctx)) {
    case 1: {
      setState(3036);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::OFFSET_SYMBOL || _la == MySQLParser::COMMA_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3037);
      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, 290, MySQLParser::RuleLimitOption);
  size_t _la = 0;

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3041);
      _la = _input->LA(1);
      if (!(((((_la - 747) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 747)) & 1099511627783) != 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;
}

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

MySQLParser::TextStringLiteralContext* MySQLParser::IntoClauseContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::IntoClauseContext::DUMPFILE_SYMBOL() {
  return getToken(MySQLParser::DUMPFILE_SYMBOL, 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::CharsetClauseContext* MySQLParser::IntoClauseContext::charsetClause() {
  return getRuleContext<MySQLParser::CharsetClauseContext>(0);
}

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


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, 292, MySQLParser::RuleIntoClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3044);
    match(MySQLParser::INTO_SYMBOL);
    setState(3072);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx)) {
    case 1: {
      setState(3045);
      match(MySQLParser::OUTFILE_SYMBOL);
      setState(3046);
      textStringLiteral();
      setState(3048);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx)) {
      case 1: {
        setState(3047);
        charsetClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 308, _ctx)) {
      case 1: {
        setState(3050);
        fieldsClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 309, _ctx)) {
      case 1: {
        setState(3053);
        linesClause();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(3056);
      match(MySQLParser::DUMPFILE_SYMBOL);
      setState(3057);
      textStringLiteral();
      break;
    }

    case 3: {
      setState(3060);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 310, _ctx)) {
      case 1: {
        setState(3058);
        textOrIdentifier();
        break;
      }

      case 2: {
        setState(3059);
        userVariable();
        break;
      }

      default:
        break;
      }
      setState(3069);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 312, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(3062);
          match(MySQLParser::COMMA_SYMBOL);
          setState(3065);
          _errHandler->sync(this);
          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _ctx)) {
          case 1: {
            setState(3063);
            textOrIdentifier();
            break;
          }

          case 2: {
            setState(3064);
            userVariable();
            break;
          }

          default:
            break;
          } 
        }
        setState(3071);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 312, _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, 294, MySQLParser::RuleProcedureAnalyseClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3074);
    match(MySQLParser::PROCEDURE_SYMBOL);
    setState(3075);
    match(MySQLParser::ANALYSE_SYMBOL);
    setState(3076);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3082);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::INT_NUMBER) {
      setState(3077);
      match(MySQLParser::INT_NUMBER);
      setState(3080);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(3078);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3079);
        match(MySQLParser::INT_NUMBER);
      }
    }
    setState(3084);
    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, 296, MySQLParser::RuleHavingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3086);
    match(MySQLParser::HAVING_SYMBOL);
    setState(3087);
    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, 298, MySQLParser::RuleWindowClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3089);
    match(MySQLParser::WINDOW_SYMBOL);
    setState(3090);
    windowDefinition();
    setState(3095);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3091);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3092);
        windowDefinition(); 
      }
      setState(3097);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _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, 300, MySQLParser::RuleWindowDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3098);
    windowName();
    setState(3099);
    match(MySQLParser::AS_SYMBOL);
    setState(3100);
    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, 302, MySQLParser::RuleWindowSpec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3102);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3103);
    windowSpecDetails();
    setState(3104);
    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, 304, MySQLParser::RuleWindowSpecDetails);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 317, _ctx)) {
    case 1: {
      setState(3106);
      windowName();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == MySQLParser::PARTITION_SYMBOL) {
      setState(3109);
      match(MySQLParser::PARTITION_SYMBOL);
      setState(3110);
      match(MySQLParser::BY_SYMBOL);
      setState(3111);
      orderList();
    }
    setState(3115);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ORDER_SYMBOL) {
      setState(3114);
      orderClause();
    }
    setState(3118);
    _errHandler->sync(this);

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

    || _la == MySQLParser::ROWS_SYMBOL || _la == MySQLParser::GROUPS_SYMBOL) {
      setState(3117);
      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, 306, MySQLParser::RuleWindowFrameClause);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::EXCLUDE_SYMBOL) {
      setState(3122);
      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, 308, MySQLParser::RuleWindowFrameUnits);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3125);
    _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, 310, MySQLParser::RuleWindowFrameExtent);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3129);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CURRENT_SYMBOL:
      case MySQLParser::INTERVAL_SYMBOL:
      case MySQLParser::UNBOUNDED_SYMBOL:
      case MySQLParser::INT_NUMBER:
      case MySQLParser::LONG_NUMBER:
      case MySQLParser::ULONGLONG_NUMBER:
      case MySQLParser::PARAM_MARKER:
      case MySQLParser::DECIMAL_NUMBER:
      case MySQLParser::FLOAT_NUMBER: {
        enterOuterAlt(_localctx, 1);
        setState(3127);
        windowFrameStart();
        break;
      }

      case MySQLParser::BETWEEN_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3128);
        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::Ulonglong_numberContext* MySQLParser::WindowFrameStartContext::ulonglong_number() {
  return getRuleContext<MySQLParser::Ulonglong_numberContext>(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, 312, MySQLParser::RuleWindowFrameStart);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3145);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UNBOUNDED_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3131);
        match(MySQLParser::UNBOUNDED_SYMBOL);
        setState(3132);
        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(3133);
        ulonglong_number();
        setState(3134);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::PARAM_MARKER: {
        enterOuterAlt(_localctx, 3);
        setState(3136);
        match(MySQLParser::PARAM_MARKER);
        setState(3137);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::INTERVAL_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(3138);
        match(MySQLParser::INTERVAL_SYMBOL);
        setState(3139);
        expr(0);
        setState(3140);
        interval();
        setState(3141);
        match(MySQLParser::PRECEDING_SYMBOL);
        break;
      }

      case MySQLParser::CURRENT_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(3143);
        match(MySQLParser::CURRENT_SYMBOL);
        setState(3144);
        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, 314, MySQLParser::RuleWindowFrameBetween);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3147);
    match(MySQLParser::BETWEEN_SYMBOL);
    setState(3148);
    windowFrameBound();
    setState(3149);
    match(MySQLParser::AND_SYMBOL);
    setState(3150);
    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::Ulonglong_numberContext* MySQLParser::WindowFrameBoundContext::ulonglong_number() {
  return getRuleContext<MySQLParser::Ulonglong_numberContext>(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, 316, MySQLParser::RuleWindowFrameBound);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3153);
      match(MySQLParser::UNBOUNDED_SYMBOL);
      setState(3154);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3155);
      ulonglong_number();
      setState(3156);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3158);
      match(MySQLParser::PARAM_MARKER);
      setState(3159);
      match(MySQLParser::FOLLOWING_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3160);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(3161);
      expr(0);
      setState(3162);
      interval();
      setState(3163);
      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, 318, MySQLParser::RuleWindowFrameExclusion);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3167);
    match(MySQLParser::EXCLUDE_SYMBOL);
    setState(3174);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CURRENT_SYMBOL: {
        setState(3168);
        match(MySQLParser::CURRENT_SYMBOL);
        setState(3169);
        match(MySQLParser::ROW_SYMBOL);
        break;
      }

      case MySQLParser::GROUP_SYMBOL: {
        setState(3170);
        match(MySQLParser::GROUP_SYMBOL);
        break;
      }

      case MySQLParser::TIES_SYMBOL: {
        setState(3171);
        match(MySQLParser::TIES_SYMBOL);
        break;
      }

      case MySQLParser::NO_SYMBOL: {
        setState(3172);
        match(MySQLParser::NO_SYMBOL);
        setState(3173);
        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, 320, MySQLParser::RuleWithClause);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 326, _ctx)) {
    case 1: {
      setState(3177);
      match(MySQLParser::RECURSIVE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3180);
    commonTableExpression();
    setState(3185);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3181);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3182);
        commonTableExpression(); 
      }
      setState(3187);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _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, 322, MySQLParser::RuleCommonTableExpression);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(3189);
      columnInternalRefList();
    }
    setState(3192);
    match(MySQLParser::AS_SYMBOL);
    setState(3193);
    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);
}


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, 324, MySQLParser::RuleGroupByClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3195);
    match(MySQLParser::GROUP_SYMBOL);
    setState(3196);
    match(MySQLParser::BY_SYMBOL);
    setState(3197);
    orderList();
    setState(3199);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 329, _ctx)) {
    case 1: {
      setState(3198);
      olapOption();
      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, 326, MySQLParser::RuleOlapOption);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3203);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(3204);
      match(MySQLParser::WITH_SYMBOL);
      setState(3205);
      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, 328, MySQLParser::RuleOrderClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3208);
    match(MySQLParser::ORDER_SYMBOL);
    setState(3209);
    match(MySQLParser::BY_SYMBOL);
    setState(3210);
    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, 330, MySQLParser::RuleDirection);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3212);
    _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, 332, MySQLParser::RuleFromClause);

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

    case 2: {
      setState(3216);
      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, 334, MySQLParser::RuleTableReferenceList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3219);
    tableReference();
    setState(3224);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 332, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3220);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3221);
        tableReference(); 
      }
      setState(3226);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 332, _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, 336, MySQLParser::RuleTableValueConstructor);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3227);
    match(MySQLParser::VALUES_SYMBOL);
    setState(3228);
    rowValueExplicit();
    setState(3233);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 333, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3229);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3230);
        rowValueExplicit(); 
      }
      setState(3235);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 333, _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, 338, MySQLParser::RuleExplicitTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3236);
    match(MySQLParser::TABLE_SYMBOL);
    setState(3237);
    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, 340, MySQLParser::RuleRowValueExplicit);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 334, _ctx)) {
    case 1: {
      setState(3241);
      values();
      break;
    }

    default:
      break;
    }
    setState(3244);
    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, 342, MySQLParser::RuleSelectOption);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3247);
      match(MySQLParser::SQL_NO_CACHE_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3248);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(3249);
      match(MySQLParser::SQL_CACHE_SYMBOL);
      break;
    }

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

      if (!(serverVersion >= 50704 && serverVersion < 50708)) throw FailedPredicateException(this, "serverVersion >= 50704 && serverVersion < 50708");
      setState(3251);
      match(MySQLParser::MAX_STATEMENT_TIME_SYMBOL);
      setState(3252);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(3253);
      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, 344, MySQLParser::RuleLockingClauseList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3257); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(3256);
      lockingClause();
      setState(3259); 
      _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, 346, MySQLParser::RuleLockingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3276);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FOR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3261);
        match(MySQLParser::FOR_SYMBOL);
        setState(3262);
        lockStrengh();
        setState(3266);
        _errHandler->sync(this);

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

          if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
          setState(3264);
          match(MySQLParser::OF_SYMBOL);
          setState(3265);
          tableAliasRefList();
          break;
        }

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

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

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

        default:
          break;
        }
        break;
      }

      case MySQLParser::LOCK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3272);
        match(MySQLParser::LOCK_SYMBOL);
        setState(3273);
        match(MySQLParser::IN_SYMBOL);
        setState(3274);
        match(MySQLParser::SHARE_SYMBOL);
        setState(3275);
        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, 348, MySQLParser::RuleLockStrengh);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3279);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3280);
      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, 350, MySQLParser::RuleLockedRowAction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3286);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::SKIP_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3283);
        match(MySQLParser::SKIP_SYMBOL);
        setState(3284);
        match(MySQLParser::LOCKED_SYMBOL);
        break;
      }

      case MySQLParser::NOWAIT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3285);
        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, 352, MySQLParser::RuleSelectItemList);

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

    case 2: {
      setState(3289);
      match(MySQLParser::MULT_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(3296);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 343, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3292);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3293);
        selectItem(); 
      }
      setState(3298);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 343, _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, 354, MySQLParser::RuleSelectItem);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3300);
      expr(0);
      setState(3302);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 344, _ctx)) {
      case 1: {
        setState(3301);
        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, 356, MySQLParser::RuleSelectAlias);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 346, _ctx)) {
    case 1: {
      setState(3306);
      match(MySQLParser::AS_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3311);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 347, _ctx)) {
    case 1: {
      setState(3309);
      identifier();
      break;
    }

    case 2: {
      setState(3310);
      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, 358, MySQLParser::RuleWhereClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3313);
    match(MySQLParser::WHERE_SYMBOL);
    setState(3314);
    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, 360, MySQLParser::RuleTableReference);

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

    case 2: {
      setState(3317);
      match(MySQLParser::OPEN_CURLY_SYMBOL);
      setState(3321);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 348, _ctx)) {
      case 1: {
        setState(3318);

        if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
        setState(3319);
        identifier();
        break;
      }

      case 2: {
        setState(3320);
        match(MySQLParser::OJ_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(3323);
      escapedTableReference();
      setState(3324);
      match(MySQLParser::CLOSE_CURLY_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3331);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 350, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3328);
        joinedTable(); 
      }
      setState(3333);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 350, _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, 362, MySQLParser::RuleEscapedTableReference);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3334);
    tableFactor();
    setState(3338);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::CROSS_SYMBOL || ((((_la - 239) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 239)) & 8594128897) != 0) || _la == MySQLParser::NATURAL_SYMBOL || _la == MySQLParser::RIGHT_SYMBOL || _la == MySQLParser::STRAIGHT_JOIN_SYMBOL) {
      setState(3335);
      joinedTable();
      setState(3340);
      _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, 364, MySQLParser::RuleJoinedTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3360);
    _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(3341);
        innerJoinType();
        setState(3342);
        tableReference();
        setState(3347);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 352, _ctx)) {
        case 1: {
          setState(3343);
          match(MySQLParser::ON_SYMBOL);
          setState(3344);
          expr(0);
          break;
        }

        case 2: {
          setState(3345);
          match(MySQLParser::USING_SYMBOL);
          setState(3346);
          identifierListWithParentheses();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::LEFT_SYMBOL:
      case MySQLParser::RIGHT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3349);
        outerJoinType();
        setState(3350);
        tableReference();
        setState(3355);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::ON_SYMBOL: {
            setState(3351);
            match(MySQLParser::ON_SYMBOL);
            setState(3352);
            expr(0);
            break;
          }

          case MySQLParser::USING_SYMBOL: {
            setState(3353);
            match(MySQLParser::USING_SYMBOL);
            setState(3354);
            identifierListWithParentheses();
            break;
          }

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

      case MySQLParser::NATURAL_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(3357);
        naturalJoinType();
        setState(3358);
        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, 366, MySQLParser::RuleNaturalJoinType);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == MySQLParser::INNER_SYMBOL) {
        setState(3363);
        match(MySQLParser::INNER_SYMBOL);
      }
      setState(3366);
      match(MySQLParser::JOIN_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3367);
      match(MySQLParser::NATURAL_SYMBOL);
      setState(3368);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LEFT_SYMBOL || _la == MySQLParser::RIGHT_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3370);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::OUTER_SYMBOL) {
        setState(3369);
        match(MySQLParser::OUTER_SYMBOL);
      }
      setState(3372);
      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, 368, MySQLParser::RuleInnerJoinType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3380);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CROSS_SYMBOL:
      case MySQLParser::INNER_SYMBOL:
      case MySQLParser::JOIN_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3376);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::CROSS_SYMBOL || _la == MySQLParser::INNER_SYMBOL) {
          setState(3375);
          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(3378);
        match(MySQLParser::JOIN_SYMBOL);
        break;
      }

      case MySQLParser::STRAIGHT_JOIN_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3379);
        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, 370, MySQLParser::RuleOuterJoinType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3382);
    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(3384);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OUTER_SYMBOL) {
      setState(3383);
      match(MySQLParser::OUTER_SYMBOL);
    }
    setState(3386);
    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, 372, MySQLParser::RuleTableFactor);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3389);
      singleTableParens();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3390);
      derivedTable();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3391);
      tableReferenceListParens();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3392);

      if (!(serverVersion >= 80004)) throw FailedPredicateException(this, "serverVersion >= 80004");
      setState(3393);
      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);
}


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, 374, MySQLParser::RuleSingleTable);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 362, _ctx)) {
    case 1: {
      setState(3397);
      usePartition();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 363, _ctx)) {
    case 1: {
      setState(3400);
      tableAlias();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 364, _ctx)) {
    case 1: {
      setState(3403);
      indexHintList();
      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, 376, MySQLParser::RuleSingleTableParens);

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

    case 2: {
      setState(3408);
      singleTableParens();
      break;
    }

    default:
      break;
    }
    setState(3411);
    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, 378, MySQLParser::RuleDerivedTable);

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _ctx)) {
      case 1: {
        setState(3414);
        tableAlias();
        break;
      }

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

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

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

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3421);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(3422);
      match(MySQLParser::LATERAL_SYMBOL);
      setState(3423);
      subquery();
      setState(3425);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 368, _ctx)) {
      case 1: {
        setState(3424);
        tableAlias();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _ctx)) {
      case 1: {
        setState(3427);
        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, 380, MySQLParser::RuleTableReferenceListParens);

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

    case 2: {
      setState(3434);
      tableReferenceListParens();
      break;
    }

    default:
      break;
    }
    setState(3437);
    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, 382, MySQLParser::RuleTableFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3439);
    match(MySQLParser::JSON_TABLE_SYMBOL);
    setState(3440);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3441);
    expr(0);
    setState(3442);
    match(MySQLParser::COMMA_SYMBOL);
    setState(3443);
    textStringLiteral();
    setState(3444);
    columnsClause();
    setState(3445);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(3447);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _ctx)) {
    case 1: {
      setState(3446);
      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, 384, MySQLParser::RuleColumnsClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3449);
    match(MySQLParser::COLUMNS_SYMBOL);
    setState(3450);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(3451);
    jtColumn();
    setState(3456);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3452);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3453);
      jtColumn();
      setState(3458);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(3459);
    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::OnEmptyOrErrorContext* MySQLParser::JtColumnContext::onEmptyOrError() {
  return getRuleContext<MySQLParser::OnEmptyOrErrorContext>(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, 386, MySQLParser::RuleJtColumn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3484);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 377, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3461);
      identifier();
      setState(3462);
      match(MySQLParser::FOR_SYMBOL);
      setState(3463);
      match(MySQLParser::ORDINALITY_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3465);
      identifier();
      setState(3466);
      dataType();
      setState(3469);
      _errHandler->sync(this);

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

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

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

      _la = _input->LA(1);
      if (_la == MySQLParser::EXISTS_SYMBOL) {
        setState(3471);
        match(MySQLParser::EXISTS_SYMBOL);
      }
      setState(3474);
      match(MySQLParser::PATH_SYMBOL);
      setState(3475);
      textStringLiteral();
      setState(3477);
      _errHandler->sync(this);

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

      || _la == MySQLParser::ERROR_SYMBOL || _la == MySQLParser::NULL_SYMBOL) {
        setState(3476);
        onEmptyOrError();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3479);
      match(MySQLParser::NESTED_SYMBOL);
      setState(3480);
      match(MySQLParser::PATH_SYMBOL);
      setState(3481);
      textStringLiteral();
      setState(3482);
      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, 388, MySQLParser::RuleOnEmptyOrError);
  size_t _la = 0;

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

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

      || _la == MySQLParser::ERROR_SYMBOL || _la == MySQLParser::NULL_SYMBOL) {
        setState(3487);
        onError();
      }
      break;
    }

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

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

      || _la == MySQLParser::ERROR_SYMBOL || _la == MySQLParser::NULL_SYMBOL) {
        setState(3491);
        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::JtOnResponseContext* MySQLParser::OnEmptyContext::jtOnResponse() {
  return getRuleContext<MySQLParser::JtOnResponseContext>(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, 390, MySQLParser::RuleOnEmpty);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3496);
    jtOnResponse();
    setState(3497);
    match(MySQLParser::ON_SYMBOL);
    setState(3498);
    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::JtOnResponseContext* MySQLParser::OnErrorContext::jtOnResponse() {
  return getRuleContext<MySQLParser::JtOnResponseContext>(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, 392, MySQLParser::RuleOnError);

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

  return _localctx;
}

//----------------- JtOnResponseContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::JtOnResponseContext::ERROR_SYMBOL() {
  return getToken(MySQLParser::ERROR_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::JtOnResponseContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}

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

MySQLParser::TextStringLiteralContext* MySQLParser::JtOnResponseContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}


size_t MySQLParser::JtOnResponseContext::getRuleIndex() const {
  return MySQLParser::RuleJtOnResponse;
}

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

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


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

MySQLParser::JtOnResponseContext* MySQLParser::jtOnResponse() {
  JtOnResponseContext *_localctx = _tracker.createInstance<JtOnResponseContext>(_ctx, getState());
  enterRule(_localctx, 394, MySQLParser::RuleJtOnResponse);

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

      case MySQLParser::NULL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3505);
        match(MySQLParser::NULL_SYMBOL);
        break;
      }

      case MySQLParser::DEFAULT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(3506);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(3507);
        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, 396, MySQLParser::RuleUnionOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3510);
    _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, 398, MySQLParser::RuleTableAlias);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 382, _ctx)) {
    case 1: {
      setState(3512);
      match(MySQLParser::AS_SYMBOL);
      break;
    }

    case 2: {
      setState(3513);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(3514);
      match(MySQLParser::EQUAL_OPERATOR);
      break;
    }

    default:
      break;
    }
    setState(3517);
    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);
}

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

tree::TerminalNode* MySQLParser::IndexHintListContext::COMMA_SYMBOL(size_t i) {
  return getToken(MySQLParser::COMMA_SYMBOL, 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, 400, MySQLParser::RuleIndexHintList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3519);
    indexHint();
    setState(3524);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 383, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3520);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3521);
        indexHint(); 
      }
      setState(3526);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 383, _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, 402, MySQLParser::RuleIndexHint);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3547);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FORCE_SYMBOL:
      case MySQLParser::IGNORE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3527);
        indexHintType();
        setState(3528);
        keyOrIndex();
        setState(3530);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FOR_SYMBOL) {
          setState(3529);
          indexHintClause();
        }
        setState(3532);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(3533);
        indexList();
        setState(3534);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::USE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3536);
        match(MySQLParser::USE_SYMBOL);
        setState(3537);
        keyOrIndex();
        setState(3539);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FOR_SYMBOL) {
          setState(3538);
          indexHintClause();
        }
        setState(3541);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(3543);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 386, _ctx)) {
        case 1: {
          setState(3542);
          indexList();
          break;
        }

        default:
          break;
        }
        setState(3545);
        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, 404, MySQLParser::RuleIndexHintType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3549);
    _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, 406, MySQLParser::RuleKeyOrIndex);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3551);
    _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, 408, MySQLParser::RuleConstraintKeyType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3559);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PRIMARY_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3553);
        match(MySQLParser::PRIMARY_SYMBOL);
        setState(3554);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      case MySQLParser::UNIQUE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3555);
        match(MySQLParser::UNIQUE_SYMBOL);
        setState(3557);
        _errHandler->sync(this);

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

        || _la == MySQLParser::KEY_SYMBOL) {
          setState(3556);
          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, 410, MySQLParser::RuleIndexHintClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3561);
    match(MySQLParser::FOR_SYMBOL);
    setState(3567);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::JOIN_SYMBOL: {
        setState(3562);
        match(MySQLParser::JOIN_SYMBOL);
        break;
      }

      case MySQLParser::ORDER_SYMBOL: {
        setState(3563);
        match(MySQLParser::ORDER_SYMBOL);
        setState(3564);
        match(MySQLParser::BY_SYMBOL);
        break;
      }

      case MySQLParser::GROUP_SYMBOL: {
        setState(3565);
        match(MySQLParser::GROUP_SYMBOL);
        setState(3566);
        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, 412, MySQLParser::RuleIndexList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3569);
    indexListElement();
    setState(3574);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3570);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3571);
      indexListElement();
      setState(3576);
      _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, 414, MySQLParser::RuleIndexListElement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3578);
      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, 416, MySQLParser::RuleUpdateStatement);
  size_t _la = 0;

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

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

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

    default:
      break;
    }
    setState(3585);
    match(MySQLParser::UPDATE_SYMBOL);
    setState(3587);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 394, _ctx)) {
    case 1: {
      setState(3586);
      match(MySQLParser::LOW_PRIORITY_SYMBOL);
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 395, _ctx)) {
    case 1: {
      setState(3589);
      match(MySQLParser::IGNORE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(3592);
    tableReferenceList();
    setState(3593);
    match(MySQLParser::SET_SYMBOL);
    setState(3594);
    updateList();
    setState(3596);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::WHERE_SYMBOL) {
      setState(3595);
      whereClause();
    }
    setState(3599);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ORDER_SYMBOL) {
      setState(3598);
      orderClause();
    }
    setState(3602);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::LIMIT_SYMBOL) {
      setState(3601);
      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, 418, MySQLParser::RuleTransactionOrLockingStatement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3605);
      savepointStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3606);
      lockStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3607);
      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::TransactionCharacteristicContext *> MySQLParser::TransactionStatementContext::transactionCharacteristic() {
  return getRuleContexts<MySQLParser::TransactionCharacteristicContext>();
}

MySQLParser::TransactionCharacteristicContext* MySQLParser::TransactionStatementContext::transactionCharacteristic(size_t i) {
  return getRuleContext<MySQLParser::TransactionCharacteristicContext>(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, 420, MySQLParser::RuleTransactionStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3635);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::START_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3610);
        match(MySQLParser::START_SYMBOL);
        setState(3611);
        match(MySQLParser::TRANSACTION_SYMBOL);
        setState(3615);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(3612);
            transactionCharacteristic(); 
          }
          setState(3617);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx);
        }
        break;
      }

      case MySQLParser::COMMIT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3618);
        match(MySQLParser::COMMIT_SYMBOL);
        setState(3620);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WORK_SYMBOL) {
          setState(3619);
          match(MySQLParser::WORK_SYMBOL);
        }
        setState(3627);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::AND_SYMBOL) {
          setState(3622);
          match(MySQLParser::AND_SYMBOL);
          setState(3624);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::NO_SYMBOL) {
            setState(3623);
            match(MySQLParser::NO_SYMBOL);
          }
          setState(3626);
          match(MySQLParser::CHAIN_SYMBOL);
        }
        setState(3633);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NO_SYMBOL || _la == MySQLParser::RELEASE_SYMBOL) {
          setState(3630);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::NO_SYMBOL) {
            setState(3629);
            match(MySQLParser::NO_SYMBOL);
          }
          setState(3632);
          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, 422, MySQLParser::RuleBeginWork);
  size_t _la = 0;

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

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

  return _localctx;
}

//----------------- TransactionCharacteristicContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::TransactionCharacteristicContext::CONSISTENT_SYMBOL() {
  return getToken(MySQLParser::CONSISTENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::TransactionCharacteristicContext::SNAPSHOT_SYMBOL() {
  return getToken(MySQLParser::SNAPSHOT_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::TransactionCharacteristicContext::WRITE_SYMBOL() {
  return getToken(MySQLParser::WRITE_SYMBOL, 0);
}

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


size_t MySQLParser::TransactionCharacteristicContext::getRuleIndex() const {
  return MySQLParser::RuleTransactionCharacteristic;
}

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

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


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

MySQLParser::TransactionCharacteristicContext* MySQLParser::transactionCharacteristic() {
  TransactionCharacteristicContext *_localctx = _tracker.createInstance<TransactionCharacteristicContext>(_ctx, getState());
  enterRule(_localctx, 424, MySQLParser::RuleTransactionCharacteristic);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3647);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 408, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3641);
      match(MySQLParser::WITH_SYMBOL);
      setState(3642);
      match(MySQLParser::CONSISTENT_SYMBOL);
      setState(3643);
      match(MySQLParser::SNAPSHOT_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3644);

      if (!(serverVersion >= 50605)) throw FailedPredicateException(this, "serverVersion >= 50605");
      setState(3645);
      match(MySQLParser::READ_SYMBOL);
      setState(3646);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ONLY_SYMBOL || _la == MySQLParser::WRITE_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;
}

//----------------- 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, 426, MySQLParser::RuleSavepointStatement);
  size_t _la = 0;

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

      case MySQLParser::ROLLBACK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3651);
        match(MySQLParser::ROLLBACK_SYMBOL);
        setState(3653);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WORK_SYMBOL) {
          setState(3652);
          match(MySQLParser::WORK_SYMBOL);
        }
        setState(3673);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::TO_SYMBOL: {
            setState(3655);
            match(MySQLParser::TO_SYMBOL);
            setState(3657);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 410, _ctx)) {
            case 1: {
              setState(3656);
              match(MySQLParser::SAVEPOINT_SYMBOL);
              break;
            }

            default:
              break;
            }
            setState(3659);
            identifier();
            break;
          }

          case MySQLParser::EOF:
          case MySQLParser::AND_SYMBOL:
          case MySQLParser::NO_SYMBOL:
          case MySQLParser::RELEASE_SYMBOL:
          case MySQLParser::SEMICOLON_SYMBOL: {
            setState(3665);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == MySQLParser::AND_SYMBOL) {
              setState(3660);
              match(MySQLParser::AND_SYMBOL);
              setState(3662);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == MySQLParser::NO_SYMBOL) {
                setState(3661);
                match(MySQLParser::NO_SYMBOL);
              }
              setState(3664);
              match(MySQLParser::CHAIN_SYMBOL);
            }
            setState(3671);
            _errHandler->sync(this);

            _la = _input->LA(1);
            if (_la == MySQLParser::NO_SYMBOL || _la == MySQLParser::RELEASE_SYMBOL) {
              setState(3668);
              _errHandler->sync(this);

              _la = _input->LA(1);
              if (_la == MySQLParser::NO_SYMBOL) {
                setState(3667);
                match(MySQLParser::NO_SYMBOL);
              }
              setState(3670);
              match(MySQLParser::RELEASE_SYMBOL);
            }
            break;
          }

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

      case MySQLParser::RELEASE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(3675);
        match(MySQLParser::RELEASE_SYMBOL);
        setState(3676);
        match(MySQLParser::SAVEPOINT_SYMBOL);
        setState(3677);
        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, 428, MySQLParser::RuleLockStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3702);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 419, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3680);
      match(MySQLParser::LOCK_SYMBOL);
      setState(3681);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::TABLES_SYMBOL

      || _la == MySQLParser::TABLE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3682);
      lockItem();
      setState(3687);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(3683);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3684);
        lockItem();
        setState(3689);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3690);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3691);
      match(MySQLParser::LOCK_SYMBOL);
      setState(3692);
      match(MySQLParser::INSTANCE_SYMBOL);
      setState(3693);
      match(MySQLParser::FOR_SYMBOL);
      setState(3694);
      match(MySQLParser::BACKUP_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3695);
      match(MySQLParser::UNLOCK_SYMBOL);
      setState(3700);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 418, _ctx)) {
      case 1: {
        setState(3696);
        match(MySQLParser::TABLES_SYMBOL);
        break;
      }

      case 2: {
        setState(3697);
        match(MySQLParser::TABLE_SYMBOL);
        break;
      }

      case 3: {
        setState(3698);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(3699);
        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, 430, MySQLParser::RuleLockItem);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 420, _ctx)) {
    case 1: {
      setState(3705);
      tableAlias();
      break;
    }

    default:
      break;
    }
    setState(3708);
    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, 432, MySQLParser::RuleLockOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3718);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::READ_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3710);
        match(MySQLParser::READ_SYMBOL);
        setState(3712);
        _errHandler->sync(this);

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

      case MySQLParser::LOW_PRIORITY_SYMBOL:
      case MySQLParser::WRITE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3715);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOW_PRIORITY_SYMBOL) {
          setState(3714);
          match(MySQLParser::LOW_PRIORITY_SYMBOL);
        }
        setState(3717);
        match(MySQLParser::WRITE_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;
}

//----------------- 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, 434, MySQLParser::RuleXaStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3720);
    match(MySQLParser::XA_SYMBOL);
    setState(3747);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::BEGIN_SYMBOL:
      case MySQLParser::START_SYMBOL: {
        setState(3721);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::BEGIN_SYMBOL || _la == MySQLParser::START_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(3722);
        xid();
        setState(3724);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::JOIN_SYMBOL || _la == MySQLParser::RESUME_SYMBOL) {
          setState(3723);
          _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(3726);
        match(MySQLParser::END_SYMBOL);
        setState(3727);
        xid();
        setState(3733);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::SUSPEND_SYMBOL) {
          setState(3728);
          match(MySQLParser::SUSPEND_SYMBOL);
          setState(3731);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::FOR_SYMBOL) {
            setState(3729);
            match(MySQLParser::FOR_SYMBOL);
            setState(3730);
            match(MySQLParser::MIGRATE_SYMBOL);
          }
        }
        break;
      }

      case MySQLParser::PREPARE_SYMBOL: {
        setState(3735);
        match(MySQLParser::PREPARE_SYMBOL);
        setState(3736);
        xid();
        break;
      }

      case MySQLParser::COMMIT_SYMBOL: {
        setState(3737);
        match(MySQLParser::COMMIT_SYMBOL);
        setState(3738);
        xid();
        setState(3741);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ONE_SYMBOL) {
          setState(3739);
          match(MySQLParser::ONE_SYMBOL);
          setState(3740);
          match(MySQLParser::PHASE_SYMBOL);
        }
        break;
      }

      case MySQLParser::ROLLBACK_SYMBOL: {
        setState(3743);
        match(MySQLParser::ROLLBACK_SYMBOL);
        setState(3744);
        xid();
        break;
      }

      case MySQLParser::RECOVER_SYMBOL: {
        setState(3745);
        match(MySQLParser::RECOVER_SYMBOL);
        setState(3746);
        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, 436, MySQLParser::RuleXaConvert);
  size_t _la = 0;

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

      if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
      setState(3752);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::CONVERT_SYMBOL) {
        setState(3750);
        match(MySQLParser::CONVERT_SYMBOL);
        setState(3751);
        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, 438, MySQLParser::RuleXid);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMA_SYMBOL) {
      setState(3758);
      match(MySQLParser::COMMA_SYMBOL);
      setState(3759);
      textString();
      setState(3762);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(3760);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3761);
        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);
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicationStatementContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

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

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

tree::TerminalNode* MySQLParser::ReplicationStatementContext::BEFORE_SYMBOL() {
  return getToken(MySQLParser::BEFORE_SYMBOL, 0);
}

MySQLParser::ExprContext* MySQLParser::ReplicationStatementContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::ChangeMasterContext* MySQLParser::ReplicationStatementContext::changeMaster() {
  return getRuleContext<MySQLParser::ChangeMasterContext>(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::IfExistsContext* MySQLParser::ReplicationStatementContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}

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

MySQLParser::SlaveContext* MySQLParser::ReplicationStatementContext::slave() {
  return getRuleContext<MySQLParser::SlaveContext>(0);
}

MySQLParser::ChangeReplicationContext* MySQLParser::ReplicationStatementContext::changeReplication() {
  return getRuleContext<MySQLParser::ChangeReplicationContext>(0);
}

MySQLParser::ReplicationLoadContext* MySQLParser::ReplicationStatementContext::replicationLoad() {
  return getRuleContext<MySQLParser::ReplicationLoadContext>(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, 440, MySQLParser::RuleReplicationStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3799);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 436, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3766);
      match(MySQLParser::PURGE_SYMBOL);
      setState(3767);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::BINARY_SYMBOL || _la == MySQLParser::MASTER_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3768);
      match(MySQLParser::LOGS_SYMBOL);
      setState(3773);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::TO_SYMBOL: {
          setState(3769);
          match(MySQLParser::TO_SYMBOL);
          setState(3770);
          textLiteral();
          break;
        }

        case MySQLParser::BEFORE_SYMBOL: {
          setState(3771);
          match(MySQLParser::BEFORE_SYMBOL);
          setState(3772);
          expr(0);
          break;
        }

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3775);
      changeMaster();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3776);
      match(MySQLParser::RESET_SYMBOL);
      setState(3777);
      resetOption();
      setState(3782);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(3778);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3779);
        resetOption();
        setState(3784);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

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

      if (!(serverVersion > 80000)) throw FailedPredicateException(this, "serverVersion > 80000");
      setState(3786);
      match(MySQLParser::RESET_SYMBOL);
      setState(3787);
      match(MySQLParser::PERSIST_SYMBOL);
      setState(3791);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::IF_SYMBOL) {
        setState(3788);
        ifExists();
        setState(3789);
        identifier();
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3793);
      slave();
      break;
    }

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

      if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
      setState(3795);
      changeReplication();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(3796);
      replicationLoad();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(3797);

      if (!(serverVersion > 50706)) throw FailedPredicateException(this, "serverVersion > 50706");
      setState(3798);
      groupReplication();
      break;
    }

    default:
      break;
    }
   
  }
  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) {
}

tree::TerminalNode* MySQLParser::ResetOptionContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

MySQLParser::MasterResetOptionsContext* MySQLParser::ResetOptionContext::masterResetOptions() {
  return getRuleContext<MySQLParser::MasterResetOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::ResetOptionContext::CACHE_SYMBOL() {
  return getToken(MySQLParser::CACHE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ResetOptionContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ResetOptionContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 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, 442, MySQLParser::RuleResetOption);

#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, 440, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3801);
      antlrcpp::downCast<ResetOptionContext *>(_localctx)->option = match(MySQLParser::MASTER_SYMBOL);
      setState(3803);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 437, _ctx)) {
      case 1: {
        setState(3802);
        masterResetOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3805);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(3806);
      antlrcpp::downCast<ResetOptionContext *>(_localctx)->option = match(MySQLParser::QUERY_SYMBOL);
      setState(3807);
      match(MySQLParser::CACHE_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3808);
      antlrcpp::downCast<ResetOptionContext *>(_localctx)->option = match(MySQLParser::SLAVE_SYMBOL);
      setState(3810);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 438, _ctx)) {
      case 1: {
        setState(3809);
        match(MySQLParser::ALL_SYMBOL);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 439, _ctx)) {
      case 1: {
        setState(3812);
        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;
}

//----------------- MasterResetOptionsContext ------------------------------------------------------------------

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

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

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

MySQLParser::Real_ulonglong_numberContext* MySQLParser::MasterResetOptionsContext::real_ulonglong_number() {
  return getRuleContext<MySQLParser::Real_ulonglong_numberContext>(0);
}


size_t MySQLParser::MasterResetOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleMasterResetOptions;
}

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

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


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

MySQLParser::MasterResetOptionsContext* MySQLParser::masterResetOptions() {
  MasterResetOptionsContext *_localctx = _tracker.createInstance<MasterResetOptionsContext>(_ctx, getState());
  enterRule(_localctx, 444, MySQLParser::RuleMasterResetOptions);

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

    if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
    setState(3818);
    match(MySQLParser::TO_SYMBOL);
    setState(3823);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 441, _ctx)) {
    case 1: {
      setState(3819);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(3820);
      real_ulong_number();
      break;
    }

    case 2: {
      setState(3821);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(3822);
      real_ulonglong_number();
      break;
    }

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

  return _localctx;
}

//----------------- ReplicationLoadContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::ReplicationLoadContext::LOAD_SYMBOL() {
  return getToken(MySQLParser::LOAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicationLoadContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ReplicationLoadContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

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

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

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


size_t MySQLParser::ReplicationLoadContext::getRuleIndex() const {
  return MySQLParser::RuleReplicationLoad;
}

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

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


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

MySQLParser::ReplicationLoadContext* MySQLParser::replicationLoad() {
  ReplicationLoadContext *_localctx = _tracker.createInstance<ReplicationLoadContext>(_ctx, getState());
  enterRule(_localctx, 446, MySQLParser::RuleReplicationLoad);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3825);
    match(MySQLParser::LOAD_SYMBOL);
    setState(3829);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::DATA_SYMBOL: {
        setState(3826);
        match(MySQLParser::DATA_SYMBOL);
        break;
      }

      case MySQLParser::TABLE_SYMBOL: {
        setState(3827);
        match(MySQLParser::TABLE_SYMBOL);
        setState(3828);
        tableRef();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(3831);
    match(MySQLParser::FROM_SYMBOL);
    setState(3832);
    match(MySQLParser::MASTER_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeMasterContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::ChangeMasterContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

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

MySQLParser::ChangeMasterOptionsContext* MySQLParser::ChangeMasterContext::changeMasterOptions() {
  return getRuleContext<MySQLParser::ChangeMasterOptionsContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::ChangeMasterContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ChangeMasterContext::getRuleIndex() const {
  return MySQLParser::RuleChangeMaster;
}

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

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


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

MySQLParser::ChangeMasterContext* MySQLParser::changeMaster() {
  ChangeMasterContext *_localctx = _tracker.createInstance<ChangeMasterContext>(_ctx, getState());
  enterRule(_localctx, 448, MySQLParser::RuleChangeMaster);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3834);
    match(MySQLParser::CHANGE_SYMBOL);
    setState(3835);
    match(MySQLParser::MASTER_SYMBOL);
    setState(3836);
    match(MySQLParser::TO_SYMBOL);
    setState(3837);
    changeMasterOptions();
    setState(3839);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 443, _ctx)) {
    case 1: {
      setState(3838);
      channel();
      break;
    }

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

  return _localctx;
}

//----------------- ChangeMasterOptionsContext ------------------------------------------------------------------

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

std::vector<MySQLParser::MasterOptionContext *> MySQLParser::ChangeMasterOptionsContext::masterOption() {
  return getRuleContexts<MySQLParser::MasterOptionContext>();
}

MySQLParser::MasterOptionContext* MySQLParser::ChangeMasterOptionsContext::masterOption(size_t i) {
  return getRuleContext<MySQLParser::MasterOptionContext>(i);
}

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

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


size_t MySQLParser::ChangeMasterOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleChangeMasterOptions;
}

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

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


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

MySQLParser::ChangeMasterOptionsContext* MySQLParser::changeMasterOptions() {
  ChangeMasterOptionsContext *_localctx = _tracker.createInstance<ChangeMasterOptionsContext>(_ctx, getState());
  enterRule(_localctx, 450, MySQLParser::RuleChangeMasterOptions);

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

  return _localctx;
}

//----------------- MasterOptionContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_HOST_SYMBOL() {
  return getToken(MySQLParser::MASTER_HOST_SYMBOL, 0);
}

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

MySQLParser::TextStringNoLinebreakContext* MySQLParser::MasterOptionContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::NETWORK_NAMESPACE_SYMBOL() {
  return getToken(MySQLParser::NETWORK_NAMESPACE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_BIND_SYMBOL() {
  return getToken(MySQLParser::MASTER_BIND_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_USER_SYMBOL() {
  return getToken(MySQLParser::MASTER_USER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::MASTER_PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_PORT_SYMBOL() {
  return getToken(MySQLParser::MASTER_PORT_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::MasterOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_CONNECT_RETRY_SYMBOL() {
  return getToken(MySQLParser::MASTER_CONNECT_RETRY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_RETRY_COUNT_SYMBOL() {
  return getToken(MySQLParser::MASTER_RETRY_COUNT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_DELAY_SYMBOL() {
  return getToken(MySQLParser::MASTER_DELAY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_CA_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CA_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_CAPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CAPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_TLS_VERSION_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_VERSION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_CERT_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_TLS_CIPHERSUITES_SYMBOL() {
  return getToken(MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL, 0);
}

MySQLParser::MasterTlsCiphersuitesDefContext* MySQLParser::MasterOptionContext::masterTlsCiphersuitesDef() {
  return getRuleContext<MySQLParser::MasterTlsCiphersuitesDefContext>(0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_CIPHER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CIPHER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_KEY_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_CRL_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRL_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_SSL_CRLPATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_SSL_CRLPATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_PUBLIC_KEY_PATH_SYMBOL() {
  return getToken(MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::GET_MASTER_PUBLIC_KEY_SYMBOL() {
  return getToken(MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_HEARTBEAT_PERIOD_SYMBOL() {
  return getToken(MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::IGNORE_SERVER_IDS_SYMBOL() {
  return getToken(MySQLParser::IGNORE_SERVER_IDS_SYMBOL, 0);
}

MySQLParser::ServerIdListContext* MySQLParser::MasterOptionContext::serverIdList() {
  return getRuleContext<MySQLParser::ServerIdListContext>(0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_COMPRESSION_ALGORITHM_SYMBOL() {
  return getToken(MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::MasterOptionContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL() {
  return getToken(MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::MASTER_AUTO_POSITION_SYMBOL() {
  return getToken(MySQLParser::MASTER_AUTO_POSITION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::PRIVILEGE_CHECKS_USER_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL, 0);
}

MySQLParser::PrivilegeCheckDefContext* MySQLParser::MasterOptionContext::privilegeCheckDef() {
  return getRuleContext<MySQLParser::PrivilegeCheckDefContext>(0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::REQUIRE_ROW_FORMAT_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterOptionContext::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL() {
  return getToken(MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL, 0);
}

MySQLParser::TablePrimaryKeyCheckDefContext* MySQLParser::MasterOptionContext::tablePrimaryKeyCheckDef() {
  return getRuleContext<MySQLParser::TablePrimaryKeyCheckDefContext>(0);
}

MySQLParser::MasterFileDefContext* MySQLParser::MasterOptionContext::masterFileDef() {
  return getRuleContext<MySQLParser::MasterFileDefContext>(0);
}


size_t MySQLParser::MasterOptionContext::getRuleIndex() const {
  return MySQLParser::RuleMasterOption;
}

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

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


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

MySQLParser::MasterOptionContext* MySQLParser::masterOption() {
  MasterOptionContext *_localctx = _tracker.createInstance<MasterOptionContext>(_ctx, getState());
  enterRule(_localctx, 452, MySQLParser::RuleMasterOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3940);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::MASTER_HOST_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3849);
        match(MySQLParser::MASTER_HOST_SYMBOL);
        setState(3850);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3851);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::NETWORK_NAMESPACE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3852);
        match(MySQLParser::NETWORK_NAMESPACE_SYMBOL);
        setState(3853);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3854);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_BIND_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(3855);
        match(MySQLParser::MASTER_BIND_SYMBOL);
        setState(3856);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3857);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_USER_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(3858);
        match(MySQLParser::MASTER_USER_SYMBOL);
        setState(3859);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3860);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_PASSWORD_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(3861);
        match(MySQLParser::MASTER_PASSWORD_SYMBOL);
        setState(3862);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3863);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_PORT_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(3864);
        match(MySQLParser::MASTER_PORT_SYMBOL);
        setState(3865);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3866);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_CONNECT_RETRY_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(3867);
        match(MySQLParser::MASTER_CONNECT_RETRY_SYMBOL);
        setState(3868);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3869);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_RETRY_COUNT_SYMBOL: {
        enterOuterAlt(_localctx, 8);
        setState(3870);
        match(MySQLParser::MASTER_RETRY_COUNT_SYMBOL);
        setState(3871);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3872);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_DELAY_SYMBOL: {
        enterOuterAlt(_localctx, 9);
        setState(3873);
        match(MySQLParser::MASTER_DELAY_SYMBOL);
        setState(3874);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3875);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_SSL_SYMBOL: {
        enterOuterAlt(_localctx, 10);
        setState(3876);
        match(MySQLParser::MASTER_SSL_SYMBOL);
        setState(3877);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3878);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_SSL_CA_SYMBOL: {
        enterOuterAlt(_localctx, 11);
        setState(3879);
        match(MySQLParser::MASTER_SSL_CA_SYMBOL);
        setState(3880);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3881);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_SSL_CAPATH_SYMBOL: {
        enterOuterAlt(_localctx, 12);
        setState(3882);
        match(MySQLParser::MASTER_SSL_CAPATH_SYMBOL);
        setState(3883);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3884);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_TLS_VERSION_SYMBOL: {
        enterOuterAlt(_localctx, 13);
        setState(3885);
        match(MySQLParser::MASTER_TLS_VERSION_SYMBOL);
        setState(3886);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3887);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_SSL_CERT_SYMBOL: {
        enterOuterAlt(_localctx, 14);
        setState(3888);
        match(MySQLParser::MASTER_SSL_CERT_SYMBOL);
        setState(3889);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3890);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL: {
        enterOuterAlt(_localctx, 15);
        setState(3891);
        match(MySQLParser::MASTER_TLS_CIPHERSUITES_SYMBOL);
        setState(3892);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3893);
        masterTlsCiphersuitesDef();
        break;
      }

      case MySQLParser::MASTER_SSL_CIPHER_SYMBOL: {
        enterOuterAlt(_localctx, 16);
        setState(3894);
        match(MySQLParser::MASTER_SSL_CIPHER_SYMBOL);
        setState(3895);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3896);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_SSL_KEY_SYMBOL: {
        enterOuterAlt(_localctx, 17);
        setState(3897);
        match(MySQLParser::MASTER_SSL_KEY_SYMBOL);
        setState(3898);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3899);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL: {
        enterOuterAlt(_localctx, 18);
        setState(3900);
        match(MySQLParser::MASTER_SSL_VERIFY_SERVER_CERT_SYMBOL);
        setState(3901);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3902);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_SSL_CRL_SYMBOL: {
        enterOuterAlt(_localctx, 19);
        setState(3903);
        match(MySQLParser::MASTER_SSL_CRL_SYMBOL);
        setState(3904);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3905);
        textLiteral();
        break;
      }

      case MySQLParser::MASTER_SSL_CRLPATH_SYMBOL: {
        enterOuterAlt(_localctx, 20);
        setState(3906);
        match(MySQLParser::MASTER_SSL_CRLPATH_SYMBOL);
        setState(3907);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3908);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL: {
        enterOuterAlt(_localctx, 21);
        setState(3909);
        match(MySQLParser::MASTER_PUBLIC_KEY_PATH_SYMBOL);
        setState(3910);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3911);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL: {
        enterOuterAlt(_localctx, 22);
        setState(3912);
        match(MySQLParser::GET_MASTER_PUBLIC_KEY_SYMBOL);
        setState(3913);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3914);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL: {
        enterOuterAlt(_localctx, 23);
        setState(3915);
        match(MySQLParser::MASTER_HEARTBEAT_PERIOD_SYMBOL);
        setState(3916);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3917);
        ulong_number();
        break;
      }

      case MySQLParser::IGNORE_SERVER_IDS_SYMBOL: {
        enterOuterAlt(_localctx, 24);
        setState(3918);
        match(MySQLParser::IGNORE_SERVER_IDS_SYMBOL);
        setState(3919);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3920);
        serverIdList();
        break;
      }

      case MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL: {
        enterOuterAlt(_localctx, 25);
        setState(3921);
        match(MySQLParser::MASTER_COMPRESSION_ALGORITHM_SYMBOL);
        setState(3922);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3923);
        textStringLiteral();
        break;
      }

      case MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL: {
        enterOuterAlt(_localctx, 26);
        setState(3924);
        match(MySQLParser::MASTER_ZSTD_COMPRESSION_LEVEL_SYMBOL);
        setState(3925);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3926);
        ulong_number();
        break;
      }

      case MySQLParser::MASTER_AUTO_POSITION_SYMBOL: {
        enterOuterAlt(_localctx, 27);
        setState(3927);
        match(MySQLParser::MASTER_AUTO_POSITION_SYMBOL);
        setState(3928);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3929);
        ulong_number();
        break;
      }

      case MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL: {
        enterOuterAlt(_localctx, 28);
        setState(3930);
        match(MySQLParser::PRIVILEGE_CHECKS_USER_SYMBOL);
        setState(3931);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3932);
        privilegeCheckDef();
        break;
      }

      case MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL: {
        enterOuterAlt(_localctx, 29);
        setState(3933);
        match(MySQLParser::REQUIRE_ROW_FORMAT_SYMBOL);
        setState(3934);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3935);
        ulong_number();
        break;
      }

      case MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL: {
        enterOuterAlt(_localctx, 30);
        setState(3936);
        match(MySQLParser::REQUIRE_TABLE_PRIMARY_KEY_CHECK_SYMBOL);
        setState(3937);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3938);
        tablePrimaryKeyCheckDef();
        break;
      }

      case MySQLParser::MASTER_LOG_FILE_SYMBOL:
      case MySQLParser::MASTER_LOG_POS_SYMBOL:
      case MySQLParser::RELAY_LOG_FILE_SYMBOL:
      case MySQLParser::RELAY_LOG_POS_SYMBOL: {
        enterOuterAlt(_localctx, 31);
        setState(3939);
        masterFileDef();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  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, 454, MySQLParser::RulePrivilegeCheckDef);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3943);
      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);
}


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, 456, MySQLParser::RuleTablePrimaryKeyCheckDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3946);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::ON_SYMBOL || _la == MySQLParser::STREAM_SYMBOL

    || _la == MySQLParser::OFF_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;
}

//----------------- MasterTlsCiphersuitesDefContext ------------------------------------------------------------------

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

MySQLParser::TextStringNoLinebreakContext* MySQLParser::MasterTlsCiphersuitesDefContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

tree::TerminalNode* MySQLParser::MasterTlsCiphersuitesDefContext::NULL_SYMBOL() {
  return getToken(MySQLParser::NULL_SYMBOL, 0);
}


size_t MySQLParser::MasterTlsCiphersuitesDefContext::getRuleIndex() const {
  return MySQLParser::RuleMasterTlsCiphersuitesDef;
}

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

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


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

MySQLParser::MasterTlsCiphersuitesDefContext* MySQLParser::masterTlsCiphersuitesDef() {
  MasterTlsCiphersuitesDefContext *_localctx = _tracker.createInstance<MasterTlsCiphersuitesDefContext>(_ctx, getState());
  enterRule(_localctx, 458, MySQLParser::RuleMasterTlsCiphersuitesDef);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3949);
      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;
}

//----------------- MasterFileDefContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::MasterFileDefContext::MASTER_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_FILE_SYMBOL, 0);
}

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

MySQLParser::TextStringNoLinebreakContext* MySQLParser::MasterFileDefContext::textStringNoLinebreak() {
  return getRuleContext<MySQLParser::TextStringNoLinebreakContext>(0);
}

tree::TerminalNode* MySQLParser::MasterFileDefContext::MASTER_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::MASTER_LOG_POS_SYMBOL, 0);
}

MySQLParser::Ulonglong_numberContext* MySQLParser::MasterFileDefContext::ulonglong_number() {
  return getRuleContext<MySQLParser::Ulonglong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::MasterFileDefContext::RELAY_LOG_FILE_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_FILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::MasterFileDefContext::RELAY_LOG_POS_SYMBOL() {
  return getToken(MySQLParser::RELAY_LOG_POS_SYMBOL, 0);
}

MySQLParser::Ulong_numberContext* MySQLParser::MasterFileDefContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(0);
}


size_t MySQLParser::MasterFileDefContext::getRuleIndex() const {
  return MySQLParser::RuleMasterFileDef;
}

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

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


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

MySQLParser::MasterFileDefContext* MySQLParser::masterFileDef() {
  MasterFileDefContext *_localctx = _tracker.createInstance<MasterFileDefContext>(_ctx, getState());
  enterRule(_localctx, 460, MySQLParser::RuleMasterFileDef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3964);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::MASTER_LOG_FILE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3952);
        match(MySQLParser::MASTER_LOG_FILE_SYMBOL);
        setState(3953);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3954);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::MASTER_LOG_POS_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(3955);
        match(MySQLParser::MASTER_LOG_POS_SYMBOL);
        setState(3956);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3957);
        ulonglong_number();
        break;
      }

      case MySQLParser::RELAY_LOG_FILE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(3958);
        match(MySQLParser::RELAY_LOG_FILE_SYMBOL);
        setState(3959);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3960);
        textStringNoLinebreak();
        break;
      }

      case MySQLParser::RELAY_LOG_POS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(3961);
        match(MySQLParser::RELAY_LOG_POS_SYMBOL);
        setState(3962);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3963);
        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;
}

//----------------- 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, 462, MySQLParser::RuleServerIdList);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (((((_la - 747) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 747)) & 28587302322183) != 0)) {
      setState(3967);
      ulong_number();
      setState(3972);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(3968);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3969);
        ulong_number();
        setState(3974);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(3977);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ChangeReplicationContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::ChangeReplicationContext::REPLICATION_SYMBOL() {
  return getToken(MySQLParser::REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ChangeReplicationContext::FILTER_SYMBOL() {
  return getToken(MySQLParser::FILTER_SYMBOL, 0);
}

std::vector<MySQLParser::FilterDefinitionContext *> MySQLParser::ChangeReplicationContext::filterDefinition() {
  return getRuleContexts<MySQLParser::FilterDefinitionContext>();
}

MySQLParser::FilterDefinitionContext* MySQLParser::ChangeReplicationContext::filterDefinition(size_t i) {
  return getRuleContext<MySQLParser::FilterDefinitionContext>(i);
}

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

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

MySQLParser::ChannelContext* MySQLParser::ChangeReplicationContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}


size_t MySQLParser::ChangeReplicationContext::getRuleIndex() const {
  return MySQLParser::RuleChangeReplication;
}

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

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


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

MySQLParser::ChangeReplicationContext* MySQLParser::changeReplication() {
  ChangeReplicationContext *_localctx = _tracker.createInstance<ChangeReplicationContext>(_ctx, getState());
  enterRule(_localctx, 464, MySQLParser::RuleChangeReplication);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3979);
    match(MySQLParser::CHANGE_SYMBOL);
    setState(3980);
    match(MySQLParser::REPLICATION_SYMBOL);
    setState(3981);
    match(MySQLParser::FILTER_SYMBOL);
    setState(3982);
    filterDefinition();
    setState(3987);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 451, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3983);
        match(MySQLParser::COMMA_SYMBOL);
        setState(3984);
        filterDefinition(); 
      }
      setState(3989);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 451, _ctx);
    }
    setState(3992);
    _errHandler->sync(this);

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(3991);
      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, 466, MySQLParser::RuleFilterDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4043);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REPLICATE_DO_DB_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(3994);
        match(MySQLParser::REPLICATE_DO_DB_SYMBOL);
        setState(3995);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(3996);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(3998);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 453, _ctx)) {
        case 1: {
          setState(3997);
          filterDbList();
          break;
        }

        default:
          break;
        }
        setState(4000);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_IGNORE_DB_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4001);
        match(MySQLParser::REPLICATE_IGNORE_DB_SYMBOL);
        setState(4002);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4003);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4005);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 454, _ctx)) {
        case 1: {
          setState(4004);
          filterDbList();
          break;
        }

        default:
          break;
        }
        setState(4007);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_DO_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4008);
        match(MySQLParser::REPLICATE_DO_TABLE_SYMBOL);
        setState(4009);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4010);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4012);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 455, _ctx)) {
        case 1: {
          setState(4011);
          filterTableList();
          break;
        }

        default:
          break;
        }
        setState(4014);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(4015);
        match(MySQLParser::REPLICATE_IGNORE_TABLE_SYMBOL);
        setState(4016);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4017);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4019);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 456, _ctx)) {
        case 1: {
          setState(4018);
          filterTableList();
          break;
        }

        default:
          break;
        }
        setState(4021);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(4022);
        match(MySQLParser::REPLICATE_WILD_DO_TABLE_SYMBOL);
        setState(4023);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4024);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4026);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 457, _ctx)) {
        case 1: {
          setState(4025);
          filterStringList();
          break;
        }

        default:
          break;
        }
        setState(4028);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(4029);
        match(MySQLParser::REPLICATE_WILD_IGNORE_TABLE_SYMBOL);
        setState(4030);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4031);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4033);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 458, _ctx)) {
        case 1: {
          setState(4032);
          filterStringList();
          break;
        }

        default:
          break;
        }
        setState(4035);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::REPLICATE_REWRITE_DB_SYMBOL: {
        enterOuterAlt(_localctx, 7);
        setState(4036);
        match(MySQLParser::REPLICATE_REWRITE_DB_SYMBOL);
        setState(4037);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4038);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4040);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
          setState(4039);
          filterDbPairList();
        }
        setState(4042);
        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, 468, MySQLParser::RuleFilterDbList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4045);
    schemaRef();
    setState(4050);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4046);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4047);
      schemaRef();
      setState(4052);
      _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, 470, MySQLParser::RuleFilterTableList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4053);
    filterTableRef();
    setState(4058);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4054);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4055);
      filterTableRef();
      setState(4060);
      _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, 472, MySQLParser::RuleFilterStringList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4061);
    filterWildDbTableString();
    setState(4066);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4062);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4063);
      filterWildDbTableString();
      setState(4068);
      _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, 474, MySQLParser::RuleFilterWildDbTableString);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4069);
    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, 476, MySQLParser::RuleFilterDbPairList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4071);
    schemaIdentifierPair();
    setState(4076);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4072);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4073);
      schemaIdentifierPair();
      setState(4078);
      _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;
}

//----------------- SlaveContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::SlaveContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SlaveContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 0);
}

MySQLParser::SlaveConnectionOptionsContext* MySQLParser::SlaveContext::slaveConnectionOptions() {
  return getRuleContext<MySQLParser::SlaveConnectionOptionsContext>(0);
}

MySQLParser::SlaveThreadOptionsContext* MySQLParser::SlaveContext::slaveThreadOptions() {
  return getRuleContext<MySQLParser::SlaveThreadOptionsContext>(0);
}

tree::TerminalNode* MySQLParser::SlaveContext::UNTIL_SYMBOL() {
  return getToken(MySQLParser::UNTIL_SYMBOL, 0);
}

MySQLParser::SlaveUntilOptionsContext* MySQLParser::SlaveContext::slaveUntilOptions() {
  return getRuleContext<MySQLParser::SlaveUntilOptionsContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::SlaveContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}

tree::TerminalNode* MySQLParser::SlaveContext::STOP_SYMBOL() {
  return getToken(MySQLParser::STOP_SYMBOL, 0);
}


size_t MySQLParser::SlaveContext::getRuleIndex() const {
  return MySQLParser::RuleSlave;
}

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

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


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

MySQLParser::SlaveContext* MySQLParser::slave() {
  SlaveContext *_localctx = _tracker.createInstance<SlaveContext>(_ctx, getState());
  enterRule(_localctx, 478, MySQLParser::RuleSlave);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4100);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::START_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4079);
        match(MySQLParser::START_SYMBOL);
        setState(4080);
        match(MySQLParser::SLAVE_SYMBOL);
        setState(4082);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 465, _ctx)) {
        case 1: {
          setState(4081);
          slaveThreadOptions();
          break;
        }

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

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 466, _ctx)) {
        case 1: {
          setState(4084);
          match(MySQLParser::UNTIL_SYMBOL);
          setState(4085);
          slaveUntilOptions();
          break;
        }

        default:
          break;
        }
        setState(4088);
        slaveConnectionOptions();
        setState(4090);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 467, _ctx)) {
        case 1: {
          setState(4089);
          channel();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::STOP_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4092);
        match(MySQLParser::STOP_SYMBOL);
        setState(4093);
        match(MySQLParser::SLAVE_SYMBOL);
        setState(4095);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 468, _ctx)) {
        case 1: {
          setState(4094);
          slaveThreadOptions();
          break;
        }

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

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 469, _ctx)) {
        case 1: {
          setState(4097);
          channel();
          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;
}

//----------------- SlaveUntilOptionsContext ------------------------------------------------------------------

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

std::vector<MySQLParser::MasterFileDefContext *> MySQLParser::SlaveUntilOptionsContext::masterFileDef() {
  return getRuleContexts<MySQLParser::MasterFileDefContext>();
}

MySQLParser::MasterFileDefContext* MySQLParser::SlaveUntilOptionsContext::masterFileDef(size_t i) {
  return getRuleContext<MySQLParser::MasterFileDefContext>(i);
}

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

MySQLParser::TextStringContext* MySQLParser::SlaveUntilOptionsContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::SlaveUntilOptionsContext::SQL_AFTER_MTS_GAPS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SlaveUntilOptionsContext::SQL_BEFORE_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_BEFORE_GTIDS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SlaveUntilOptionsContext::SQL_AFTER_GTIDS_SYMBOL() {
  return getToken(MySQLParser::SQL_AFTER_GTIDS_SYMBOL, 0);
}

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

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


size_t MySQLParser::SlaveUntilOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleSlaveUntilOptions;
}

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

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


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

MySQLParser::SlaveUntilOptionsContext* MySQLParser::slaveUntilOptions() {
  SlaveUntilOptionsContext *_localctx = _tracker.createInstance<SlaveUntilOptionsContext>(_ctx, getState());
  enterRule(_localctx, 480, MySQLParser::RuleSlaveUntilOptions);
  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(4109);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 471, _ctx)) {
    case 1: {
      setState(4102);
      masterFileDef();
      break;
    }

    case 2: {
      setState(4103);

      if (!(serverVersion >= 50606)) throw FailedPredicateException(this, "serverVersion >= 50606");
      setState(4104);
      _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(4105);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(4106);
      textString();
      break;
    }

    case 3: {
      setState(4107);

      if (!(serverVersion >= 50606)) throw FailedPredicateException(this, "serverVersion >= 50606");
      setState(4108);
      match(MySQLParser::SQL_AFTER_MTS_GAPS_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(4115);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 472, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4111);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4112);
        masterFileDef(); 
      }
      setState(4117);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 472, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SlaveConnectionOptionsContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::SlaveConnectionOptionsContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::SlaveConnectionOptionsContext::EQUAL_OPERATOR(size_t i) {
  return getToken(MySQLParser::EQUAL_OPERATOR, i);
}

std::vector<MySQLParser::TextStringContext *> MySQLParser::SlaveConnectionOptionsContext::textString() {
  return getRuleContexts<MySQLParser::TextStringContext>();
}

MySQLParser::TextStringContext* MySQLParser::SlaveConnectionOptionsContext::textString(size_t i) {
  return getRuleContext<MySQLParser::TextStringContext>(i);
}

tree::TerminalNode* MySQLParser::SlaveConnectionOptionsContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SlaveConnectionOptionsContext::DEFAULT_AUTH_SYMBOL() {
  return getToken(MySQLParser::DEFAULT_AUTH_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SlaveConnectionOptionsContext::PLUGIN_DIR_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_DIR_SYMBOL, 0);
}


size_t MySQLParser::SlaveConnectionOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleSlaveConnectionOptions;
}

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

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


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

MySQLParser::SlaveConnectionOptionsContext* MySQLParser::slaveConnectionOptions() {
  SlaveConnectionOptionsContext *_localctx = _tracker.createInstance<SlaveConnectionOptionsContext>(_ctx, getState());
  enterRule(_localctx, 482, MySQLParser::RuleSlaveConnectionOptions);

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

      if (!(serverVersion >= 50604)) throw FailedPredicateException(this, "serverVersion >= 50604");
      setState(4122);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 473, _ctx)) {
      case 1: {
        setState(4119);
        match(MySQLParser::USER_SYMBOL);
        setState(4120);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4121);
        textString();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 474, _ctx)) {
      case 1: {
        setState(4124);
        match(MySQLParser::PASSWORD_SYMBOL);
        setState(4125);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4126);
        textString();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 475, _ctx)) {
      case 1: {
        setState(4129);
        match(MySQLParser::DEFAULT_AUTH_SYMBOL);
        setState(4130);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4131);
        textString();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 476, _ctx)) {
      case 1: {
        setState(4134);
        match(MySQLParser::PLUGIN_DIR_SYMBOL);
        setState(4135);
        match(MySQLParser::EQUAL_OPERATOR);
        setState(4136);
        textString();
        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;
}

//----------------- SlaveThreadOptionsContext ------------------------------------------------------------------

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

std::vector<MySQLParser::SlaveThreadOptionContext *> MySQLParser::SlaveThreadOptionsContext::slaveThreadOption() {
  return getRuleContexts<MySQLParser::SlaveThreadOptionContext>();
}

MySQLParser::SlaveThreadOptionContext* MySQLParser::SlaveThreadOptionsContext::slaveThreadOption(size_t i) {
  return getRuleContext<MySQLParser::SlaveThreadOptionContext>(i);
}

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

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


size_t MySQLParser::SlaveThreadOptionsContext::getRuleIndex() const {
  return MySQLParser::RuleSlaveThreadOptions;
}

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

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


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

MySQLParser::SlaveThreadOptionsContext* MySQLParser::slaveThreadOptions() {
  SlaveThreadOptionsContext *_localctx = _tracker.createInstance<SlaveThreadOptionsContext>(_ctx, getState());
  enterRule(_localctx, 484, MySQLParser::RuleSlaveThreadOptions);

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

  return _localctx;
}

//----------------- SlaveThreadOptionContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::SlaveThreadOptionContext::RELAY_THREAD_SYMBOL() {
  return getToken(MySQLParser::RELAY_THREAD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SlaveThreadOptionContext::SQL_THREAD_SYMBOL() {
  return getToken(MySQLParser::SQL_THREAD_SYMBOL, 0);
}


size_t MySQLParser::SlaveThreadOptionContext::getRuleIndex() const {
  return MySQLParser::RuleSlaveThreadOption;
}

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

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


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

MySQLParser::SlaveThreadOptionContext* MySQLParser::slaveThreadOption() {
  SlaveThreadOptionContext *_localctx = _tracker.createInstance<SlaveThreadOptionContext>(_ctx, getState());
  enterRule(_localctx, 486, MySQLParser::RuleSlaveThreadOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4150);
    _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::GROUP_REPLICATION_SYMBOL() {
  return getToken(MySQLParser::GROUP_REPLICATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GroupReplicationContext::START_SYMBOL() {
  return getToken(MySQLParser::START_SYMBOL, 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, 488, MySQLParser::RuleGroupReplication);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4152);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::START_SYMBOL

    || _la == MySQLParser::STOP_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(4153);
    match(MySQLParser::GROUP_REPLICATION_SYMBOL);
   
  }
  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, 490, MySQLParser::RulePreparedStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4166);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PREPARE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4155);
        antlrcpp::downCast<PreparedStatementContext *>(_localctx)->type = match(MySQLParser::PREPARE_SYMBOL);
        setState(4156);
        identifier();
        setState(4157);
        match(MySQLParser::FROM_SYMBOL);
        setState(4160);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 479, _ctx)) {
        case 1: {
          setState(4158);
          textLiteral();
          break;
        }

        case 2: {
          setState(4159);
          userVariable();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::EXECUTE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4162);
        executeStatement();
        break;
      }

      case MySQLParser::DEALLOCATE_SYMBOL:
      case MySQLParser::DROP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4163);
        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(4164);
        match(MySQLParser::PREPARE_SYMBOL);
        setState(4165);
        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, 492, MySQLParser::RuleExecuteStatement);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::USING_SYMBOL) {
      setState(4170);
      match(MySQLParser::USING_SYMBOL);
      setState(4171);
      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, 494, MySQLParser::RuleExecuteVarList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4174);
    userVariable();
    setState(4179);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4175);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4176);
      userVariable();
      setState(4181);
      _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, 496, MySQLParser::RuleCloneStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4182);
    match(MySQLParser::CLONE_SYMBOL);
    setState(4207);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 486, _ctx)) {
    case 1: {
      setState(4183);
      match(MySQLParser::LOCAL_SYMBOL);
      setState(4184);
      match(MySQLParser::DATA_SYMBOL);
      setState(4185);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(4187);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 483, _ctx)) {
      case 1: {
        setState(4186);
        equal();
        break;
      }

      default:
        break;
      }
      setState(4189);
      textStringLiteral();
      break;
    }

    case 2: {
      setState(4190);
      match(MySQLParser::REMOTE_SYMBOL);
      setState(4193);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(4191);
        match(MySQLParser::FOR_SYMBOL);
        setState(4192);
        match(MySQLParser::REPLICATION_SYMBOL);
      }
      break;
    }

    case 3: {
      setState(4195);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(4196);
      match(MySQLParser::INSTANCE_SYMBOL);
      setState(4197);
      match(MySQLParser::FROM_SYMBOL);
      setState(4198);
      user();
      setState(4199);
      match(MySQLParser::COLON_SYMBOL);
      setState(4200);
      ulong_number();
      setState(4201);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(4202);
      match(MySQLParser::BY_SYMBOL);
      setState(4203);
      textStringLiteral();
      setState(4205);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DATA_SYMBOL || _la == MySQLParser::REQUIRE_SYMBOL) {
        setState(4204);
        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, 498, MySQLParser::RuleDataDirSSL);
  size_t _la = 0;

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

      case MySQLParser::DATA_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4210);
        match(MySQLParser::DATA_SYMBOL);
        setState(4211);
        match(MySQLParser::DIRECTORY_SYMBOL);
        setState(4213);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 487, _ctx)) {
        case 1: {
          setState(4212);
          equal();
          break;
        }

        default:
          break;
        }
        setState(4215);
        textStringLiteral();
        setState(4217);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REQUIRE_SYMBOL) {
          setState(4216);
          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, 500, MySQLParser::RuleSsl);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::NO_SYMBOL) {
      setState(4222);
      match(MySQLParser::NO_SYMBOL);
    }
    setState(4225);
    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::AlterUserContext* MySQLParser::AccountManagementStatementContext::alterUser() {
  return getRuleContext<MySQLParser::AlterUserContext>(0);
}

MySQLParser::CreateUserContext* MySQLParser::AccountManagementStatementContext::createUser() {
  return getRuleContext<MySQLParser::CreateUserContext>(0);
}

MySQLParser::DropUserContext* MySQLParser::AccountManagementStatementContext::dropUser() {
  return getRuleContext<MySQLParser::DropUserContext>(0);
}

MySQLParser::GrantContext* MySQLParser::AccountManagementStatementContext::grant() {
  return getRuleContext<MySQLParser::GrantContext>(0);
}

MySQLParser::RenameUserContext* MySQLParser::AccountManagementStatementContext::renameUser() {
  return getRuleContext<MySQLParser::RenameUserContext>(0);
}

MySQLParser::RevokeContext* MySQLParser::AccountManagementStatementContext::revoke() {
  return getRuleContext<MySQLParser::RevokeContext>(0);
}

MySQLParser::SetRoleContext* MySQLParser::AccountManagementStatementContext::setRole() {
  return getRuleContext<MySQLParser::SetRoleContext>(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, 502, MySQLParser::RuleAccountManagementStatement);

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

      if (!(serverVersion >= 50606)) throw FailedPredicateException(this, "serverVersion >= 50606");
      setState(4228);
      alterUser();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4229);
      createUser();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4230);
      dropUser();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4231);
      grant();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4232);
      renameUser();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(4233);
      revoke();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(4234);

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

    default:
      break;
    }
   
  }
  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) {
}

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

tree::TerminalNode* MySQLParser::AlterUserContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::AlterUserTailContext* MySQLParser::AlterUserContext::alterUserTail() {
  return getRuleContext<MySQLParser::AlterUserTailContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::AlterUserContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(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, 504, MySQLParser::RuleAlterUser);

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

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

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(4241);
      ifExists();
      break;
    }

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

  return _localctx;
}

//----------------- AlterUserTailContext ------------------------------------------------------------------

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

MySQLParser::CreateUserTailContext* MySQLParser::AlterUserTailContext::createUserTail() {
  return getRuleContext<MySQLParser::CreateUserTailContext>(0);
}

MySQLParser::CreateUserListContext* MySQLParser::AlterUserTailContext::createUserList() {
  return getRuleContext<MySQLParser::CreateUserListContext>(0);
}

MySQLParser::AlterUserListContext* MySQLParser::AlterUserTailContext::alterUserList() {
  return getRuleContext<MySQLParser::AlterUserListContext>(0);
}

MySQLParser::UserContext* MySQLParser::AlterUserTailContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserTailContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

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

MySQLParser::TextStringContext* MySQLParser::AlterUserTailContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

MySQLParser::ReplacePasswordContext* MySQLParser::AlterUserTailContext::replacePassword() {
  return getRuleContext<MySQLParser::ReplacePasswordContext>(0);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::AlterUserTailContext::retainCurrentPassword() {
  return getRuleContext<MySQLParser::RetainCurrentPasswordContext>(0);
}

MySQLParser::DiscardOldPasswordContext* MySQLParser::AlterUserTailContext::discardOldPassword() {
  return getRuleContext<MySQLParser::DiscardOldPasswordContext>(0);
}

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

tree::TerminalNode* MySQLParser::AlterUserTailContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::AlterUserTailContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

MySQLParser::RoleListContext* MySQLParser::AlterUserTailContext::roleList() {
  return getRuleContext<MySQLParser::RoleListContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserTailContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUserTailContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

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

MySQLParser::TextOrIdentifierContext* MySQLParser::AlterUserTailContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserTailContext::FAILED_LOGIN_ATTEMPTS_SYMBOL() {
  return getToken(MySQLParser::FAILED_LOGIN_ATTEMPTS_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::AlterUserTailContext::PASSWORD_LOCK_TIME_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_LOCK_TIME_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUserTailContext::UNBOUNDED_SYMBOL() {
  return getToken(MySQLParser::UNBOUNDED_SYMBOL, 0);
}


size_t MySQLParser::AlterUserTailContext::getRuleIndex() const {
  return MySQLParser::RuleAlterUserTail;
}

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

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


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

MySQLParser::AlterUserTailContext* MySQLParser::alterUserTail() {
  AlterUserTailContext *_localctx = _tracker.createInstance<AlterUserTailContext>(_ctx, getState());
  enterRule(_localctx, 506, MySQLParser::RuleAlterUserTail);
  size_t _la = 0;

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

        if (!(serverVersion < 80014)) throw FailedPredicateException(this, "serverVersion < 80014");
        setState(4247);
        createUserList();
        break;
      }

      case 2: {
        setState(4248);

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

      default:
        break;
      }
      setState(4252);
      createUserTail();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4254);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(4255);
      user();
      setState(4256);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(4257);
      match(MySQLParser::BY_SYMBOL);
      setState(4258);
      textString();
      setState(4261);
      _errHandler->sync(this);

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

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

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

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

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

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4267);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(4268);
      user();
      setState(4269);
      discardOldPassword();
      break;
    }

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4272);
      user();
      setState(4273);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(4274);
      match(MySQLParser::ROLE_SYMBOL);
      setState(4278);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 496, _ctx)) {
      case 1: {
        setState(4275);
        match(MySQLParser::ALL_SYMBOL);
        break;
      }

      case 2: {
        setState(4276);
        match(MySQLParser::NONE_SYMBOL);
        break;
      }

      case 3: {
        setState(4277);
        roleList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4280);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(4281);
      user();
      setState(4282);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(4285);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(4283);
        match(MySQLParser::WITH_SYMBOL);
        setState(4284);
        textOrIdentifier();
      }
      setState(4287);
      match(MySQLParser::BY_SYMBOL);
      setState(4288);
      match(MySQLParser::RANDOM_SYMBOL);
      setState(4289);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(4291);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::RETAIN_SYMBOL) {
        setState(4290);
        retainCurrentPassword();
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(4293);
      match(MySQLParser::FAILED_LOGIN_ATTEMPTS_SYMBOL);
      setState(4294);
      real_ulong_number();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(4295);
      match(MySQLParser::PASSWORD_LOCK_TIME_SYMBOL);
      setState(4298);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::INT_NUMBER:
        case MySQLParser::LONG_NUMBER:
        case MySQLParser::ULONGLONG_NUMBER:
        case MySQLParser::HEX_NUMBER: {
          setState(4296);
          real_ulong_number();
          break;
        }

        case MySQLParser::UNBOUNDED_SYMBOL: {
          setState(4297);
          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;
}

//----------------- 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, 508, MySQLParser::RuleUserFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4302);
    match(MySQLParser::USER_SYMBOL);
    setState(4303);
    parentheses();
   
  }
  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) {
}

tree::TerminalNode* MySQLParser::CreateUserContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUserContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::CreateUserListContext* MySQLParser::CreateUserContext::createUserList() {
  return getRuleContext<MySQLParser::CreateUserListContext>(0);
}

MySQLParser::DefaultRoleClauseContext* MySQLParser::CreateUserContext::defaultRoleClause() {
  return getRuleContext<MySQLParser::DefaultRoleClauseContext>(0);
}

MySQLParser::CreateUserTailContext* MySQLParser::CreateUserContext::createUserTail() {
  return getRuleContext<MySQLParser::CreateUserTailContext>(0);
}

MySQLParser::IfNotExistsContext* MySQLParser::CreateUserContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(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, 510, MySQLParser::RuleCreateUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4305);
    match(MySQLParser::CREATE_SYMBOL);
    setState(4306);
    match(MySQLParser::USER_SYMBOL);
    setState(4310);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 501, _ctx)) {
    case 1: {
      setState(4307);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(4308);
      ifNotExists();
      break;
    }

    case 2: {
      break;
    }

    default:
      break;
    }
    setState(4312);
    createUserList();
    setState(4313);
    defaultRoleClause();
    setState(4314);
    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);
}


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, 512, MySQLParser::RuleCreateUserTail);
  size_t _la = 0;

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

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(4318);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::REQUIRE_SYMBOL) {
        setState(4317);
        requireClause();
      }
      setState(4321);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(4320);
        connectOptions();
      }
      setState(4326);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::ACCOUNT_SYMBOL || _la == MySQLParser::PASSWORD_SYMBOL) {
        setState(4323);
        accountLockPasswordExpireOptions();
        setState(4328);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      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;
}

//----------------- 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, 514, MySQLParser::RuleDefaultRoleClause);

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4336);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 506, _ctx)) {
      case 1: {
        setState(4333);
        match(MySQLParser::DEFAULT_SYMBOL);
        setState(4334);
        match(MySQLParser::ROLE_SYMBOL);
        setState(4335);
        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, 516, MySQLParser::RuleRequireClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4341);
    match(MySQLParser::REQUIRE_SYMBOL);
    setState(4344);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CIPHER_SYMBOL:
      case MySQLParser::ISSUER_SYMBOL:
      case MySQLParser::SUBJECT_SYMBOL: {
        setState(4342);
        requireList();
        break;
      }

      case MySQLParser::NONE_SYMBOL:
      case MySQLParser::SSL_SYMBOL:
      case MySQLParser::X509_SYMBOL: {
        setState(4343);
        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, 518, MySQLParser::RuleConnectOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4346);
    match(MySQLParser::WITH_SYMBOL);
    setState(4355); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(4355);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL: {
          setState(4347);
          match(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL);
          setState(4348);
          ulong_number();
          break;
        }

        case MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL: {
          setState(4349);
          match(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL);
          setState(4350);
          ulong_number();
          break;
        }

        case MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL: {
          setState(4351);
          match(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL);
          setState(4352);
          ulong_number();
          break;
        }

        case MySQLParser::MAX_USER_CONNECTIONS_SYMBOL: {
          setState(4353);
          match(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL);
          setState(4354);
          ulong_number();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(4357); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (((((_la - 321) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 321)) & 195) != 0));
   
  }
  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);
}


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, 520, MySQLParser::RuleAccountLockPasswordExpireOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4392);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ACCOUNT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4359);
        match(MySQLParser::ACCOUNT_SYMBOL);
        setState(4360);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::LOCK_SYMBOL || _la == MySQLParser::UNLOCK_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      case MySQLParser::PASSWORD_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4361);
        match(MySQLParser::PASSWORD_SYMBOL);
        setState(4390);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 515, _ctx)) {
        case 1: {
          setState(4362);
          match(MySQLParser::EXPIRE_SYMBOL);
          setState(4369);
          _errHandler->sync(this);
          switch (_input->LA(1)) {
            case MySQLParser::INTERVAL_SYMBOL: {
              setState(4363);
              match(MySQLParser::INTERVAL_SYMBOL);
              setState(4364);
              real_ulong_number();
              setState(4365);
              match(MySQLParser::DAY_SYMBOL);
              break;
            }

            case MySQLParser::NEVER_SYMBOL: {
              setState(4367);
              match(MySQLParser::NEVER_SYMBOL);
              break;
            }

            case MySQLParser::DEFAULT_SYMBOL: {
              setState(4368);
              match(MySQLParser::DEFAULT_SYMBOL);
              break;
            }

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

          default:
            break;
          }
          break;
        }

        case 2: {
          setState(4371);
          match(MySQLParser::HISTORY_SYMBOL);
          setState(4374);
          _errHandler->sync(this);
          switch (_input->LA(1)) {
            case MySQLParser::INT_NUMBER:
            case MySQLParser::LONG_NUMBER:
            case MySQLParser::ULONGLONG_NUMBER:
            case MySQLParser::HEX_NUMBER: {
              setState(4372);
              real_ulong_number();
              break;
            }

            case MySQLParser::DEFAULT_SYMBOL: {
              setState(4373);
              match(MySQLParser::DEFAULT_SYMBOL);
              break;
            }

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

        case 3: {
          setState(4376);
          match(MySQLParser::REUSE_SYMBOL);
          setState(4377);
          match(MySQLParser::INTERVAL_SYMBOL);
          setState(4382);
          _errHandler->sync(this);
          switch (_input->LA(1)) {
            case MySQLParser::INT_NUMBER:
            case MySQLParser::LONG_NUMBER:
            case MySQLParser::ULONGLONG_NUMBER:
            case MySQLParser::HEX_NUMBER: {
              setState(4378);
              real_ulong_number();
              setState(4379);
              match(MySQLParser::DAY_SYMBOL);
              break;
            }

            case MySQLParser::DEFAULT_SYMBOL: {
              setState(4381);
              match(MySQLParser::DEFAULT_SYMBOL);
              break;
            }

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

        case 4: {
          setState(4384);

          if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
          setState(4385);
          match(MySQLParser::REQUIRE_SYMBOL);
          setState(4386);
          match(MySQLParser::CURRENT_SYMBOL);
          setState(4388);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::DEFAULT_SYMBOL || _la == MySQLParser::OPTIONAL_SYMBOL) {
            setState(4387);
            _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:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DropUserContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::DropUserContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::DropUserContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

MySQLParser::IfExistsContext* MySQLParser::DropUserContext::ifExists() {
  return getRuleContext<MySQLParser::IfExistsContext>(0);
}


size_t MySQLParser::DropUserContext::getRuleIndex() const {
  return MySQLParser::RuleDropUser;
}

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

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


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

MySQLParser::DropUserContext* MySQLParser::dropUser() {
  DropUserContext *_localctx = _tracker.createInstance<DropUserContext>(_ctx, getState());
  enterRule(_localctx, 522, MySQLParser::RuleDropUser);

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

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

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(4397);
      ifExists();
      break;
    }

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

  return _localctx;
}

//----------------- GrantContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::GrantContext::GRANT_SYMBOL(size_t i) {
  return getToken(MySQLParser::GRANT_SYMBOL, i);
}

MySQLParser::RoleOrPrivilegesListContext* MySQLParser::GrantContext::roleOrPrivilegesList() {
  return getRuleContext<MySQLParser::RoleOrPrivilegesListContext>(0);
}

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

MySQLParser::UserListContext* MySQLParser::GrantContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

tree::TerminalNode* MySQLParser::GrantContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::GrantIdentifierContext* MySQLParser::GrantContext::grantIdentifier() {
  return getRuleContext<MySQLParser::GrantIdentifierContext>(0);
}

MySQLParser::GrantTargetListContext* MySQLParser::GrantContext::grantTargetList() {
  return getRuleContext<MySQLParser::GrantTargetListContext>(0);
}

tree::TerminalNode* MySQLParser::GrantContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::GrantContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

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

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

tree::TerminalNode* MySQLParser::GrantContext::ADMIN_SYMBOL() {
  return getToken(MySQLParser::ADMIN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

MySQLParser::AclTypeContext* MySQLParser::GrantContext::aclType() {
  return getRuleContext<MySQLParser::AclTypeContext>(0);
}

MySQLParser::VersionedRequireClauseContext* MySQLParser::GrantContext::versionedRequireClause() {
  return getRuleContext<MySQLParser::VersionedRequireClauseContext>(0);
}

MySQLParser::GrantOptionsContext* MySQLParser::GrantContext::grantOptions() {
  return getRuleContext<MySQLParser::GrantOptionsContext>(0);
}

MySQLParser::GrantAsContext* MySQLParser::GrantContext::grantAs() {
  return getRuleContext<MySQLParser::GrantAsContext>(0);
}

tree::TerminalNode* MySQLParser::GrantContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}


size_t MySQLParser::GrantContext::getRuleIndex() const {
  return MySQLParser::RuleGrant;
}

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

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


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

MySQLParser::GrantContext* MySQLParser::grant() {
  GrantContext *_localctx = _tracker.createInstance<GrantContext>(_ctx, getState());
  enterRule(_localctx, 524, MySQLParser::RuleGrant);
  size_t _la = 0;

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4404);
      roleOrPrivilegesList();
      setState(4405);
      match(MySQLParser::TO_SYMBOL);
      setState(4406);
      userList();
      setState(4410);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(4407);
        match(MySQLParser::WITH_SYMBOL);
        setState(4408);
        match(MySQLParser::ADMIN_SYMBOL);
        setState(4409);
        match(MySQLParser::OPTION_SYMBOL);
      }
      break;
    }

    case 2: {
      setState(4417);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 520, _ctx)) {
      case 1: {
        setState(4412);
        roleOrPrivilegesList();
        break;
      }

      case 2: {
        setState(4413);
        match(MySQLParser::ALL_SYMBOL);
        setState(4415);
        _errHandler->sync(this);

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

      default:
        break;
      }
      setState(4419);
      match(MySQLParser::ON_SYMBOL);
      setState(4421);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 521, _ctx)) {
      case 1: {
        setState(4420);
        aclType();
        break;
      }

      default:
        break;
      }
      setState(4423);
      grantIdentifier();
      setState(4424);
      match(MySQLParser::TO_SYMBOL);
      setState(4425);
      grantTargetList();
      setState(4427);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 522, _ctx)) {
      case 1: {
        setState(4426);
        versionedRequireClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 523, _ctx)) {
      case 1: {
        setState(4429);
        grantOptions();
        break;
      }

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

      _la = _input->LA(1);
      if (_la == MySQLParser::AS_SYMBOL) {
        setState(4432);
        grantAs();
      }
      break;
    }

    case 3: {
      setState(4435);
      match(MySQLParser::PROXY_SYMBOL);
      setState(4436);
      match(MySQLParser::ON_SYMBOL);
      setState(4437);
      user();
      setState(4438);
      match(MySQLParser::TO_SYMBOL);
      setState(4439);
      grantTargetList();
      setState(4443);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(4440);
        match(MySQLParser::WITH_SYMBOL);
        setState(4441);
        match(MySQLParser::GRANT_SYMBOL);
        setState(4442);
        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, 526, MySQLParser::RuleGrantTargetList);

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

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(4448);
      createUserList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4449);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(4450);
      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);
}

std::vector<MySQLParser::GrantOptionContext *> MySQLParser::GrantOptionsContext::grantOption() {
  return getRuleContexts<MySQLParser::GrantOptionContext>();
}

MySQLParser::GrantOptionContext* MySQLParser::GrantOptionsContext::grantOption(size_t i) {
  return getRuleContext<MySQLParser::GrantOptionContext>(i);
}

tree::TerminalNode* MySQLParser::GrantOptionsContext::GRANT_SYMBOL() {
  return getToken(MySQLParser::GRANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GrantOptionsContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 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, 528, MySQLParser::RuleGrantOptions);
  size_t _la = 0;

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

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(4454);
      match(MySQLParser::WITH_SYMBOL);
      setState(4456); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(4455);
        grantOption();
        setState(4458); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == MySQLParser::GRANT_SYMBOL || ((((_la - 321) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 321)) & 195) != 0));
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4460);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(4461);
      match(MySQLParser::WITH_SYMBOL);
      setState(4462);
      match(MySQLParser::GRANT_SYMBOL);
      setState(4463);
      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;
}

//----------------- 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, 530, MySQLParser::RuleExceptRoleList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4466);
    match(MySQLParser::EXCEPT_SYMBOL);
    setState(4467);
    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, 532, MySQLParser::RuleWithRoles);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4469);
    match(MySQLParser::WITH_SYMBOL);
    setState(4470);
    match(MySQLParser::ROLE_SYMBOL);
    setState(4478);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 531, _ctx)) {
    case 1: {
      setState(4471);
      roleList();
      break;
    }

    case 2: {
      setState(4472);
      match(MySQLParser::ALL_SYMBOL);
      setState(4474);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXCEPT_SYMBOL) {
        setState(4473);
        exceptRoleList();
      }
      break;
    }

    case 3: {
      setState(4476);
      match(MySQLParser::NONE_SYMBOL);
      break;
    }

    case 4: {
      setState(4477);
      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, 534, MySQLParser::RuleGrantAs);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::WITH_SYMBOL) {
      setState(4482);
      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, 536, MySQLParser::RuleVersionedRequireClause);

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

    if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
    setState(4486);
    requireClause();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RenameUserContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::RenameUserContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

std::vector<MySQLParser::UserContext *> MySQLParser::RenameUserContext::user() {
  return getRuleContexts<MySQLParser::UserContext>();
}

MySQLParser::UserContext* MySQLParser::RenameUserContext::user(size_t i) {
  return getRuleContext<MySQLParser::UserContext>(i);
}

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

tree::TerminalNode* MySQLParser::RenameUserContext::TO_SYMBOL(size_t i) {
  return getToken(MySQLParser::TO_SYMBOL, i);
}

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

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


size_t MySQLParser::RenameUserContext::getRuleIndex() const {
  return MySQLParser::RuleRenameUser;
}

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

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


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

MySQLParser::RenameUserContext* MySQLParser::renameUser() {
  RenameUserContext *_localctx = _tracker.createInstance<RenameUserContext>(_ctx, getState());
  enterRule(_localctx, 538, MySQLParser::RuleRenameUser);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4488);
    match(MySQLParser::RENAME_SYMBOL);
    setState(4489);
    match(MySQLParser::USER_SYMBOL);
    setState(4490);
    user();
    setState(4491);
    match(MySQLParser::TO_SYMBOL);
    setState(4492);
    user();
    setState(4500);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4493);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4494);
      user();
      setState(4495);
      match(MySQLParser::TO_SYMBOL);
      setState(4496);
      user();
      setState(4502);
      _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;
}

//----------------- RevokeContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::RevokeContext::REVOKE_SYMBOL() {
  return getToken(MySQLParser::REVOKE_SYMBOL, 0);
}

MySQLParser::RoleOrPrivilegesListContext* MySQLParser::RevokeContext::roleOrPrivilegesList() {
  return getRuleContext<MySQLParser::RoleOrPrivilegesListContext>(0);
}

tree::TerminalNode* MySQLParser::RevokeContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::RevokeContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

MySQLParser::OnTypeToContext* MySQLParser::RevokeContext::onTypeTo() {
  return getRuleContext<MySQLParser::OnTypeToContext>(0);
}

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

tree::TerminalNode* MySQLParser::RevokeContext::PROXY_SYMBOL() {
  return getToken(MySQLParser::PROXY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RevokeContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::RevokeContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

MySQLParser::GrantIdentifierContext* MySQLParser::RevokeContext::grantIdentifier() {
  return getRuleContext<MySQLParser::GrantIdentifierContext>(0);
}

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

tree::TerminalNode* MySQLParser::RevokeContext::GRANT_SYMBOL() {
  return getToken(MySQLParser::GRANT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RevokeContext::OPTION_SYMBOL() {
  return getToken(MySQLParser::OPTION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RevokeContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}

MySQLParser::AclTypeContext* MySQLParser::RevokeContext::aclType() {
  return getRuleContext<MySQLParser::AclTypeContext>(0);
}


size_t MySQLParser::RevokeContext::getRuleIndex() const {
  return MySQLParser::RuleRevoke;
}

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

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


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

MySQLParser::RevokeContext* MySQLParser::revoke() {
  RevokeContext *_localctx = _tracker.createInstance<RevokeContext>(_ctx, getState());
  enterRule(_localctx, 540, MySQLParser::RuleRevoke);

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4505);
      roleOrPrivilegesList();
      setState(4506);
      match(MySQLParser::FROM_SYMBOL);
      setState(4507);
      userList();
      break;
    }

    case 2: {
      setState(4509);
      roleOrPrivilegesList();
      setState(4510);
      onTypeTo();
      setState(4511);
      match(MySQLParser::FROM_SYMBOL);
      setState(4512);
      userList();
      break;
    }

    case 3: {
      setState(4514);
      match(MySQLParser::ALL_SYMBOL);
      setState(4516);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 534, _ctx)) {
      case 1: {
        setState(4515);
        match(MySQLParser::PRIVILEGES_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(4529);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 536, _ctx)) {
      case 1: {
        setState(4518);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(4519);
        match(MySQLParser::ON_SYMBOL);
        setState(4521);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 535, _ctx)) {
        case 1: {
          setState(4520);
          aclType();
          break;
        }

        default:
          break;
        }
        setState(4523);
        grantIdentifier();
        break;
      }

      case 2: {
        setState(4524);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4525);
        match(MySQLParser::GRANT_SYMBOL);
        setState(4526);
        match(MySQLParser::OPTION_SYMBOL);
        setState(4527);
        match(MySQLParser::FROM_SYMBOL);
        setState(4528);
        userList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      setState(4531);
      match(MySQLParser::PROXY_SYMBOL);
      setState(4532);
      match(MySQLParser::ON_SYMBOL);
      setState(4533);
      user();
      setState(4534);
      match(MySQLParser::FROM_SYMBOL);
      setState(4535);
      userList();
      break;
    }

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

  return _localctx;
}

//----------------- OnTypeToContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::OnTypeToContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 0);
}

MySQLParser::GrantIdentifierContext* MySQLParser::OnTypeToContext::grantIdentifier() {
  return getRuleContext<MySQLParser::GrantIdentifierContext>(0);
}

MySQLParser::AclTypeContext* MySQLParser::OnTypeToContext::aclType() {
  return getRuleContext<MySQLParser::AclTypeContext>(0);
}


size_t MySQLParser::OnTypeToContext::getRuleIndex() const {
  return MySQLParser::RuleOnTypeTo;
}

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

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


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

MySQLParser::OnTypeToContext* MySQLParser::onTypeTo() {
  OnTypeToContext *_localctx = _tracker.createInstance<OnTypeToContext>(_ctx, getState());
  enterRule(_localctx, 542, MySQLParser::RuleOnTypeTo);
  size_t _la = 0;

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

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(4540);
      match(MySQLParser::ON_SYMBOL);
      setState(4542);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 538, _ctx)) {
      case 1: {
        setState(4541);
        aclType();
        break;
      }

      default:
        break;
      }
      setState(4544);
      grantIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4545);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4551);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ON_SYMBOL) {
        setState(4546);
        match(MySQLParser::ON_SYMBOL);
        setState(4548);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 539, _ctx)) {
        case 1: {
          setState(4547);
          aclType();
          break;
        }

        default:
          break;
        }
        setState(4550);
        grantIdentifier();
      }
      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);
}


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, 544, MySQLParser::RuleAclType);
  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::FUNCTION_SYMBOL || _la == MySQLParser::PROCEDURE_SYMBOL || _la == MySQLParser::TABLE_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, 546, MySQLParser::RuleRoleOrPrivilegesList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4557);
    roleOrPrivilege();
    setState(4562);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 542, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4558);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4559);
        roleOrPrivilege(); 
      }
      setState(4564);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 542, _ctx);
    }
   
  }
  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_TEXT_SUFFIX() {
  return getToken(MySQLParser::AT_TEXT_SUFFIX, 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);
}

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

tree::TerminalNode* MySQLParser::RoleOrPrivilegeContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 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, 548, MySQLParser::RuleRoleOrPrivilege);
  size_t _la = 0;

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

      if (!(serverVersion > 80000)) throw FailedPredicateException(this, "serverVersion > 80000");
      setState(4576);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 545, _ctx)) {
      case 1: {
        setState(4566);
        roleIdentifierOrText();
        setState(4568);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 543, _ctx)) {
        case 1: {
          setState(4567);
          columnInternalRefList();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(4570);
        roleIdentifierOrText();
        setState(4574);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::AT_TEXT_SUFFIX: {
            setState(4571);
            match(MySQLParser::AT_TEXT_SUFFIX);
            break;
          }

          case MySQLParser::AT_SIGN_SYMBOL: {
            setState(4572);
            match(MySQLParser::AT_SIGN_SYMBOL);
            setState(4573);
            textOrIdentifier();
            break;
          }

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

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4578);
      _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(4580);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 546, _ctx)) {
      case 1: {
        setState(4579);
        columnInternalRefList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4582);
      _la = _input->LA(1);
      if (!(((((_la - 133) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 133)) & 36030033969577985) != 0) || _la == MySQLParser::INDEX_SYMBOL || ((((_la - 423) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 423)) & 268435473) != 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(4583);
      match(MySQLParser::GRANT_SYMBOL);
      setState(4584);
      match(MySQLParser::OPTION_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4585);
      match(MySQLParser::SHOW_SYMBOL);
      setState(4586);
      match(MySQLParser::DATABASES_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(4587);
      match(MySQLParser::CREATE_SYMBOL);
      setState(4591);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 547, _ctx)) {
      case 1: {
        setState(4588);
        match(MySQLParser::TEMPORARY_SYMBOL);
        setState(4589);
        antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = match(MySQLParser::TABLES_SYMBOL);
        break;
      }

      case 2: {
        setState(4590);
        antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::ROUTINE_SYMBOL || _la == MySQLParser::TABLESPACE_SYMBOL

        || _la == MySQLParser::USER_SYMBOL || _la == MySQLParser::VIEW_SYMBOL)) {
          antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(4593);
      match(MySQLParser::LOCK_SYMBOL);
      setState(4594);
      match(MySQLParser::TABLES_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(4595);
      match(MySQLParser::REPLICATION_SYMBOL);
      setState(4596);
      antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CLIENT_SYMBOL || _la == MySQLParser::SLAVE_SYMBOL)) {
        antlrcpp::downCast<RoleOrPrivilegeContext *>(_localctx)->object = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(4597);
      match(MySQLParser::SHOW_SYMBOL);
      setState(4598);
      match(MySQLParser::VIEW_SYMBOL);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(4599);
      match(MySQLParser::ALTER_SYMBOL);
      setState(4601);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 548, _ctx)) {
      case 1: {
        setState(4600);
        match(MySQLParser::ROUTINE_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

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

      if (!(serverVersion > 80000)) throw FailedPredicateException(this, "serverVersion > 80000");
      setState(4604);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::CREATE_SYMBOL

      || _la == MySQLParser::DROP_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(4605);
      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, 550, MySQLParser::RuleGrantIdentifier);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == MySQLParser::DOT_SYMBOL) {
        setState(4609);
        match(MySQLParser::DOT_SYMBOL);
        setState(4610);
        match(MySQLParser::MULT_OPERATOR);
      }
      break;
    }

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

      _la = _input->LA(1);
      if (_la == MySQLParser::DOT_SYMBOL) {
        setState(4614);
        match(MySQLParser::DOT_SYMBOL);
        setState(4615);
        match(MySQLParser::MULT_OPERATOR);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4618);
      tableRef();
      break;
    }

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

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(4620);
      schemaRef();
      setState(4621);
      match(MySQLParser::DOT_SYMBOL);
      setState(4622);
      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, 552, 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(4626);
    requireListElement();
    setState(4633);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 554, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4628);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::AND_SYMBOL) {
          setState(4627);
          match(MySQLParser::AND_SYMBOL);
        }
        setState(4630);
        requireListElement(); 
      }
      setState(4635);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 554, _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, 554, MySQLParser::RuleRequireListElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4642);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CIPHER_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4636);
        antlrcpp::downCast<RequireListElementContext *>(_localctx)->element = match(MySQLParser::CIPHER_SYMBOL);
        setState(4637);
        textString();
        break;
      }

      case MySQLParser::ISSUER_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4638);
        antlrcpp::downCast<RequireListElementContext *>(_localctx)->element = match(MySQLParser::ISSUER_SYMBOL);
        setState(4639);
        textString();
        break;
      }

      case MySQLParser::SUBJECT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4640);
        antlrcpp::downCast<RequireListElementContext *>(_localctx)->element = match(MySQLParser::SUBJECT_SYMBOL);
        setState(4641);
        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, 556, MySQLParser::RuleGrantOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4654);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::GRANT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4644);
        antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::GRANT_SYMBOL);
        setState(4645);
        match(MySQLParser::OPTION_SYMBOL);
        break;
      }

      case MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4646);
        antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_QUERIES_PER_HOUR_SYMBOL);
        setState(4647);
        ulong_number();
        break;
      }

      case MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4648);
        antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_UPDATES_PER_HOUR_SYMBOL);
        setState(4649);
        ulong_number();
        break;
      }

      case MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(4650);
        antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_CONNECTIONS_PER_HOUR_SYMBOL);
        setState(4651);
        ulong_number();
        break;
      }

      case MySQLParser::MAX_USER_CONNECTIONS_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(4652);
        antlrcpp::downCast<GrantOptionContext *>(_localctx)->option = match(MySQLParser::MAX_USER_CONNECTIONS_SYMBOL);
        setState(4653);
        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;
}

//----------------- SetRoleContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::SetRoleContext::ROLE_SYMBOL() {
  return getToken(MySQLParser::ROLE_SYMBOL, 0);
}

std::vector<MySQLParser::RoleListContext *> MySQLParser::SetRoleContext::roleList() {
  return getRuleContexts<MySQLParser::RoleListContext>();
}

MySQLParser::RoleListContext* MySQLParser::SetRoleContext::roleList(size_t i) {
  return getRuleContext<MySQLParser::RoleListContext>(i);
}

tree::TerminalNode* MySQLParser::SetRoleContext::NONE_SYMBOL() {
  return getToken(MySQLParser::NONE_SYMBOL, 0);
}

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

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

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

tree::TerminalNode* MySQLParser::SetRoleContext::EXCEPT_SYMBOL() {
  return getToken(MySQLParser::EXCEPT_SYMBOL, 0);
}


size_t MySQLParser::SetRoleContext::getRuleIndex() const {
  return MySQLParser::RuleSetRole;
}

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

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


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

MySQLParser::SetRoleContext* MySQLParser::setRole() {
  SetRoleContext *_localctx = _tracker.createInstance<SetRoleContext>(_ctx, getState());
  enterRule(_localctx, 558, MySQLParser::RuleSetRole);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4679);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 559, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4656);
      match(MySQLParser::SET_SYMBOL);
      setState(4657);
      match(MySQLParser::ROLE_SYMBOL);
      setState(4658);
      roleList();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4659);
      match(MySQLParser::SET_SYMBOL);
      setState(4660);
      match(MySQLParser::ROLE_SYMBOL);
      setState(4661);
      _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(4662);
      match(MySQLParser::SET_SYMBOL);
      setState(4663);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(4664);
      match(MySQLParser::ROLE_SYMBOL);
      setState(4668);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 557, _ctx)) {
      case 1: {
        setState(4665);
        roleList();
        break;
      }

      case 2: {
        setState(4666);
        match(MySQLParser::NONE_SYMBOL);
        break;
      }

      case 3: {
        setState(4667);
        match(MySQLParser::ALL_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(4670);
      match(MySQLParser::TO_SYMBOL);
      setState(4671);
      roleList();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4672);
      match(MySQLParser::SET_SYMBOL);
      setState(4673);
      match(MySQLParser::ROLE_SYMBOL);
      setState(4674);
      match(MySQLParser::ALL_SYMBOL);
      setState(4677);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXCEPT_SYMBOL) {
        setState(4675);
        match(MySQLParser::EXCEPT_SYMBOL);
        setState(4676);
        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, 560, MySQLParser::RuleRoleList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(4681);
    role();
    setState(4686);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 560, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(4682);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4683);
        role(); 
      }
      setState(4688);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 560, _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::AT_TEXT_SUFFIX() {
  return getToken(MySQLParser::AT_TEXT_SUFFIX, 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, 562, MySQLParser::RuleRole);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 561, _ctx)) {
    case 1: {
      setState(4690);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(4691);
      textOrIdentifier();
      break;
    }

    case 2: {
      setState(4692);
      match(MySQLParser::AT_TEXT_SUFFIX);
      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, 564, MySQLParser::RuleTableAdministrationStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4738);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ANALYZE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4695);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::ANALYZE_SYMBOL);
        setState(4697);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
          setState(4696);
          noWriteToBinLog();
        }
        setState(4699);
        match(MySQLParser::TABLE_SYMBOL);
        setState(4700);
        tableRefList();
        setState(4703);
        _errHandler->sync(this);

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

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

        default:
          break;
        }
        break;
      }

      case MySQLParser::CHECK_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4705);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::CHECK_SYMBOL);
        setState(4706);
        match(MySQLParser::TABLE_SYMBOL);
        setState(4707);
        tableRefList();
        setState(4711);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::CHANGED_SYMBOL || ((((_la - 180) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 180)) & 1048593) != 0) || _la == MySQLParser::MEDIUM_SYMBOL || _la == MySQLParser::QUICK_SYMBOL) {
          setState(4708);
          checkOption();
          setState(4713);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case MySQLParser::CHECKSUM_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(4714);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::CHECKSUM_SYMBOL);
        setState(4715);
        match(MySQLParser::TABLE_SYMBOL);
        setState(4716);
        tableRefList();
        setState(4718);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL) {
          setState(4717);
          _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(4720);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::OPTIMIZE_SYMBOL);
        setState(4722);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
          setState(4721);
          noWriteToBinLog();
        }
        setState(4724);
        match(MySQLParser::TABLE_SYMBOL);
        setState(4725);
        tableRefList();
        break;
      }

      case MySQLParser::REPAIR_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(4726);
        antlrcpp::downCast<TableAdministrationStatementContext *>(_localctx)->type = match(MySQLParser::REPAIR_SYMBOL);
        setState(4728);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::LOCAL_SYMBOL || _la == MySQLParser::NO_WRITE_TO_BINLOG_SYMBOL) {
          setState(4727);
          noWriteToBinLog();
        }
        setState(4730);
        match(MySQLParser::TABLE_SYMBOL);
        setState(4731);
        tableRefList();
        setState(4735);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::EXTENDED_SYMBOL || _la == MySQLParser::QUICK_SYMBOL || _la == MySQLParser::USE_FRM_SYMBOL) {
          setState(4732);
          repairType();
          setState(4737);
          _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;
}

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

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

tree::TerminalNode* MySQLParser::HistogramContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::HistogramContext::BUCKETS_SYMBOL() {
  return getToken(MySQLParser::BUCKETS_SYMBOL, 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, 566, MySQLParser::RuleHistogram);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4753);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UPDATE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4740);
        match(MySQLParser::UPDATE_SYMBOL);
        setState(4741);
        match(MySQLParser::HISTOGRAM_SYMBOL);
        setState(4742);
        match(MySQLParser::ON_SYMBOL);
        setState(4743);
        identifierList();
        setState(4747);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WITH_SYMBOL) {
          setState(4744);
          match(MySQLParser::WITH_SYMBOL);
          setState(4745);
          match(MySQLParser::INT_NUMBER);
          setState(4746);
          match(MySQLParser::BUCKETS_SYMBOL);
        }
        break;
      }

      case MySQLParser::DROP_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4749);
        match(MySQLParser::DROP_SYMBOL);
        setState(4750);
        match(MySQLParser::HISTOGRAM_SYMBOL);
        setState(4751);
        match(MySQLParser::ON_SYMBOL);
        setState(4752);
        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, 568, MySQLParser::RuleCheckOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4758);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::FOR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4755);
        match(MySQLParser::FOR_SYMBOL);
        setState(4756);
        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(4757);
        _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, 570, MySQLParser::RuleRepairType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4760);
    _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;
}

//----------------- InstallUninstallStatmentContext ------------------------------------------------------------------

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

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

tree::TerminalNode* MySQLParser::InstallUninstallStatmentContext::SONAME_SYMBOL() {
  return getToken(MySQLParser::SONAME_SYMBOL, 0);
}

MySQLParser::TextStringLiteralContext* MySQLParser::InstallUninstallStatmentContext::textStringLiteral() {
  return getRuleContext<MySQLParser::TextStringLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::InstallUninstallStatmentContext::INSTALL_SYMBOL() {
  return getToken(MySQLParser::INSTALL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::InstallUninstallStatmentContext::PLUGIN_SYMBOL() {
  return getToken(MySQLParser::PLUGIN_SYMBOL, 0);
}

MySQLParser::TextStringLiteralListContext* MySQLParser::InstallUninstallStatmentContext::textStringLiteralList() {
  return getRuleContext<MySQLParser::TextStringLiteralListContext>(0);
}

tree::TerminalNode* MySQLParser::InstallUninstallStatmentContext::COMPONENT_SYMBOL() {
  return getToken(MySQLParser::COMPONENT_SYMBOL, 0);
}

MySQLParser::PluginRefContext* MySQLParser::InstallUninstallStatmentContext::pluginRef() {
  return getRuleContext<MySQLParser::PluginRefContext>(0);
}

tree::TerminalNode* MySQLParser::InstallUninstallStatmentContext::UNINSTALL_SYMBOL() {
  return getToken(MySQLParser::UNINSTALL_SYMBOL, 0);
}

std::vector<MySQLParser::ComponentRefContext *> MySQLParser::InstallUninstallStatmentContext::componentRef() {
  return getRuleContexts<MySQLParser::ComponentRefContext>();
}

MySQLParser::ComponentRefContext* MySQLParser::InstallUninstallStatmentContext::componentRef(size_t i) {
  return getRuleContext<MySQLParser::ComponentRefContext>(i);
}

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

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


size_t MySQLParser::InstallUninstallStatmentContext::getRuleIndex() const {
  return MySQLParser::RuleInstallUninstallStatment;
}

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

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


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

MySQLParser::InstallUninstallStatmentContext* MySQLParser::installUninstallStatment() {
  InstallUninstallStatmentContext *_localctx = _tracker.createInstance<InstallUninstallStatmentContext>(_ctx, getState());
  enterRule(_localctx, 572, MySQLParser::RuleInstallUninstallStatment);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4784);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 574, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4762);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->action = match(MySQLParser::INSTALL_SYMBOL);
      setState(4763);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->type = match(MySQLParser::PLUGIN_SYMBOL);
      setState(4764);
      identifier();
      setState(4765);
      match(MySQLParser::SONAME_SYMBOL);
      setState(4766);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4768);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->action = match(MySQLParser::INSTALL_SYMBOL);
      setState(4769);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->type = match(MySQLParser::COMPONENT_SYMBOL);
      setState(4770);
      textStringLiteralList();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4771);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->action = match(MySQLParser::UNINSTALL_SYMBOL);
      setState(4772);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->type = match(MySQLParser::PLUGIN_SYMBOL);
      setState(4773);
      pluginRef();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4774);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->action = match(MySQLParser::UNINSTALL_SYMBOL);
      setState(4775);
      antlrcpp::downCast<InstallUninstallStatmentContext *>(_localctx)->type = match(MySQLParser::COMPONENT_SYMBOL);
      setState(4776);
      componentRef();
      setState(4781);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(4777);
        match(MySQLParser::COMMA_SYMBOL);
        setState(4778);
        componentRef();
        setState(4783);
        _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;
}

//----------------- 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, 574, MySQLParser::RuleSetStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4786);
    match(MySQLParser::SET_SYMBOL);
    setState(4787);
    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, 576, MySQLParser::RuleStartOptionValueList);
  size_t _la = 0;

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4792);
      match(MySQLParser::TRANSACTION_SYMBOL);
      setState(4793);
      transactionCharacteristics();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4794);
      optionType();
      setState(4795);
      startOptionValueListFollowingOptionType();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4797);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(4800);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(4798);
        match(MySQLParser::FOR_SYMBOL);
        setState(4799);
        user();
      }
      setState(4802);
      equal();
      setState(4829);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 580, _ctx)) {
      case 1: {
        setState(4803);
        textString();
        setState(4805);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REPLACE_SYMBOL) {
          setState(4804);
          replacePassword();
        }
        setState(4808);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::RETAIN_SYMBOL) {
          setState(4807);
          retainCurrentPassword();
        }
        break;
      }

      case 2: {
        setState(4810);
        textString();
        setState(4812);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::REPLACE_SYMBOL) {
          setState(4811);
          replacePassword();
        }
        setState(4815);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::RETAIN_SYMBOL) {
          setState(4814);
          retainCurrentPassword();
        }
        break;
      }

      case 3: {
        setState(4817);

        if (!(serverVersion < 50706)) throw FailedPredicateException(this, "serverVersion < 50706");
        setState(4818);
        match(MySQLParser::OLD_PASSWORD_SYMBOL);
        setState(4819);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4820);
        textString();
        setState(4821);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case 4: {
        setState(4823);

        if (!(serverVersion < 80014)) throw FailedPredicateException(this, "serverVersion < 80014");
        setState(4824);
        match(MySQLParser::PASSWORD_SYMBOL);
        setState(4825);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(4826);
        textString();
        setState(4827);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4831);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(4832);
      match(MySQLParser::PASSWORD_SYMBOL);
      setState(4835);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(4833);
        match(MySQLParser::FOR_SYMBOL);
        setState(4834);
        user();
      }
      setState(4837);
      match(MySQLParser::TO_SYMBOL);
      setState(4838);
      match(MySQLParser::RANDOM_SYMBOL);
      setState(4840);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::REPLACE_SYMBOL) {
        setState(4839);
        replacePassword();
      }
      setState(4843);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::RETAIN_SYMBOL) {
        setState(4842);
        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, 578, MySQLParser::RuleTransactionCharacteristics);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4856);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::READ_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(4847);
        transactionAccessMode();
        setState(4849);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ISOLATION_SYMBOL) {
          setState(4848);
          isolationLevel();
        }
        break;
      }

      case MySQLParser::ISOLATION_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(4851);
        isolationLevel();
        setState(4854);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(4852);
          match(MySQLParser::COMMA_SYMBOL);
          setState(4853);
          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, 580, MySQLParser::RuleTransactionAccessMode);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4858);
    match(MySQLParser::READ_SYMBOL);
    setState(4859);
    _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, 582, MySQLParser::RuleIsolationLevel);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4861);
    match(MySQLParser::ISOLATION_SYMBOL);
    setState(4862);
    match(MySQLParser::LEVEL_SYMBOL);
    setState(4868);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REPEATABLE_SYMBOL: {
        setState(4863);
        match(MySQLParser::REPEATABLE_SYMBOL);
        setState(4864);
        match(MySQLParser::READ_SYMBOL);
        break;
      }

      case MySQLParser::READ_SYMBOL: {
        setState(4865);
        match(MySQLParser::READ_SYMBOL);
        setState(4866);
        _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(4867);
        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, 584, MySQLParser::RuleOptionValueListContinued);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4874);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(4870);
      match(MySQLParser::COMMA_SYMBOL);
      setState(4871);
      optionValue();
      setState(4876);
      _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::InternalVariableNameContext* MySQLParser::OptionValueNoOptionTypeContext::internalVariableName() {
  return getRuleContext<MySQLParser::InternalVariableNameContext>(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);
}

MySQLParser::SetSystemVariableContext* MySQLParser::OptionValueNoOptionTypeContext::setSystemVariable() {
  return getRuleContext<MySQLParser::SetSystemVariableContext>(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, 586, MySQLParser::RuleOptionValueNoOptionType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4902);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 592, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4877);
      internalVariableName();
      setState(4878);
      equal();
      setState(4879);
      setExprOrDefault();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4881);
      charsetClause();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4882);
      userVariable();
      setState(4883);
      equal();
      setState(4884);
      expr(0);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(4886);
      setSystemVariable();
      setState(4887);
      equal();
      setState(4888);
      setExprOrDefault();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(4890);
      match(MySQLParser::NAMES_SYMBOL);
      setState(4900);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 591, _ctx)) {
      case 1: {
        setState(4891);
        equal();
        setState(4892);
        expr(0);
        break;
      }

      case 2: {
        setState(4894);
        charsetName();
        setState(4896);
        _errHandler->sync(this);

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

      case 3: {
        setState(4898);

        if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
        setState(4899);
        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::InternalVariableNameContext* MySQLParser::OptionValueContext::internalVariableName() {
  return getRuleContext<MySQLParser::InternalVariableNameContext>(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, 588, MySQLParser::RuleOptionValue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(4910);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 593, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(4904);
      optionType();
      setState(4905);
      internalVariableName();
      setState(4906);
      equal();
      setState(4907);
      setExprOrDefault();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4909);
      optionValueNoOptionType();
      break;
    }

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

  return _localctx;
}

//----------------- SetSystemVariableContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::SetSystemVariableContext::AT_AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_AT_SIGN_SYMBOL, 0);
}

MySQLParser::InternalVariableNameContext* MySQLParser::SetSystemVariableContext::internalVariableName() {
  return getRuleContext<MySQLParser::InternalVariableNameContext>(0);
}

MySQLParser::SetVarIdentTypeContext* MySQLParser::SetSystemVariableContext::setVarIdentType() {
  return getRuleContext<MySQLParser::SetVarIdentTypeContext>(0);
}


size_t MySQLParser::SetSystemVariableContext::getRuleIndex() const {
  return MySQLParser::RuleSetSystemVariable;
}

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

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


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

MySQLParser::SetSystemVariableContext* MySQLParser::setSystemVariable() {
  SetSystemVariableContext *_localctx = _tracker.createInstance<SetSystemVariableContext>(_ctx, getState());
  enterRule(_localctx, 590, MySQLParser::RuleSetSystemVariable);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 594, _ctx)) {
    case 1: {
      setState(4913);
      setVarIdentType();
      break;
    }

    default:
      break;
    }
    setState(4916);
    internalVariableName();
   
  }
  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, 592, MySQLParser::RuleStartOptionValueListFollowingOptionType);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4921);
      match(MySQLParser::TRANSACTION_SYMBOL);
      setState(4922);
      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::InternalVariableNameContext* MySQLParser::OptionValueFollowingOptionTypeContext::internalVariableName() {
  return getRuleContext<MySQLParser::InternalVariableNameContext>(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, 594, MySQLParser::RuleOptionValueFollowingOptionType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(4925);
    internalVariableName();
    setState(4926);
    equal();
    setState(4927);
    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, 596, MySQLParser::RuleSetExprOrDefault);
  size_t _la = 0;

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(4930);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ALL_SYMBOL

      || _la == MySQLParser::BINARY_SYMBOL || _la == MySQLParser::DEFAULT_SYMBOL || _la == MySQLParser::ON_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(4931);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(4932);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ROW_SYMBOL || _la == MySQLParser::SYSTEM_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;
}

//----------------- ShowStatementContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::ShowStatementContext::SHOW_SYMBOL() {
  return getToken(MySQLParser::SHOW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::STATUS_SYMBOL() {
  return getToken(MySQLParser::STATUS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::TABLES_SYMBOL() {
  return getToken(MySQLParser::TABLES_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ShowStatementContext::EVENTS_SYMBOL() {
  return getToken(MySQLParser::EVENTS_SYMBOL, 0);
}

MySQLParser::FromOrInContext* MySQLParser::ShowStatementContext::fromOrIn() {
  return getRuleContext<MySQLParser::FromOrInContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::COUNT_SYMBOL() {
  return getToken(MySQLParser::COUNT_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ShowStatementContext::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

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

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

tree::TerminalNode* MySQLParser::ShowStatementContext::FOR_SYMBOL() {
  return getToken(MySQLParser::FOR_SYMBOL, 0);
}

MySQLParser::UserContext* MySQLParser::ShowStatementContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::USING_SYMBOL() {
  return getToken(MySQLParser::USING_SYMBOL, 0);
}

MySQLParser::UserListContext* MySQLParser::ShowStatementContext::userList() {
  return getRuleContext<MySQLParser::UserListContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::CODE_SYMBOL() {
  return getToken(MySQLParser::CODE_SYMBOL, 0);
}

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

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

tree::TerminalNode* MySQLParser::ShowStatementContext::AUTHORS_SYMBOL() {
  return getToken(MySQLParser::AUTHORS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::DATABASES_SYMBOL() {
  return getToken(MySQLParser::DATABASES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::TRIGGERS_SYMBOL() {
  return getToken(MySQLParser::TRIGGERS_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ShowStatementContext::OPEN_SYMBOL() {
  return getToken(MySQLParser::OPEN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::PLUGINS_SYMBOL() {
  return getToken(MySQLParser::PLUGINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::ENGINE_SYMBOL() {
  return getToken(MySQLParser::ENGINE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::MUTEX_SYMBOL() {
  return getToken(MySQLParser::MUTEX_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::LOGS_SYMBOL() {
  return getToken(MySQLParser::LOGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::COLUMNS_SYMBOL() {
  return getToken(MySQLParser::COLUMNS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::BINARY_SYMBOL() {
  return getToken(MySQLParser::BINARY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::MASTER_SYMBOL() {
  return getToken(MySQLParser::MASTER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::SLAVE_SYMBOL() {
  return getToken(MySQLParser::SLAVE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::ENGINES_SYMBOL() {
  return getToken(MySQLParser::ENGINES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::WARNINGS_SYMBOL() {
  return getToken(MySQLParser::WARNINGS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::ERRORS_SYMBOL() {
  return getToken(MySQLParser::ERRORS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::PROFILES_SYMBOL() {
  return getToken(MySQLParser::PROFILES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::PROFILE_SYMBOL() {
  return getToken(MySQLParser::PROFILE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::PROCESSLIST_SYMBOL() {
  return getToken(MySQLParser::PROCESSLIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::COLLATION_SYMBOL() {
  return getToken(MySQLParser::COLLATION_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::CONTRIBUTORS_SYMBOL() {
  return getToken(MySQLParser::CONTRIBUTORS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::PRIVILEGES_SYMBOL() {
  return getToken(MySQLParser::PRIVILEGES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::GRANTS_SYMBOL() {
  return getToken(MySQLParser::GRANTS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::CREATE_SYMBOL() {
  return getToken(MySQLParser::CREATE_SYMBOL, 0);
}

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

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

MySQLParser::EngineRefContext* MySQLParser::ShowStatementContext::engineRef() {
  return getRuleContext<MySQLParser::EngineRefContext>(0);
}

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

tree::TerminalNode* MySQLParser::ShowStatementContext::HOSTS_SYMBOL() {
  return getToken(MySQLParser::HOSTS_SYMBOL, 0);
}

MySQLParser::NonBlockingContext* MySQLParser::ShowStatementContext::nonBlocking() {
  return getRuleContext<MySQLParser::NonBlockingContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::BINLOG_SYMBOL() {
  return getToken(MySQLParser::BINLOG_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::RELAYLOG_SYMBOL() {
  return getToken(MySQLParser::RELAYLOG_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ShowStatementContext::INDEXES_SYMBOL() {
  return getToken(MySQLParser::INDEXES_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ShowStatementContext::VARIABLES_SYMBOL() {
  return getToken(MySQLParser::VARIABLES_SYMBOL, 0);
}

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

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

MySQLParser::TriggerRefContext* MySQLParser::ShowStatementContext::triggerRef() {
  return getRuleContext<MySQLParser::TriggerRefContext>(0);
}

MySQLParser::ViewRefContext* MySQLParser::ShowStatementContext::viewRef() {
  return getRuleContext<MySQLParser::ViewRefContext>(0);
}

MySQLParser::LikeOrWhereContext* MySQLParser::ShowStatementContext::likeOrWhere() {
  return getRuleContext<MySQLParser::LikeOrWhereContext>(0);
}

MySQLParser::ShowCommandTypeContext* MySQLParser::ShowStatementContext::showCommandType() {
  return getRuleContext<MySQLParser::ShowCommandTypeContext>(0);
}

MySQLParser::InDbContext* MySQLParser::ShowStatementContext::inDb() {
  return getRuleContext<MySQLParser::InDbContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::FULL_SYMBOL() {
  return getToken(MySQLParser::FULL_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::ShowStatementContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

MySQLParser::Ulonglong_numberContext* MySQLParser::ShowStatementContext::ulonglong_number() {
  return getRuleContext<MySQLParser::Ulonglong_numberContext>(0);
}

MySQLParser::LimitClauseContext* MySQLParser::ShowStatementContext::limitClause() {
  return getRuleContext<MySQLParser::LimitClauseContext>(0);
}

MySQLParser::ChannelContext* MySQLParser::ShowStatementContext::channel() {
  return getRuleContext<MySQLParser::ChannelContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

MySQLParser::WhereClauseContext* MySQLParser::ShowStatementContext::whereClause() {
  return getRuleContext<MySQLParser::WhereClauseContext>(0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::STORAGE_SYMBOL() {
  return getToken(MySQLParser::STORAGE_SYMBOL, 0);
}

std::vector<MySQLParser::ProfileTypeContext *> MySQLParser::ShowStatementContext::profileType() {
  return getRuleContexts<MySQLParser::ProfileTypeContext>();
}

MySQLParser::ProfileTypeContext* MySQLParser::ShowStatementContext::profileType(size_t i) {
  return getRuleContext<MySQLParser::ProfileTypeContext>(i);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::QUERY_SYMBOL() {
  return getToken(MySQLParser::QUERY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

MySQLParser::OptionTypeContext* MySQLParser::ShowStatementContext::optionType() {
  return getRuleContext<MySQLParser::OptionTypeContext>(0);
}

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

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

tree::TerminalNode* MySQLParser::ShowStatementContext::TRIGGER_SYMBOL() {
  return getToken(MySQLParser::TRIGGER_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::VIEW_SYMBOL() {
  return getToken(MySQLParser::VIEW_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ShowStatementContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 0);
}

MySQLParser::IfNotExistsContext* MySQLParser::ShowStatementContext::ifNotExists() {
  return getRuleContext<MySQLParser::IfNotExistsContext>(0);
}

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

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


size_t MySQLParser::ShowStatementContext::getRuleIndex() const {
  return MySQLParser::RuleShowStatement;
}

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

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


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

MySQLParser::ShowStatementContext* MySQLParser::showStatement() {
  ShowStatementContext *_localctx = _tracker.createInstance<ShowStatementContext>(_ctx, getState());
  enterRule(_localctx, 598, MySQLParser::RuleShowStatement);
  size_t _la = 0;

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

      if (!(serverVersion < 50700)) throw FailedPredicateException(this, "serverVersion < 50700");
      setState(4937);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::AUTHORS_SYMBOL);
      break;
    }

    case 2: {
      setState(4938);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::DATABASES_SYMBOL);
      setState(4940);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(4939);
        likeOrWhere();
      }
      break;
    }

    case 3: {
      setState(4943);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 598, _ctx)) {
      case 1: {
        setState(4942);
        showCommandType();
        break;
      }

      default:
        break;
      }
      setState(4945);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::TABLES_SYMBOL);
      setState(4947);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(4946);
        inDb();
      }
      setState(4950);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(4949);
        likeOrWhere();
      }
      break;
    }

    case 4: {
      setState(4953);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FULL_SYMBOL) {
        setState(4952);
        match(MySQLParser::FULL_SYMBOL);
      }
      setState(4955);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::TRIGGERS_SYMBOL);
      setState(4957);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(4956);
        inDb();
      }
      setState(4960);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(4959);
        likeOrWhere();
      }
      break;
    }

    case 5: {
      setState(4962);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::EVENTS_SYMBOL);
      setState(4964);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(4963);
        inDb();
      }
      setState(4967);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(4966);
        likeOrWhere();
      }
      break;
    }

    case 6: {
      setState(4969);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::TABLE_SYMBOL);
      setState(4970);
      match(MySQLParser::STATUS_SYMBOL);
      setState(4972);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(4971);
        inDb();
      }
      setState(4975);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(4974);
        likeOrWhere();
      }
      break;
    }

    case 7: {
      setState(4977);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::OPEN_SYMBOL);
      setState(4978);
      match(MySQLParser::TABLES_SYMBOL);
      setState(4980);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(4979);
        inDb();
      }
      setState(4983);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(4982);
        likeOrWhere();
      }
      break;
    }

    case 8: {
      setState(4985);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PLUGINS_SYMBOL);
      break;
    }

    case 9: {
      setState(4986);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::ENGINE_SYMBOL);
      setState(4989);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 610, _ctx)) {
      case 1: {
        setState(4987);
        engineRef();
        break;
      }

      case 2: {
        setState(4988);
        match(MySQLParser::ALL_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(4991);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LOGS_SYMBOL || _la == MySQLParser::MUTEX_SYMBOL || _la == MySQLParser::STATUS_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 10: {
      setState(4993);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 611, _ctx)) {
      case 1: {
        setState(4992);
        showCommandType();
        break;
      }

      default:
        break;
      }
      setState(4995);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::COLUMNS_SYMBOL);
      setState(4996);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::FROM_SYMBOL

      || _la == MySQLParser::IN_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(4997);
      tableRef();
      setState(4999);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(4998);
        inDb();
      }
      setState(5002);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(5001);
        likeOrWhere();
      }
      break;
    }

    case 11: {
      setState(5004);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::BINARY_SYMBOL || _la == MySQLParser::MASTER_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5005);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::LOGS_SYMBOL);
      break;
    }

    case 12: {
      setState(5006);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::SLAVE_SYMBOL);
      setState(5013);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::HOSTS_SYMBOL: {
          setState(5007);
          match(MySQLParser::HOSTS_SYMBOL);
          break;
        }

        case MySQLParser::STATUS_SYMBOL: {
          setState(5008);
          match(MySQLParser::STATUS_SYMBOL);
          setState(5009);
          nonBlocking();
          setState(5011);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 614, _ctx)) {
          case 1: {
            setState(5010);
            channel();
            break;
          }

          default:
            break;
          }
          break;
        }

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

    case 13: {
      setState(5015);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::BINLOG_SYMBOL || _la == MySQLParser::RELAYLOG_SYMBOL)) {
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5016);
      match(MySQLParser::EVENTS_SYMBOL);
      setState(5019);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 616, _ctx)) {
      case 1: {
        setState(5017);
        match(MySQLParser::IN_SYMBOL);
        setState(5018);
        textString();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 617, _ctx)) {
      case 1: {
        setState(5021);
        match(MySQLParser::FROM_SYMBOL);
        setState(5022);
        ulonglong_number();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 618, _ctx)) {
      case 1: {
        setState(5025);
        limitClause();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 619, _ctx)) {
      case 1: {
        setState(5028);
        channel();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 14: {
      setState(5033);
      _errHandler->sync(this);

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

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(5032);
        match(MySQLParser::EXTENDED_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5035);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 235) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 235)) & 268435459) != 0))) {
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5036);
      fromOrIn();
      setState(5037);
      tableRef();
      setState(5039);
      _errHandler->sync(this);

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

      || _la == MySQLParser::IN_SYMBOL) {
        setState(5038);
        inDb();
      }
      setState(5042);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WHERE_SYMBOL) {
        setState(5041);
        whereClause();
      }
      break;
    }

    case 15: {
      setState(5045);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::STORAGE_SYMBOL) {
        setState(5044);
        match(MySQLParser::STORAGE_SYMBOL);
      }
      setState(5047);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::ENGINES_SYMBOL);
      break;
    }

    case 16: {
      setState(5048);
      match(MySQLParser::COUNT_SYMBOL);
      setState(5049);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5050);
      match(MySQLParser::MULT_OPERATOR);
      setState(5051);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5052);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ERRORS_SYMBOL || _la == MySQLParser::WARNINGS_SYMBOL)) {
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 17: {
      setState(5053);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::WARNINGS_SYMBOL);
      setState(5055);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIMIT_SYMBOL) {
        setState(5054);
        limitClause();
      }
      break;
    }

    case 18: {
      setState(5057);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::ERRORS_SYMBOL);
      setState(5059);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIMIT_SYMBOL) {
        setState(5058);
        limitClause();
      }
      break;
    }

    case 19: {
      setState(5061);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PROFILES_SYMBOL);
      break;
    }

    case 20: {
      setState(5062);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PROFILE_SYMBOL);
      setState(5071);
      _errHandler->sync(this);

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

      || _la == MySQLParser::BLOCK_SYMBOL || _la == MySQLParser::CONTEXT_SYMBOL

      || _la == MySQLParser::CPU_SYMBOL || _la == MySQLParser::IPC_SYMBOL || _la == MySQLParser::MEMORY_SYMBOL || _la == MySQLParser::PAGE_SYMBOL || _la == MySQLParser::SOURCE_SYMBOL

      || _la == MySQLParser::SWAPS_SYMBOL) {
        setState(5063);
        profileType();
        setState(5068);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::COMMA_SYMBOL) {
          setState(5064);
          match(MySQLParser::COMMA_SYMBOL);
          setState(5065);
          profileType();
          setState(5070);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(5076);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(5073);
        match(MySQLParser::FOR_SYMBOL);
        setState(5074);
        match(MySQLParser::QUERY_SYMBOL);
        setState(5075);
        match(MySQLParser::INT_NUMBER);
      }
      setState(5079);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIMIT_SYMBOL) {
        setState(5078);
        limitClause();
      }
      break;
    }

    case 21: {
      setState(5082);
      _errHandler->sync(this);

      _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) {
        setState(5081);
        optionType();
      }
      setState(5084);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::STATUS_SYMBOL || _la == MySQLParser::VARIABLES_SYMBOL)) {
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5086);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(5085);
        likeOrWhere();
      }
      break;
    }

    case 22: {
      setState(5089);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FULL_SYMBOL) {
        setState(5088);
        match(MySQLParser::FULL_SYMBOL);
      }
      setState(5091);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PROCESSLIST_SYMBOL);
      break;
    }

    case 23: {
      setState(5092);
      charset();
      setState(5094);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(5093);
        likeOrWhere();
      }
      break;
    }

    case 24: {
      setState(5096);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::COLLATION_SYMBOL);
      setState(5098);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(5097);
        likeOrWhere();
      }
      break;
    }

    case 25: {
      setState(5100);

      if (!(serverVersion < 50700)) throw FailedPredicateException(this, "serverVersion < 50700");
      setState(5101);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::CONTRIBUTORS_SYMBOL);
      break;
    }

    case 26: {
      setState(5102);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PRIVILEGES_SYMBOL);
      break;
    }

    case 27: {
      setState(5103);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::GRANTS_SYMBOL);
      setState(5106);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FOR_SYMBOL) {
        setState(5104);
        match(MySQLParser::FOR_SYMBOL);
        setState(5105);
        user();
      }
      break;
    }

    case 28: {
      setState(5108);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::GRANTS_SYMBOL);
      setState(5109);
      match(MySQLParser::FOR_SYMBOL);
      setState(5110);
      user();
      setState(5111);
      match(MySQLParser::USING_SYMBOL);
      setState(5112);
      userList();
      break;
    }

    case 29: {
      setState(5114);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::MASTER_SYMBOL);
      setState(5115);
      match(MySQLParser::STATUS_SYMBOL);
      break;
    }

    case 30: {
      setState(5116);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::CREATE_SYMBOL);
      setState(5137);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 637, _ctx)) {
      case 1: {
        setState(5117);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::DATABASE_SYMBOL);
        setState(5119);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 636, _ctx)) {
        case 1: {
          setState(5118);
          ifNotExists();
          break;
        }

        default:
          break;
        }
        setState(5121);
        schemaRef();
        break;
      }

      case 2: {
        setState(5122);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::EVENT_SYMBOL);
        setState(5123);
        eventRef();
        break;
      }

      case 3: {
        setState(5124);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::FUNCTION_SYMBOL);
        setState(5125);
        functionRef();
        break;
      }

      case 4: {
        setState(5126);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::PROCEDURE_SYMBOL);
        setState(5127);
        procedureRef();
        break;
      }

      case 5: {
        setState(5128);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::TABLE_SYMBOL);
        setState(5129);
        tableRef();
        break;
      }

      case 6: {
        setState(5130);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::TRIGGER_SYMBOL);
        setState(5131);
        triggerRef();
        break;
      }

      case 7: {
        setState(5132);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::VIEW_SYMBOL);
        setState(5133);
        viewRef();
        break;
      }

      case 8: {
        setState(5134);

        if (!(serverVersion >= 50704)) throw FailedPredicateException(this, "serverVersion >= 50704");
        setState(5135);
        antlrcpp::downCast<ShowStatementContext *>(_localctx)->object = match(MySQLParser::USER_SYMBOL);
        setState(5136);
        user();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 31: {
      setState(5139);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PROCEDURE_SYMBOL);
      setState(5140);
      match(MySQLParser::STATUS_SYMBOL);
      setState(5142);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(5141);
        likeOrWhere();
      }
      break;
    }

    case 32: {
      setState(5144);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::FUNCTION_SYMBOL);
      setState(5145);
      match(MySQLParser::STATUS_SYMBOL);
      setState(5147);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LIKE_SYMBOL || _la == MySQLParser::WHERE_SYMBOL) {
        setState(5146);
        likeOrWhere();
      }
      break;
    }

    case 33: {
      setState(5149);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::PROCEDURE_SYMBOL);
      setState(5150);
      match(MySQLParser::CODE_SYMBOL);
      setState(5151);
      procedureRef();
      break;
    }

    case 34: {
      setState(5152);
      antlrcpp::downCast<ShowStatementContext *>(_localctx)->value = match(MySQLParser::FUNCTION_SYMBOL);
      setState(5153);
      match(MySQLParser::CODE_SYMBOL);
      setState(5154);
      functionRef();
      break;
    }

    default:
      break;
    }
   
  }
  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, 600, MySQLParser::RuleShowCommandType);
  size_t _la = 0;

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5158);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(5159);
      match(MySQLParser::EXTENDED_SYMBOL);
      setState(5161);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FULL_SYMBOL) {
        setState(5160);
        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;
}

//----------------- NonBlockingContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::NonBlockingContext::NONBLOCKING_SYMBOL() {
  return getToken(MySQLParser::NONBLOCKING_SYMBOL, 0);
}


size_t MySQLParser::NonBlockingContext::getRuleIndex() const {
  return MySQLParser::RuleNonBlocking;
}

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

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


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

MySQLParser::NonBlockingContext* MySQLParser::nonBlocking() {
  NonBlockingContext *_localctx = _tracker.createInstance<NonBlockingContext>(_ctx, getState());
  enterRule(_localctx, 602, MySQLParser::RuleNonBlocking);

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

      if (!(serverVersion >= 50700 && serverVersion < 50706)) throw FailedPredicateException(this, "serverVersion >= 50700 && serverVersion < 50706");
      setState(5167);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 643, _ctx)) {
      case 1: {
        setState(5166);
        match(MySQLParser::NONBLOCKING_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;
}

//----------------- 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, 604, MySQLParser::RuleFromOrIn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5172);
    _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, 606, MySQLParser::RuleInDb);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5174);
    fromOrIn();
    setState(5175);
    identifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProfileTypeContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::ProfileTypeContext::BLOCK_SYMBOL() {
  return getToken(MySQLParser::BLOCK_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::IO_SYMBOL() {
  return getToken(MySQLParser::IO_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::CONTEXT_SYMBOL() {
  return getToken(MySQLParser::CONTEXT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::SWITCHES_SYMBOL() {
  return getToken(MySQLParser::SWITCHES_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::PAGE_SYMBOL() {
  return getToken(MySQLParser::PAGE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::FAULTS_SYMBOL() {
  return getToken(MySQLParser::FAULTS_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ProfileTypeContext::CPU_SYMBOL() {
  return getToken(MySQLParser::CPU_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::IPC_SYMBOL() {
  return getToken(MySQLParser::IPC_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::MEMORY_SYMBOL() {
  return getToken(MySQLParser::MEMORY_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::SOURCE_SYMBOL() {
  return getToken(MySQLParser::SOURCE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ProfileTypeContext::SWAPS_SYMBOL() {
  return getToken(MySQLParser::SWAPS_SYMBOL, 0);
}


size_t MySQLParser::ProfileTypeContext::getRuleIndex() const {
  return MySQLParser::RuleProfileType;
}

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

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


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

MySQLParser::ProfileTypeContext* MySQLParser::profileType() {
  ProfileTypeContext *_localctx = _tracker.createInstance<ProfileTypeContext>(_ctx, getState());
  enterRule(_localctx, 608, MySQLParser::RuleProfileType);
  size_t _la = 0;

#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::BLOCK_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5177);
        match(MySQLParser::BLOCK_SYMBOL);
        setState(5178);
        match(MySQLParser::IO_SYMBOL);
        break;
      }

      case MySQLParser::CONTEXT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5179);
        match(MySQLParser::CONTEXT_SYMBOL);
        setState(5180);
        match(MySQLParser::SWITCHES_SYMBOL);
        break;
      }

      case MySQLParser::PAGE_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(5181);
        match(MySQLParser::PAGE_SYMBOL);
        setState(5182);
        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(5183);
        _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, 610, MySQLParser::RuleOtherAdministrativeStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5223);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 651, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5186);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::BINLOG_SYMBOL);
      setState(5187);
      textLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5188);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::CACHE_SYMBOL);
      setState(5189);
      match(MySQLParser::INDEX_SYMBOL);
      setState(5190);
      keyCacheListOrParts();
      setState(5191);
      match(MySQLParser::IN_SYMBOL);
      setState(5194);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 646, _ctx)) {
      case 1: {
        setState(5192);
        identifier();
        break;
      }

      case 2: {
        setState(5193);
        match(MySQLParser::DEFAULT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5196);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::FLUSH_SYMBOL);
      setState(5198);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(5209);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 649, _ctx)) {
      case 1: {
        setState(5200);
        flushTables();
        break;
      }

      case 2: {
        setState(5201);
        flushOption();
        setState(5206);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == MySQLParser::COMMA_SYMBOL) {
          setState(5202);
          match(MySQLParser::COMMA_SYMBOL);
          setState(5203);
          flushOption();
          setState(5208);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5211);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::KILL_SYMBOL);
      setState(5213);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 650, _ctx)) {
      case 1: {
        setState(5212);
        _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(5215);
      expr(0);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5216);
      antlrcpp::downCast<OtherAdministrativeStatementContext *>(_localctx)->type = match(MySQLParser::LOAD_SYMBOL);
      setState(5217);
      match(MySQLParser::INDEX_SYMBOL);
      setState(5218);
      match(MySQLParser::INTO_SYMBOL);
      setState(5219);
      match(MySQLParser::CACHE_SYMBOL);
      setState(5220);
      preloadTail();
      break;
    }

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

      if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
      setState(5222);
      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, 612, MySQLParser::RuleKeyCacheListOrParts);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5226);
      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, 614, MySQLParser::RuleKeyCacheList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5229);
    assignToKeycache();
    setState(5234);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5230);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5231);
      assignToKeycache();
      setState(5236);
      _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, 616, MySQLParser::RuleAssignToKeycache);
  size_t _la = 0;

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

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

    || _la == MySQLParser::KEY_SYMBOL) {
      setState(5238);
      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, 618, MySQLParser::RuleAssignToKeycachePartition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5241);
    tableRef();
    setState(5242);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(5243);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(5244);
    allOrPartitionNameList();
    setState(5245);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
    setState(5247);
    _errHandler->sync(this);

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

    || _la == MySQLParser::KEY_SYMBOL) {
      setState(5246);
      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, 620, MySQLParser::RuleCacheKeyList);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 656, _ctx)) {
    case 1: {
      setState(5251);
      keyUsageList();
      break;
    }

    default:
      break;
    }
    setState(5254);
    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, 622, MySQLParser::RuleKeyUsageElement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5257);
      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, 624, MySQLParser::RuleKeyUsageList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5260);
    keyUsageElement();
    setState(5265);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5261);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5262);
      keyUsageElement();
      setState(5267);
      _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::HOSTS_SYMBOL() {
  return getToken(MySQLParser::HOSTS_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::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, 626, MySQLParser::RuleFlushOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5283);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 661, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5268);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DES_KEY_FILE_SYMBOL || _la == MySQLParser::HOSTS_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(5270);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::BINARY_SYMBOL || ((((_la - 163) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 163)) & 35184372088837) != 0) || _la == MySQLParser::SLOW_SYMBOL) {
        setState(5269);
        logType();
      }
      setState(5272);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::LOGS_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5273);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::RELAY_SYMBOL);
      setState(5274);
      match(MySQLParser::LOGS_SYMBOL);
      setState(5276);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 660, _ctx)) {
      case 1: {
        setState(5275);
        channel();
        break;
      }

      default:
        break;
      }
      break;
    }

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

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(5279);
      antlrcpp::downCast<FlushOptionContext *>(_localctx)->option = match(MySQLParser::QUERY_SYMBOL);
      setState(5280);
      match(MySQLParser::CACHE_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5281);

      if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
      setState(5282);
      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, 628, MySQLParser::RuleLogType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5285);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::BINARY_SYMBOL || ((((_la - 163) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 163)) & 35184372088837) != 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, 630, MySQLParser::RuleFlushTables);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5287);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TABLES_SYMBOL

    || _la == MySQLParser::TABLE_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5295);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 663, _ctx)) {
    case 1: {
      setState(5288);
      match(MySQLParser::WITH_SYMBOL);
      setState(5289);
      match(MySQLParser::READ_SYMBOL);
      setState(5290);
      match(MySQLParser::LOCK_SYMBOL);
      break;
    }

    case 2: {
      setState(5291);
      identifierList();
      setState(5293);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 662, _ctx)) {
      case 1: {
        setState(5292);
        flushTablesOptions();
        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;
}

//----------------- 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, 632, MySQLParser::RuleFlushTablesOptions);

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

      if (!(serverVersion >= 50606)) throw FailedPredicateException(this, "serverVersion >= 50606");
      setState(5298);
      match(MySQLParser::FOR_SYMBOL);
      setState(5299);
      match(MySQLParser::EXPORT_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5300);
      match(MySQLParser::WITH_SYMBOL);
      setState(5301);
      match(MySQLParser::READ_SYMBOL);
      setState(5302);
      match(MySQLParser::LOCK_SYMBOL);
      break;
    }

    default:
      break;
    }
   
  }
  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, 634, MySQLParser::RulePreloadTail);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5315);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 667, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5305);
      tableRef();
      setState(5306);
      adminPartition();
      setState(5308);
      _errHandler->sync(this);

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

      || _la == MySQLParser::KEY_SYMBOL) {
        setState(5307);
        cacheKeyList();
      }
      setState(5312);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::IGNORE_SYMBOL) {
        setState(5310);
        match(MySQLParser::IGNORE_SYMBOL);
        setState(5311);
        match(MySQLParser::LEAVES_SYMBOL);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5314);
      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, 636, MySQLParser::RulePreloadList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5317);
    preloadKeys();
    setState(5322);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5318);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5319);
      preloadKeys();
      setState(5324);
      _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, 638, MySQLParser::RulePreloadKeys);
  size_t _la = 0;

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

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

    || _la == MySQLParser::KEY_SYMBOL) {
      setState(5326);
      cacheKeyList();
    }
    setState(5331);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::IGNORE_SYMBOL) {
      setState(5329);
      match(MySQLParser::IGNORE_SYMBOL);
      setState(5330);
      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, 640, MySQLParser::RuleAdminPartition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5333);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(5334);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(5335);
    allOrPartitionNameList();
    setState(5336);
    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, 642, MySQLParser::RuleResourceGroupManagement);

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

      case MySQLParser::ALTER_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5339);
        alterResourceGroup();
        break;
      }

      case MySQLParser::SET_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(5340);
        setResourceGroup();
        break;
      }

      case MySQLParser::DROP_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(5341);
        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, 644, MySQLParser::RuleCreateResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5344);
    match(MySQLParser::CREATE_SYMBOL);
    setState(5345);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(5346);
    match(MySQLParser::GROUP_SYMBOL);
    setState(5347);
    identifier();
    setState(5348);
    match(MySQLParser::TYPE_SYMBOL);
    setState(5350);
    _errHandler->sync(this);

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

    || _la == MySQLParser::ASSIGN_OPERATOR) {
      setState(5349);
      equal();
    }
    setState(5352);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::USER_SYMBOL || _la == MySQLParser::SYSTEM_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5354);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::VCPU_SYMBOL) {
      setState(5353);
      resourceGroupVcpuList();
    }
    setState(5357);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::THREAD_PRIORITY_SYMBOL) {
      setState(5356);
      resourceGroupPriority();
    }
    setState(5360);
    _errHandler->sync(this);

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

    || _la == MySQLParser::ENABLE_SYMBOL) {
      setState(5359);
      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, 646, MySQLParser::RuleResourceGroupVcpuList);
  size_t _la = 0;

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

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

    || _la == MySQLParser::ASSIGN_OPERATOR) {
      setState(5363);
      equal();
    }
    setState(5366);
    vcpuNumOrRange();
    setState(5373);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::INT_NUMBER

    || _la == MySQLParser::COMMA_SYMBOL) {
      setState(5368);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(5367);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(5370);
      vcpuNumOrRange();
      setState(5375);
      _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, 648, MySQLParser::RuleVcpuNumOrRange);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::MINUS_OPERATOR) {
      setState(5377);
      match(MySQLParser::MINUS_OPERATOR);
      setState(5378);
      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, 650, MySQLParser::RuleResourceGroupPriority);
  size_t _la = 0;

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

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

    || _la == MySQLParser::ASSIGN_OPERATOR) {
      setState(5382);
      equal();
    }
    setState(5385);
    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, 652, MySQLParser::RuleResourceGroupEnableDisable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5387);
    _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, 654, MySQLParser::RuleAlterResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5389);
    match(MySQLParser::ALTER_SYMBOL);
    setState(5390);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(5391);
    match(MySQLParser::GROUP_SYMBOL);
    setState(5392);
    resourceGroupRef();
    setState(5394);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::VCPU_SYMBOL) {
      setState(5393);
      resourceGroupVcpuList();
    }
    setState(5397);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::THREAD_PRIORITY_SYMBOL) {
      setState(5396);
      resourceGroupPriority();
    }
    setState(5400);
    _errHandler->sync(this);

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

    || _la == MySQLParser::ENABLE_SYMBOL) {
      setState(5399);
      resourceGroupEnableDisable();
    }
    setState(5403);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FORCE_SYMBOL) {
      setState(5402);
      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, 656, MySQLParser::RuleSetResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5405);
    match(MySQLParser::SET_SYMBOL);
    setState(5406);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(5407);
    match(MySQLParser::GROUP_SYMBOL);
    setState(5408);
    identifier();
    setState(5411);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FOR_SYMBOL) {
      setState(5409);
      match(MySQLParser::FOR_SYMBOL);
      setState(5410);
      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, 658, MySQLParser::RuleThreadIdList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5413);
    real_ulong_number();
    setState(5420);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((((_la - 747) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 747)) & 2199090364423) != 0)) {
      setState(5415);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(5414);
        match(MySQLParser::COMMA_SYMBOL);
      }
      setState(5417);
      real_ulong_number();
      setState(5422);
      _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, 660, MySQLParser::RuleDropResourceGroup);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5423);
    match(MySQLParser::DROP_SYMBOL);
    setState(5424);
    match(MySQLParser::RESOURCE_SYMBOL);
    setState(5425);
    match(MySQLParser::GROUP_SYMBOL);
    setState(5426);
    resourceGroupRef();
    setState(5428);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::FORCE_SYMBOL) {
      setState(5427);
      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, 662, MySQLParser::RuleUtilityStatement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5431);
      explainStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5432);
      helpCommand();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5433);
      useCommand();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5434);

      if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
      setState(5435);
      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, 664, MySQLParser::RuleDescribeStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5438);
    _la = _input->LA(1);
    if (!(((((_la - 134) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 134)) & 17592186044419) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5439);
    tableRef();
    setState(5442);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 690, _ctx)) {
    case 1: {
      setState(5440);
      textString();
      break;
    }

    case 2: {
      setState(5441);
      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);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::EXTENDED_SYMBOL() {
  return getToken(MySQLParser::EXTENDED_SYMBOL, 0);
}

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

tree::TerminalNode* MySQLParser::ExplainStatementContext::FORMAT_SYMBOL() {
  return getToken(MySQLParser::FORMAT_SYMBOL, 0);
}

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

MySQLParser::TextOrIdentifierContext* MySQLParser::ExplainStatementContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::ExplainStatementContext::ANALYZE_SYMBOL() {
  return getToken(MySQLParser::ANALYZE_SYMBOL, 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, 666, MySQLParser::RuleExplainStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5444);
    _la = _input->LA(1);
    if (!(((((_la - 134) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 134)) & 17592186044419) != 0))) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5460);
    _errHandler->sync(this);

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

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(5446);
      match(MySQLParser::EXTENDED_SYMBOL);
      break;
    }

    case 2: {
      setState(5447);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(5448);
      match(MySQLParser::PARTITIONS_SYMBOL);
      break;
    }

    case 3: {
      setState(5449);

      if (!(serverVersion >= 50605)) throw FailedPredicateException(this, "serverVersion >= 50605");
      setState(5450);
      match(MySQLParser::FORMAT_SYMBOL);
      setState(5451);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(5452);
      textOrIdentifier();
      break;
    }

    case 4: {
      setState(5453);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(5454);
      match(MySQLParser::ANALYZE_SYMBOL);
      break;
    }

    case 5: {
      setState(5455);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(5456);
      match(MySQLParser::ANALYZE_SYMBOL);
      setState(5457);
      match(MySQLParser::FORMAT_SYMBOL);
      setState(5458);
      match(MySQLParser::EQUAL_OPERATOR);
      setState(5459);
      textOrIdentifier();
      break;
    }

    default:
      break;
    }
    setState(5462);
    explainableStatement();
   
  }
  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, 668, MySQLParser::RuleExplainableStatement);

#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, 693, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5464);
      selectStatement();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5465);

      if (!(serverVersion >= 50603)) throw FailedPredicateException(this, "serverVersion >= 50603");
      setState(5470);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 692, _ctx)) {
      case 1: {
        setState(5466);
        deleteStatement();
        break;
      }

      case 2: {
        setState(5467);
        insertStatement();
        break;
      }

      case 3: {
        setState(5468);
        replaceStatement();
        break;
      }

      case 4: {
        setState(5469);
        updateStatement();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5472);

      if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
      setState(5473);
      match(MySQLParser::FOR_SYMBOL);
      setState(5474);
      match(MySQLParser::CONNECTION_SYMBOL);
      setState(5475);
      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;
}

//----------------- 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, 670, MySQLParser::RuleHelpCommand);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5478);
    match(MySQLParser::HELP_SYMBOL);
    setState(5479);
    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::IdentifierContext* MySQLParser::UseCommandContext::identifier() {
  return getRuleContext<MySQLParser::IdentifierContext>(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, 672, MySQLParser::RuleUseCommand);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5481);
    match(MySQLParser::USE_SYMBOL);
    setState(5482);
    identifier();
   
  }
  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, 674, MySQLParser::RuleRestartServer);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5484);
    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 = 676;
  enterRecursionRule(_localctx, 676, 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(5497);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 696, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<ExprIsContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(5487);
      boolPri(0);
      setState(5493);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 695, _ctx)) {
      case 1: {
        setState(5488);
        match(MySQLParser::IS_SYMBOL);
        setState(5490);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NOT_SYMBOL || _la == MySQLParser::NOT2_SYMBOL) {
          setState(5489);
          notRule();
        }
        setState(5492);
        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(5495);
      match(MySQLParser::NOT_SYMBOL);
      setState(5496);
      expr(4);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(5510);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 698, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(5508);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 697, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<ExprAndContext>(_tracker.createInstance<ExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleExpr);
          setState(5499);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(5500);
          antlrcpp::downCast<ExprAndContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::AND_SYMBOL || _la == MySQLParser::LOGICAL_AND_OPERATOR)) {
            antlrcpp::downCast<ExprAndContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(5501);
          expr(4);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<ExprXorContext>(_tracker.createInstance<ExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleExpr);
          setState(5502);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(5503);
          match(MySQLParser::XOR_SYMBOL);
          setState(5504);
          expr(3);
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<ExprOrContext>(_tracker.createInstance<ExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleExpr);
          setState(5505);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(5506);
          antlrcpp::downCast<ExprOrContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::OR_SYMBOL || _la == MySQLParser::LOGICAL_OR_OPERATOR)) {
            antlrcpp::downCast<ExprOrContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(5507);
          expr(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(5512);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 698, _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 = 678;
  enterRecursionRule(_localctx, 678, 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(5514);
    predicate();
    _ctx->stop = _input->LT(-1);
    setState(5533);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 701, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(5531);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 700, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<PrimaryExprIsNullContext>(_tracker.createInstance<BoolPriContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleBoolPri);
          setState(5516);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(5517);
          match(MySQLParser::IS_SYMBOL);
          setState(5519);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == MySQLParser::NOT_SYMBOL || _la == MySQLParser::NOT2_SYMBOL) {
            setState(5518);
            notRule();
          }
          setState(5521);
          match(MySQLParser::NULL_SYMBOL);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<PrimaryExprCompareContext>(_tracker.createInstance<BoolPriContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleBoolPri);
          setState(5522);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(5523);
          compOp();
          setState(5524);
          predicate();
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<PrimaryExprAllAnyContext>(_tracker.createInstance<BoolPriContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleBoolPri);
          setState(5526);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(5527);
          compOp();
          setState(5528);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::ALL_SYMBOL

          || _la == MySQLParser::ANY_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(5529);
          subquery();
          break;
        }

        default:
          break;
        } 
      }
      setState(5535);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 701, _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, 680, MySQLParser::RuleCompOp);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5536);
    _la = _input->LA(1);
    if (!(((((_la - 750) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 750)) & 253) != 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, 682, MySQLParser::RulePredicate);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 704, _ctx)) {
    case 1: {
      setState(5540);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL || _la == MySQLParser::NOT2_SYMBOL) {
        setState(5539);
        notRule();
      }
      setState(5542);
      predicateOperations();
      break;
    }

    case 2: {
      setState(5543);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(5544);
      match(MySQLParser::MEMBER_SYMBOL);
      setState(5546);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::OF_SYMBOL) {
        setState(5545);
        match(MySQLParser::OF_SYMBOL);
      }
      setState(5548);
      simpleExprWithParentheses();
      break;
    }

    case 3: {
      setState(5549);
      match(MySQLParser::SOUNDS_SYMBOL);
      setState(5550);
      match(MySQLParser::LIKE_SYMBOL);
      setState(5551);
      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, 684, MySQLParser::RulePredicateOperations);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5575);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::IN_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprInContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(5554);
        match(MySQLParser::IN_SYMBOL);
        setState(5560);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 705, _ctx)) {
        case 1: {
          setState(5555);
          subquery();
          break;
        }

        case 2: {
          setState(5556);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(5557);
          exprList();
          setState(5558);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::BETWEEN_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprBetweenContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(5562);
        match(MySQLParser::BETWEEN_SYMBOL);
        setState(5563);
        bitExpr(0);
        setState(5564);
        match(MySQLParser::AND_SYMBOL);
        setState(5565);
        predicate();
        break;
      }

      case MySQLParser::LIKE_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprLikeContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(5567);
        match(MySQLParser::LIKE_SYMBOL);
        setState(5568);
        simpleExpr(0);
        setState(5571);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 706, _ctx)) {
        case 1: {
          setState(5569);
          match(MySQLParser::ESCAPE_SYMBOL);
          setState(5570);
          simpleExpr(0);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::REGEXP_SYMBOL: {
        _localctx = _tracker.createInstance<MySQLParser::PredicateExprRegexContext>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(5573);
        match(MySQLParser::REGEXP_SYMBOL);
        setState(5574);
        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 = 686;
  enterRecursionRule(_localctx, 686, 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(5578);
    simpleExpr(0);
    _ctx->stop = _input->LT(-1);
    setState(5606);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 709, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(5604);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 708, _ctx)) {
        case 1: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5580);

          if (!(precpred(_ctx, 7))) throw FailedPredicateException(this, "precpred(_ctx, 7)");
          setState(5581);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = match(MySQLParser::BITWISE_XOR_OPERATOR);
          setState(5582);
          bitExpr(8);
          break;
        }

        case 2: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5583);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(5584);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::DIV_SYMBOL || _la == MySQLParser::MOD_SYMBOL || ((((_la - 760) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 760)) & 7) != 0))) {
            antlrcpp::downCast<BitExprContext *>(_localctx)->op = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(5585);
          bitExpr(7);
          break;
        }

        case 3: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5586);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(5587);
          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(5588);
          bitExpr(6);
          break;
        }

        case 4: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5589);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(5590);
          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(5591);
          bitExpr(4);
          break;
        }

        case 5: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5592);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(5593);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = match(MySQLParser::BITWISE_AND_OPERATOR);
          setState(5594);
          bitExpr(3);
          break;
        }

        case 6: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5595);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(5596);
          antlrcpp::downCast<BitExprContext *>(_localctx)->op = match(MySQLParser::BITWISE_OR_OPERATOR);
          setState(5597);
          bitExpr(2);
          break;
        }

        case 7: {
          _localctx = _tracker.createInstance<BitExprContext>(parentContext, parentState);
          pushNewRecursionContext(_localctx, startState, RuleBitExpr);
          setState(5598);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(5599);
          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(5600);
          match(MySQLParser::INTERVAL_SYMBOL);
          setState(5601);
          expr(0);
          setState(5602);
          interval();
          break;
        }

        default:
          break;
        } 
      }
      setState(5608);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 709, _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);
}
//----------------- SimpleExprVariableContext ------------------------------------------------------------------

MySQLParser::VariableContext* MySQLParser::SimpleExprVariableContext::variable() {
  return getRuleContext<MySQLParser::VariableContext>(0);
}

MySQLParser::EqualContext* MySQLParser::SimpleExprVariableContext::equal() {
  return getRuleContext<MySQLParser::EqualContext>(0);
}

MySQLParser::ExprContext* MySQLParser::SimpleExprVariableContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

MySQLParser::SimpleExprVariableContext::SimpleExprVariableContext(SimpleExprContext *ctx) { copyFrom(ctx); }

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

std::any MySQLParser::SimpleExprVariableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitSimpleExprVariable(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);
}

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);
}
//----------------- 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);
}
//----------------- 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);
}
//----------------- 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::LiteralContext* MySQLParser::SimpleExprLiteralContext::literal() {
  return getRuleContext<MySQLParser::LiteralContext>(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 = 688;
  enterRecursionRule(_localctx, 688, 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(5718);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 719, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<SimpleExprVariableContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(5610);
      variable();
      setState(5614);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 710, _ctx)) {
      case 1: {
        setState(5611);
        equal();
        setState(5612);
        expr(0);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<SimpleExprColumnRefContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5616);
      columnRef();
      setState(5618);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 711, _ctx)) {
      case 1: {
        setState(5617);
        jsonOperator();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<SimpleExprRuntimeFunctionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5620);
      runtimeFunctionCall();
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<SimpleExprFunctionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5621);
      functionCall();
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<SimpleExprLiteralContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5622);
      literal();
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<SimpleExprParamMarkerContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5623);
      match(MySQLParser::PARAM_MARKER);
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<SimpleExprSumContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5624);
      sumExpr();
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<SimpleExprGroupingOperationContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5625);

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

    case 9: {
      _localctx = _tracker.createInstance<SimpleExprWindowingFunctionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5627);

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

    case 10: {
      _localctx = _tracker.createInstance<SimpleExprUnaryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5629);
      antlrcpp::downCast<SimpleExprUnaryContext *>(_localctx)->op = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 758) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 758)) & 67) != 0))) {
        antlrcpp::downCast<SimpleExprUnaryContext *>(_localctx)->op = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5630);
      simpleExpr(14);
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<SimpleExprNotContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5631);
      not2Rule();
      setState(5632);
      simpleExpr(13);
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<SimpleExprListContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5635);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ROW_SYMBOL) {
        setState(5634);
        match(MySQLParser::ROW_SYMBOL);
      }
      setState(5637);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5638);
      exprList();
      setState(5639);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<SimpleExprSubQueryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5642);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EXISTS_SYMBOL) {
        setState(5641);
        match(MySQLParser::EXISTS_SYMBOL);
      }
      setState(5644);
      subquery();
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<SimpleExprOdbcContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5645);
      match(MySQLParser::OPEN_CURLY_SYMBOL);
      setState(5646);
      identifier();
      setState(5647);
      expr(0);
      setState(5648);
      match(MySQLParser::CLOSE_CURLY_SYMBOL);
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<SimpleExprMatchContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5650);
      match(MySQLParser::MATCH_SYMBOL);
      setState(5651);
      identListArg();
      setState(5652);
      match(MySQLParser::AGAINST_SYMBOL);
      setState(5653);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5654);
      bitExpr(0);
      setState(5656);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::IN_SYMBOL || _la == MySQLParser::WITH_SYMBOL) {
        setState(5655);
        fulltextOptions();
      }
      setState(5658);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<SimpleExprBinaryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5660);
      match(MySQLParser::BINARY_SYMBOL);
      setState(5661);
      simpleExpr(8);
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<SimpleExprCastContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5662);
      match(MySQLParser::CAST_SYMBOL);
      setState(5663);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5664);
      expr(0);
      setState(5665);
      match(MySQLParser::AS_SYMBOL);
      setState(5666);
      castType();
      setState(5668);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 715, _ctx)) {
      case 1: {
        setState(5667);
        arrayCast();
        break;
      }

      default:
        break;
      }
      setState(5670);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<SimpleExprCaseContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5672);
      match(MySQLParser::CASE_SYMBOL);
      setState(5674);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 716, _ctx)) {
      case 1: {
        setState(5673);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(5679); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(5676);
        whenExpression();
        setState(5677);
        thenExpression();
        setState(5681); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == MySQLParser::WHEN_SYMBOL);
      setState(5684);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ELSE_SYMBOL) {
        setState(5683);
        elseExpression();
      }
      setState(5686);
      match(MySQLParser::END_SYMBOL);
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<SimpleExprConvertContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5688);
      match(MySQLParser::CONVERT_SYMBOL);
      setState(5689);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5690);
      expr(0);
      setState(5691);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5692);
      castType();
      setState(5693);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<SimpleExprConvertUsingContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5695);
      match(MySQLParser::CONVERT_SYMBOL);
      setState(5696);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5697);
      expr(0);
      setState(5698);
      match(MySQLParser::USING_SYMBOL);
      setState(5699);
      charsetName();
      setState(5700);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<SimpleExprDefaultContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5702);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(5703);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5704);
      simpleIdentifier();
      setState(5705);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<SimpleExprValuesContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5707);
      match(MySQLParser::VALUES_SYMBOL);
      setState(5708);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5709);
      simpleIdentifier();
      setState(5710);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 23: {
      _localctx = _tracker.createInstance<SimpleExprIntervalContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(5712);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(5713);
      expr(0);
      setState(5714);
      interval();
      setState(5715);
      match(MySQLParser::PLUS_OPERATOR);
      setState(5716);
      expr(0);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(5728);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 721, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(5726);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 720, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<SimpleExprConcatContext>(_tracker.createInstance<SimpleExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleSimpleExpr);
          setState(5720);

          if (!(precpred(_ctx, 15))) throw FailedPredicateException(this, "precpred(_ctx, 15)");
          setState(5721);
          match(MySQLParser::CONCAT_PIPES_SYMBOL);
          setState(5722);
          simpleExpr(16);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<SimpleExprCollateContext>(_tracker.createInstance<SimpleExprContext>(parentContext, parentState));
          _localctx = newContext;
          pushNewRecursionContext(newContext, startState, RuleSimpleExpr);
          setState(5723);

          if (!(precpred(_ctx, 21))) throw FailedPredicateException(this, "precpred(_ctx, 21)");
          setState(5724);
          match(MySQLParser::COLLATE_SYMBOL);
          setState(5725);
          textOrIdentifier();
          break;
        }

        default:
          break;
        } 
      }
      setState(5730);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 721, _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, 690, MySQLParser::RuleArrayCast);

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

    if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
    setState(5732);
    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, 692, MySQLParser::RuleJsonOperator);

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

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(5735);
      match(MySQLParser::JSON_SEPARATOR_SYMBOL);
      setState(5736);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5737);

      if (!(serverVersion >= 50713)) throw FailedPredicateException(this, "serverVersion >= 50713");
      setState(5738);
      match(MySQLParser::JSON_UNQUOTED_SEPARATOR_SYMBOL);
      setState(5739);
      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::MULT_OPERATOR() {
  return getToken(MySQLParser::MULT_OPERATOR, 0);
}

tree::TerminalNode* MySQLParser::SumExprContext::COUNT_SYMBOL() {
  return getToken(MySQLParser::COUNT_SYMBOL, 0);
}

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

MySQLParser::ExprListContext* MySQLParser::SumExprContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(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, 694, MySQLParser::RuleSumExpr);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5873);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 745, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5742);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::AVG_SYMBOL);
      setState(5743);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5745);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 723, _ctx)) {
      case 1: {
        setState(5744);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5747);
      inSumExpr();
      setState(5748);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5751);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5753);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 377957122048) != 0))) {
        antlrcpp::downCast<SumExprContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(5754);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5755);
      inSumExpr();
      setState(5756);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5759);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5761);

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

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(5763);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::COUNT_SYMBOL);
      setState(5764);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5766);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ALL_SYMBOL) {
        setState(5765);
        match(MySQLParser::ALL_SYMBOL);
      }
      setState(5768);
      match(MySQLParser::MULT_OPERATOR);
      setState(5769);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5772);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(5774);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::COUNT_SYMBOL);
      setState(5775);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5783);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 729, _ctx)) {
      case 1: {
        setState(5777);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ALL_SYMBOL) {
          setState(5776);
          match(MySQLParser::ALL_SYMBOL);
        }
        setState(5779);
        match(MySQLParser::MULT_OPERATOR);
        break;
      }

      case 2: {
        setState(5780);
        inSumExpr();
        break;
      }

      case 3: {
        setState(5781);
        match(MySQLParser::DISTINCT_SYMBOL);
        setState(5782);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(5785);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5788);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(5790);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::MIN_SYMBOL);
      setState(5791);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5793);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 731, _ctx)) {
      case 1: {
        setState(5792);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5795);
      inSumExpr();
      setState(5796);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5799);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(5801);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::MAX_SYMBOL);
      setState(5802);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5804);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 733, _ctx)) {
      case 1: {
        setState(5803);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5806);
      inSumExpr();
      setState(5807);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5810);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(5812);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::STD_SYMBOL);
      setState(5813);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5814);
      inSumExpr();
      setState(5815);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5818);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(5820);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::VARIANCE_SYMBOL);
      setState(5821);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5822);
      inSumExpr();
      setState(5823);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5826);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(5828);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::STDDEV_SAMP_SYMBOL);
      setState(5829);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5830);
      inSumExpr();
      setState(5831);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5834);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(5836);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::VAR_SAMP_SYMBOL);
      setState(5837);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5838);
      inSumExpr();
      setState(5839);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5842);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(5844);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::SUM_SYMBOL);
      setState(5845);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5847);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 739, _ctx)) {
      case 1: {
        setState(5846);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5849);
      inSumExpr();
      setState(5850);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5853);
      _errHandler->sync(this);

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

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

      default:
        break;
      }
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(5855);
      antlrcpp::downCast<SumExprContext *>(_localctx)->name = match(MySQLParser::GROUP_CONCAT_SYMBOL);
      setState(5856);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5858);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 741, _ctx)) {
      case 1: {
        setState(5857);
        match(MySQLParser::DISTINCT_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(5860);
      exprList();
      setState(5862);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ORDER_SYMBOL) {
        setState(5861);
        orderClause();
      }
      setState(5866);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::SEPARATOR_SYMBOL) {
        setState(5864);
        match(MySQLParser::SEPARATOR_SYMBOL);
        setState(5865);
        textString();
      }
      setState(5868);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      setState(5871);
      _errHandler->sync(this);

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

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(5870);
        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, 696, MySQLParser::RuleGroupingOperation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5875);
    match(MySQLParser::GROUPING_SYMBOL);
    setState(5876);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(5877);
    exprList();
    setState(5878);
    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);
}

MySQLParser::SimpleExprWithParenthesesContext* MySQLParser::WindowFunctionCallContext::simpleExprWithParentheses() {
  return getRuleContext<MySQLParser::SimpleExprWithParenthesesContext>(0);
}

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

MySQLParser::ExprContext* MySQLParser::WindowFunctionCallContext::expr() {
  return getRuleContext<MySQLParser::ExprContext>(0);
}

tree::TerminalNode* MySQLParser::WindowFunctionCallContext::CLOSE_PAR_SYMBOL() {
  return getToken(MySQLParser::CLOSE_PAR_SYMBOL, 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, 698, MySQLParser::RuleWindowFunctionCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5922);
    _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(5880);
        _la = _input->LA(1);
        if (!(((((_la - 678) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 678)) & 344067) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(5881);
        parentheses();
        setState(5882);
        windowingClause();
        break;
      }

      case MySQLParser::NTILE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5884);
        match(MySQLParser::NTILE_SYMBOL);
        setState(5885);
        simpleExprWithParentheses();
        setState(5886);
        windowingClause();
        break;
      }

      case MySQLParser::LAG_SYMBOL:
      case MySQLParser::LEAD_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(5888);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::LAG_SYMBOL

        || _la == MySQLParser::LEAD_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(5889);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(5890);
        expr(0);
        setState(5892);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(5891);
          leadLagInfo();
        }
        setState(5894);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(5896);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL) {
          setState(5895);
          nullTreatment();
        }
        setState(5898);
        windowingClause();
        break;
      }

      case MySQLParser::FIRST_VALUE_SYMBOL:
      case MySQLParser::LAST_VALUE_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(5900);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::FIRST_VALUE_SYMBOL

        || _la == MySQLParser::LAST_VALUE_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(5901);
        exprWithParentheses();
        setState(5903);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL) {
          setState(5902);
          nullTreatment();
        }
        setState(5905);
        windowingClause();
        break;
      }

      case MySQLParser::NTH_VALUE_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(5907);
        match(MySQLParser::NTH_VALUE_SYMBOL);
        setState(5908);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(5909);
        expr(0);
        setState(5910);
        match(MySQLParser::COMMA_SYMBOL);
        setState(5911);
        simpleExpr(0);
        setState(5912);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(5915);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FROM_SYMBOL) {
          setState(5913);
          match(MySQLParser::FROM_SYMBOL);
          setState(5914);
          _la = _input->LA(1);
          if (!(_la == MySQLParser::FIRST_SYMBOL || _la == MySQLParser::LAST_SYMBOL)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        setState(5918);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL) {
          setState(5917);
          nullTreatment();
        }
        setState(5920);
        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;
}

//----------------- 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, 700, MySQLParser::RuleWindowingClause);

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

    case 2: {
      setState(5926);
      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::Ulonglong_numberContext* MySQLParser::LeadLagInfoContext::ulonglong_number() {
  return getRuleContext<MySQLParser::Ulonglong_numberContext>(0);
}

tree::TerminalNode* MySQLParser::LeadLagInfoContext::PARAM_MARKER() {
  return getToken(MySQLParser::PARAM_MARKER, 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, 702, MySQLParser::RuleLeadLagInfo);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5929);
    match(MySQLParser::COMMA_SYMBOL);
    setState(5932);
    _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: {
        setState(5930);
        ulonglong_number();
        break;
      }

      case MySQLParser::PARAM_MARKER: {
        setState(5931);
        match(MySQLParser::PARAM_MARKER);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(5936);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5934);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5935);
      expr(0);
    }
   
  }
  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, 704, MySQLParser::RuleNullTreatment);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5938);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::IGNORE_SYMBOL || _la == MySQLParser::RESPECT_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(5939);
    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, 706, MySQLParser::RuleJsonFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5957);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::JSON_ARRAYAGG_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(5941);
        match(MySQLParser::JSON_ARRAYAGG_SYMBOL);
        setState(5942);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(5943);
        inSumExpr();
        setState(5944);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(5946);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 755, _ctx)) {
        case 1: {
          setState(5945);
          windowingClause();
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::JSON_OBJECTAGG_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(5948);
        match(MySQLParser::JSON_OBJECTAGG_SYMBOL);
        setState(5949);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(5950);
        inSumExpr();
        setState(5951);
        match(MySQLParser::COMMA_SYMBOL);
        setState(5952);
        inSumExpr();
        setState(5953);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        setState(5955);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 756, _ctx)) {
        case 1: {
          setState(5954);
          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, 708, MySQLParser::RuleInSumExpr);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 758, _ctx)) {
    case 1: {
      setState(5959);
      match(MySQLParser::ALL_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(5962);
    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, 710, MySQLParser::RuleIdentListArg);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5965);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5966);
      identList();
      setState(5967);
      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, 712, MySQLParser::RuleIdentList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(5971);
    simpleIdentifier();
    setState(5976);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(5972);
      match(MySQLParser::COMMA_SYMBOL);
      setState(5973);
      simpleIdentifier();
      setState(5978);
      _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, 714, MySQLParser::RuleFulltextOptions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(5994);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 762, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5979);
      match(MySQLParser::IN_SYMBOL);
      setState(5980);
      match(MySQLParser::BOOLEAN_SYMBOL);
      setState(5981);
      match(MySQLParser::MODE_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(5982);
      match(MySQLParser::IN_SYMBOL);
      setState(5983);
      match(MySQLParser::NATURAL_SYMBOL);
      setState(5984);
      match(MySQLParser::LANGUAGE_SYMBOL);
      setState(5985);
      match(MySQLParser::MODE_SYMBOL);
      setState(5989);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::WITH_SYMBOL) {
        setState(5986);
        match(MySQLParser::WITH_SYMBOL);
        setState(5987);
        match(MySQLParser::QUERY_SYMBOL);
        setState(5988);
        match(MySQLParser::EXPANSION_SYMBOL);
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(5991);
      match(MySQLParser::WITH_SYMBOL);
      setState(5992);
      match(MySQLParser::QUERY_SYMBOL);
      setState(5993);
      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::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::CHAR_SYMBOL() {
  return getToken(MySQLParser::CHAR_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);
}

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

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::DATE_SYMBOL() {
  return getToken(MySQLParser::DATE_SYMBOL, 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);
}

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::INSERT_SYMBOL() {
  return getToken(MySQLParser::INSERT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::INTERVAL_SYMBOL() {
  return getToken(MySQLParser::INTERVAL_SYMBOL, 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);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::USER_SYMBOL() {
  return getToken(MySQLParser::USER_SYMBOL, 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::FROM_SYMBOL() {
  return getToken(MySQLParser::FROM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::EXTRACT_SYMBOL() {
  return getToken(MySQLParser::EXTRACT_SYMBOL, 0);
}

MySQLParser::DateTimeTtypeContext* MySQLParser::RuntimeFunctionCallContext::dateTimeTtype() {
  return getRuleContext<MySQLParser::DateTimeTtypeContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::GET_FORMAT_SYMBOL() {
  return getToken(MySQLParser::GET_FORMAT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::NOW_SYMBOL() {
  return getToken(MySQLParser::NOW_SYMBOL, 0);
}

MySQLParser::BitExprContext* MySQLParser::RuntimeFunctionCallContext::bitExpr() {
  return getRuleContext<MySQLParser::BitExprContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::IN_SYMBOL() {
  return getToken(MySQLParser::IN_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::POSITION_SYMBOL() {
  return getToken(MySQLParser::POSITION_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::TIMESTAMP_ADD_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::TIMESTAMP_DIFF_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_DIFF_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);
}

MySQLParser::ExprListWithParenthesesContext* MySQLParser::RuntimeFunctionCallContext::exprListWithParentheses() {
  return getRuleContext<MySQLParser::ExprListWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::COALESCE_SYMBOL() {
  return getToken(MySQLParser::COALESCE_SYMBOL, 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);
}

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

tree::TerminalNode* MySQLParser::RuntimeFunctionCallContext::OLD_PASSWORD_SYMBOL() {
  return getToken(MySQLParser::OLD_PASSWORD_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, 716, MySQLParser::RuleRuntimeFunctionCall);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6269);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 780, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(5996);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::CHAR_SYMBOL);
      setState(5997);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(5998);
      exprList();
      setState(6001);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::USING_SYMBOL) {
        setState(5999);
        match(MySQLParser::USING_SYMBOL);
        setState(6000);
        charsetName();
      }
      setState(6003);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6005);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::CURRENT_USER_SYMBOL);
      setState(6007);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 764, _ctx)) {
      case 1: {
        setState(6006);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6009);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::DATE_SYMBOL);
      setState(6010);
      exprWithParentheses();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6011);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::DAY_SYMBOL);
      setState(6012);
      exprWithParentheses();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6013);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::HOUR_SYMBOL);
      setState(6014);
      exprWithParentheses();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6015);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::INSERT_SYMBOL);
      setState(6016);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6017);
      expr(0);
      setState(6018);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6019);
      expr(0);
      setState(6020);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6021);
      expr(0);
      setState(6022);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6023);
      expr(0);
      setState(6024);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(6026);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::INTERVAL_SYMBOL);
      setState(6027);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6028);
      expr(0);
      setState(6031); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(6029);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6030);
        expr(0);
        setState(6033); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == MySQLParser::COMMA_SYMBOL);
      setState(6035);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(6037);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::LEFT_SYMBOL);
      setState(6038);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6039);
      expr(0);
      setState(6040);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6041);
      expr(0);
      setState(6042);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(6044);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::MINUTE_SYMBOL);
      setState(6045);
      exprWithParentheses();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(6046);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::MONTH_SYMBOL);
      setState(6047);
      exprWithParentheses();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(6048);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::RIGHT_SYMBOL);
      setState(6049);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6050);
      expr(0);
      setState(6051);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6052);
      expr(0);
      setState(6053);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(6055);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::SECOND_SYMBOL);
      setState(6056);
      exprWithParentheses();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(6057);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::TIME_SYMBOL);
      setState(6058);
      exprWithParentheses();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(6059);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::TIMESTAMP_SYMBOL);
      setState(6060);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6061);
      expr(0);
      setState(6064);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6062);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6063);
        expr(0);
      }
      setState(6066);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(6068);
      trimFunction();
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(6069);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::USER_SYMBOL);
      setState(6070);
      parentheses();
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(6071);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::VALUES_SYMBOL);
      setState(6072);
      exprWithParentheses();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(6073);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::YEAR_SYMBOL);
      setState(6074);
      exprWithParentheses();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(6075);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::ADDDATE_SYMBOL || _la == MySQLParser::SUBDATE_SYMBOL)) {
        antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6076);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6077);
      expr(0);
      setState(6078);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6084);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 767, _ctx)) {
      case 1: {
        setState(6079);
        expr(0);
        break;
      }

      case 2: {
        setState(6080);
        match(MySQLParser::INTERVAL_SYMBOL);
        setState(6081);
        expr(0);
        setState(6082);
        interval();
        break;
      }

      default:
        break;
      }
      setState(6086);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(6088);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::CURDATE_SYMBOL);
      setState(6090);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 768, _ctx)) {
      case 1: {
        setState(6089);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(6092);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::CURTIME_SYMBOL);
      setState(6094);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 769, _ctx)) {
      case 1: {
        setState(6093);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(6096);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::DATE_ADD_SYMBOL

      || _la == MySQLParser::DATE_SUB_SYMBOL)) {
        antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6097);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6098);
      expr(0);
      setState(6099);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6100);
      match(MySQLParser::INTERVAL_SYMBOL);
      setState(6101);
      expr(0);
      setState(6102);
      interval();
      setState(6103);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(6105);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::EXTRACT_SYMBOL);
      setState(6106);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6107);
      interval();
      setState(6108);
      match(MySQLParser::FROM_SYMBOL);
      setState(6109);
      expr(0);
      setState(6110);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(6112);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::GET_FORMAT_SYMBOL);
      setState(6113);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6114);
      dateTimeTtype();
      setState(6115);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6116);
      expr(0);
      setState(6117);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(6119);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::NOW_SYMBOL);
      setState(6121);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 770, _ctx)) {
      case 1: {
        setState(6120);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(6123);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::POSITION_SYMBOL);
      setState(6124);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6125);
      bitExpr(0);
      setState(6126);
      match(MySQLParser::IN_SYMBOL);
      setState(6127);
      expr(0);
      setState(6128);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(6130);
      substringFunction();
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(6131);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::SYSDATE_SYMBOL);
      setState(6133);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 771, _ctx)) {
      case 1: {
        setState(6132);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(6135);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::TIMESTAMP_ADD_SYMBOL

      || _la == MySQLParser::TIMESTAMP_DIFF_SYMBOL)) {
        antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(6136);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6137);
      intervalTimeStamp();
      setState(6138);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6139);
      expr(0);
      setState(6140);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6141);
      expr(0);
      setState(6142);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(6144);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::UTC_DATE_SYMBOL);
      setState(6146);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 772, _ctx)) {
      case 1: {
        setState(6145);
        parentheses();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(6148);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::UTC_TIME_SYMBOL);
      setState(6150);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 773, _ctx)) {
      case 1: {
        setState(6149);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(6152);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::UTC_TIMESTAMP_SYMBOL);
      setState(6154);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 774, _ctx)) {
      case 1: {
        setState(6153);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(6156);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::ASCII_SYMBOL);
      setState(6157);
      exprWithParentheses();
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(6158);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::CHARSET_SYMBOL);
      setState(6159);
      exprWithParentheses();
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(6160);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::COALESCE_SYMBOL);
      setState(6161);
      exprListWithParentheses();
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(6162);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::COLLATION_SYMBOL);
      setState(6163);
      exprWithParentheses();
      break;
    }

    case 37: {
      enterOuterAlt(_localctx, 37);
      setState(6164);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::DATABASE_SYMBOL);
      setState(6165);
      parentheses();
      break;
    }

    case 38: {
      enterOuterAlt(_localctx, 38);
      setState(6166);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::IF_SYMBOL);
      setState(6167);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6168);
      expr(0);
      setState(6169);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6170);
      expr(0);
      setState(6171);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6172);
      expr(0);
      setState(6173);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 39: {
      enterOuterAlt(_localctx, 39);
      setState(6175);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::FORMAT_SYMBOL);
      setState(6176);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6177);
      expr(0);
      setState(6178);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6179);
      expr(0);
      setState(6182);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6180);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6181);
        expr(0);
      }
      setState(6184);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 40: {
      enterOuterAlt(_localctx, 40);
      setState(6186);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::MICROSECOND_SYMBOL);
      setState(6187);
      exprWithParentheses();
      break;
    }

    case 41: {
      enterOuterAlt(_localctx, 41);
      setState(6188);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::MOD_SYMBOL);
      setState(6189);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6190);
      expr(0);
      setState(6191);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6192);
      expr(0);
      setState(6193);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 42: {
      enterOuterAlt(_localctx, 42);
      setState(6195);

      if (!(serverVersion < 50607)) throw FailedPredicateException(this, "serverVersion < 50607");
      setState(6196);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::OLD_PASSWORD_SYMBOL);
      setState(6197);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6198);
      textLiteral();
      setState(6199);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 43: {
      enterOuterAlt(_localctx, 43);
      setState(6201);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(6202);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::PASSWORD_SYMBOL);
      setState(6203);
      exprWithParentheses();
      break;
    }

    case 44: {
      enterOuterAlt(_localctx, 44);
      setState(6204);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::QUARTER_SYMBOL);
      setState(6205);
      exprWithParentheses();
      break;
    }

    case 45: {
      enterOuterAlt(_localctx, 45);
      setState(6206);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::REPEAT_SYMBOL);
      setState(6207);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6208);
      expr(0);
      setState(6209);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6210);
      expr(0);
      setState(6211);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 46: {
      enterOuterAlt(_localctx, 46);
      setState(6213);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::REPLACE_SYMBOL);
      setState(6214);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6215);
      expr(0);
      setState(6216);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6217);
      expr(0);
      setState(6218);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6219);
      expr(0);
      setState(6220);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 47: {
      enterOuterAlt(_localctx, 47);
      setState(6222);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::REVERSE_SYMBOL);
      setState(6223);
      exprWithParentheses();
      break;
    }

    case 48: {
      enterOuterAlt(_localctx, 48);
      setState(6224);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::ROW_COUNT_SYMBOL);
      setState(6225);
      parentheses();
      break;
    }

    case 49: {
      enterOuterAlt(_localctx, 49);
      setState(6226);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::TRUNCATE_SYMBOL);
      setState(6227);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6228);
      expr(0);
      setState(6229);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6230);
      expr(0);
      setState(6231);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 50: {
      enterOuterAlt(_localctx, 50);
      setState(6233);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::WEEK_SYMBOL);
      setState(6234);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6235);
      expr(0);
      setState(6238);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6236);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6237);
        expr(0);
      }
      setState(6240);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 51: {
      enterOuterAlt(_localctx, 51);
      setState(6242);
      antlrcpp::downCast<RuntimeFunctionCallContext *>(_localctx)->name = match(MySQLParser::WEIGHT_STRING_SYMBOL);
      setState(6243);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6244);
      expr(0);
      setState(6264);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 779, _ctx)) {
      case 1: {
        setState(6248);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 777, _ctx)) {
        case 1: {
          setState(6245);
          match(MySQLParser::AS_SYMBOL);
          setState(6246);
          match(MySQLParser::CHAR_SYMBOL);
          setState(6247);
          wsNumCodepoints();
          break;
        }

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

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

          if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
          setState(6251);
          weightStringLevels();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(6254);
        match(MySQLParser::AS_SYMBOL);
        setState(6255);
        match(MySQLParser::BINARY_SYMBOL);
        setState(6256);
        wsNumCodepoints();
        break;
      }

      case 3: {
        setState(6257);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6258);
        ulong_number();
        setState(6259);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6260);
        ulong_number();
        setState(6261);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6262);
        ulong_number();
        break;
      }

      default:
        break;
      }
      setState(6266);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 52: {
      enterOuterAlt(_localctx, 52);
      setState(6268);
      geometryFunction();
      break;
    }

    default:
      break;
    }
   
  }
  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::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::CONTAINS_SYMBOL() {
  return getToken(MySQLParser::CONTAINS_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::GEOMETRYCOLLECTION_SYMBOL() {
  return getToken(MySQLParser::GEOMETRYCOLLECTION_SYMBOL, 0);
}

MySQLParser::ExprListContext* MySQLParser::GeometryFunctionContext::exprList() {
  return getRuleContext<MySQLParser::ExprListContext>(0);
}

MySQLParser::ExprListWithParenthesesContext* MySQLParser::GeometryFunctionContext::exprListWithParentheses() {
  return getRuleContext<MySQLParser::ExprListWithParenthesesContext>(0);
}

tree::TerminalNode* MySQLParser::GeometryFunctionContext::LINESTRING_SYMBOL() {
  return getToken(MySQLParser::LINESTRING_SYMBOL, 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, 718, MySQLParser::RuleGeometryFunction);

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

      if (!(serverVersion < 50706)) throw FailedPredicateException(this, "serverVersion < 50706");
      setState(6272);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::CONTAINS_SYMBOL);
      setState(6273);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6274);
      expr(0);
      setState(6275);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6276);
      expr(0);
      setState(6277);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6279);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::GEOMETRYCOLLECTION_SYMBOL);
      setState(6280);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6282);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 781, _ctx)) {
      case 1: {
        setState(6281);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(6284);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6285);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::LINESTRING_SYMBOL);
      setState(6286);
      exprListWithParentheses();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6287);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::MULTILINESTRING_SYMBOL);
      setState(6288);
      exprListWithParentheses();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6289);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::MULTIPOINT_SYMBOL);
      setState(6290);
      exprListWithParentheses();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6291);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::MULTIPOLYGON_SYMBOL);
      setState(6292);
      exprListWithParentheses();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(6293);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::POINT_SYMBOL);
      setState(6294);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6295);
      expr(0);
      setState(6296);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6297);
      expr(0);
      setState(6298);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(6300);
      antlrcpp::downCast<GeometryFunctionContext *>(_localctx)->name = match(MySQLParser::POLYGON_SYMBOL);
      setState(6301);
      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, 720, MySQLParser::RuleTimeFunctionParameters);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 783, _ctx)) {
    case 1: {
      setState(6305);
      fractionalPrecision();
      break;
    }

    default:
      break;
    }
    setState(6308);
    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, 722, MySQLParser::RuleFractionalPrecision);

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

    if (!(serverVersion >= 50604)) throw FailedPredicateException(this, "serverVersion >= 50604");
    setState(6311);
    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, 724, MySQLParser::RuleWeightStringLevels);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6313);
    match(MySQLParser::LEVEL_SYMBOL);
    setState(6326);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 785, _ctx)) {
    case 1: {
      setState(6314);
      real_ulong_number();
      setState(6315);
      match(MySQLParser::MINUS_OPERATOR);
      setState(6316);
      real_ulong_number();
      break;
    }

    case 2: {
      setState(6318);
      weightStringLevelListItem();
      setState(6323);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6319);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6320);
        weightStringLevelListItem();
        setState(6325);
        _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, 726, MySQLParser::RuleWeightStringLevelListItem);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6328);
    real_ulong_number();
    setState(6334);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ASC_SYMBOL:
      case MySQLParser::DESC_SYMBOL: {
        setState(6329);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(6331);
        _errHandler->sync(this);

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

      case MySQLParser::REVERSE_SYMBOL: {
        setState(6333);
        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, 728, MySQLParser::RuleDateTimeTtype);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6336);
    _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, 730, MySQLParser::RuleTrimFunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6338);
    match(MySQLParser::TRIM_SYMBOL);
    setState(6339);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6363);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 792, _ctx)) {
    case 1: {
      setState(6340);
      expr(0);
      setState(6343);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::FROM_SYMBOL) {
        setState(6341);
        match(MySQLParser::FROM_SYMBOL);
        setState(6342);
        expr(0);
      }
      break;
    }

    case 2: {
      setState(6345);
      match(MySQLParser::LEADING_SYMBOL);
      setState(6347);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 789, _ctx)) {
      case 1: {
        setState(6346);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(6349);
      match(MySQLParser::FROM_SYMBOL);
      setState(6350);
      expr(0);
      break;
    }

    case 3: {
      setState(6351);
      match(MySQLParser::TRAILING_SYMBOL);
      setState(6353);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 790, _ctx)) {
      case 1: {
        setState(6352);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(6355);
      match(MySQLParser::FROM_SYMBOL);
      setState(6356);
      expr(0);
      break;
    }

    case 4: {
      setState(6357);
      match(MySQLParser::BOTH_SYMBOL);
      setState(6359);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 791, _ctx)) {
      case 1: {
        setState(6358);
        expr(0);
        break;
      }

      default:
        break;
      }
      setState(6361);
      match(MySQLParser::FROM_SYMBOL);
      setState(6362);
      expr(0);
      break;
    }

    default:
      break;
    }
    setState(6365);
    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, 732, MySQLParser::RuleSubstringFunction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6367);
    match(MySQLParser::SUBSTRING_SYMBOL);
    setState(6368);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6369);
    expr(0);
    setState(6382);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::COMMA_SYMBOL: {
        setState(6370);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6371);
        expr(0);
        setState(6374);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::COMMA_SYMBOL) {
          setState(6372);
          match(MySQLParser::COMMA_SYMBOL);
          setState(6373);
          expr(0);
        }
        break;
      }

      case MySQLParser::FROM_SYMBOL: {
        setState(6376);
        match(MySQLParser::FROM_SYMBOL);
        setState(6377);
        expr(0);
        setState(6380);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::FOR_SYMBOL) {
          setState(6378);
          match(MySQLParser::FOR_SYMBOL);
          setState(6379);
          expr(0);
        }
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(6384);
    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, 734, MySQLParser::RuleFunctionCall);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6400);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 798, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6386);
      pureIdentifier();
      setState(6387);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6389);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 796, _ctx)) {
      case 1: {
        setState(6388);
        udfExprList();
        break;
      }

      default:
        break;
      }
      setState(6391);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6393);
      qualifiedIdentifier();
      setState(6394);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(6396);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 797, _ctx)) {
      case 1: {
        setState(6395);
        exprList();
        break;
      }

      default:
        break;
      }
      setState(6398);
      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, 736, MySQLParser::RuleUdfExprList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6402);
    udfExpr();
    setState(6407);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6403);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6404);
      udfExpr();
      setState(6409);
      _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, 738, MySQLParser::RuleUdfExpr);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 800, _ctx)) {
    case 1: {
      setState(6411);
      selectAlias();
      break;
    }

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

  return _localctx;
}

//----------------- VariableContext ------------------------------------------------------------------

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

MySQLParser::UserVariableContext* MySQLParser::VariableContext::userVariable() {
  return getRuleContext<MySQLParser::UserVariableContext>(0);
}

MySQLParser::SystemVariableContext* MySQLParser::VariableContext::systemVariable() {
  return getRuleContext<MySQLParser::SystemVariableContext>(0);
}


size_t MySQLParser::VariableContext::getRuleIndex() const {
  return MySQLParser::RuleVariable;
}

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

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


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

MySQLParser::VariableContext* MySQLParser::variable() {
  VariableContext *_localctx = _tracker.createInstance<VariableContext>(_ctx, getState());
  enterRule(_localctx, 740, MySQLParser::RuleVariable);

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

      case MySQLParser::AT_AT_SIGN_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6415);
        systemVariable();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  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::TextOrIdentifierContext* MySQLParser::UserVariableContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::UserVariableContext::AT_TEXT_SUFFIX() {
  return getToken(MySQLParser::AT_TEXT_SUFFIX, 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, 742, MySQLParser::RuleUserVariable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6421);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::AT_SIGN_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6418);
        match(MySQLParser::AT_SIGN_SYMBOL);
        setState(6419);
        textOrIdentifier();
        break;
      }

      case MySQLParser::AT_TEXT_SUFFIX: {
        enterOuterAlt(_localctx, 2);
        setState(6420);
        match(MySQLParser::AT_TEXT_SUFFIX);
        break;
      }

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

  return _localctx;
}

//----------------- SystemVariableContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::SystemVariableContext::AT_AT_SIGN_SYMBOL() {
  return getToken(MySQLParser::AT_AT_SIGN_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::SystemVariableContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::VarIdentTypeContext* MySQLParser::SystemVariableContext::varIdentType() {
  return getRuleContext<MySQLParser::VarIdentTypeContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::SystemVariableContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}


size_t MySQLParser::SystemVariableContext::getRuleIndex() const {
  return MySQLParser::RuleSystemVariable;
}

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

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


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

MySQLParser::SystemVariableContext* MySQLParser::systemVariable() {
  SystemVariableContext *_localctx = _tracker.createInstance<SystemVariableContext>(_ctx, getState());
  enterRule(_localctx, 744, MySQLParser::RuleSystemVariable);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 803, _ctx)) {
    case 1: {
      setState(6424);
      varIdentType();
      break;
    }

    default:
      break;
    }
    setState(6427);
    textOrIdentifier();
    setState(6429);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 804, _ctx)) {
    case 1: {
      setState(6428);
      dotIdentifier();
      break;
    }

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

  return _localctx;
}

//----------------- InternalVariableNameContext ------------------------------------------------------------------

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

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

MySQLParser::LValueIdentifierContext* MySQLParser::InternalVariableNameContext::lValueIdentifier() {
  return getRuleContext<MySQLParser::LValueIdentifierContext>(0);
}

MySQLParser::DotIdentifierContext* MySQLParser::InternalVariableNameContext::dotIdentifier() {
  return getRuleContext<MySQLParser::DotIdentifierContext>(0);
}

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


size_t MySQLParser::InternalVariableNameContext::getRuleIndex() const {
  return MySQLParser::RuleInternalVariableName;
}

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

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


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

MySQLParser::InternalVariableNameContext* MySQLParser::internalVariableName() {
  InternalVariableNameContext *_localctx = _tracker.createInstance<InternalVariableNameContext>(_ctx, getState());
  enterRule(_localctx, 746, MySQLParser::RuleInternalVariableName);
  size_t _la = 0;

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

        if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
        setState(6432);
        identifier();
        setState(6434);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::DOT_SYMBOL) {
          setState(6433);
          dotIdentifier();
        }
        break;
      }

      case 2: {
        setState(6436);

        if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
        setState(6437);
        lValueIdentifier();
        setState(6439);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::DOT_SYMBOL) {
          setState(6438);
          dotIdentifier();
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6443);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(6444);
      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, 748, MySQLParser::RuleWhenExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6447);
    match(MySQLParser::WHEN_SYMBOL);
    setState(6448);
    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, 750, MySQLParser::RuleThenExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6450);
    match(MySQLParser::THEN_SYMBOL);
    setState(6451);
    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, 752, MySQLParser::RuleElseExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6453);
    match(MySQLParser::ELSE_SYMBOL);
    setState(6454);
    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::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);
}


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, 754, MySQLParser::RuleCastType);

#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, 819, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(6456);
      match(MySQLParser::BINARY_SYMBOL);
      setState(6458);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 809, _ctx)) {
      case 1: {
        setState(6457);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6460);
      match(MySQLParser::CHAR_SYMBOL);
      setState(6462);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 810, _ctx)) {
      case 1: {
        setState(6461);
        fieldLength();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 811, _ctx)) {
      case 1: {
        setState(6464);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6467);
      nchar();
      setState(6469);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 812, _ctx)) {
      case 1: {
        setState(6468);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6471);
      match(MySQLParser::SIGNED_SYMBOL);
      setState(6473);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 813, _ctx)) {
      case 1: {
        setState(6472);
        match(MySQLParser::INT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6475);
      match(MySQLParser::UNSIGNED_SYMBOL);
      setState(6477);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 814, _ctx)) {
      case 1: {
        setState(6476);
        match(MySQLParser::INT_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6479);
      match(MySQLParser::DATE_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(6480);
      match(MySQLParser::TIME_SYMBOL);
      setState(6482);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 815, _ctx)) {
      case 1: {
        setState(6481);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(6484);
      match(MySQLParser::DATETIME_SYMBOL);
      setState(6486);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 816, _ctx)) {
      case 1: {
        setState(6485);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(6488);
      match(MySQLParser::DECIMAL_SYMBOL);
      setState(6490);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 817, _ctx)) {
      case 1: {
        setState(6489);
        floatOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

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

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(6493);
      match(MySQLParser::JSON_SYMBOL);
      break;
    }

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

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(6495);
      realType();
      break;
    }

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

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(6497);
      match(MySQLParser::FLOAT_SYMBOL);
      setState(6499);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 818, _ctx)) {
      case 1: {
        setState(6498);
        standardFloatOptions();
        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;
}

//----------------- 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, 756, MySQLParser::RuleExprList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6503);
    expr(0);
    setState(6508);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6504);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6505);
      expr(0);
      setState(6510);
      _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, 758, MySQLParser::RuleCharset);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6514);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CHAR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6511);
        match(MySQLParser::CHAR_SYMBOL);
        setState(6512);
        match(MySQLParser::SET_SYMBOL);
        break;
      }

      case MySQLParser::CHARSET_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6513);
        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, 760, MySQLParser::RuleNotRule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6516);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NOT_SYMBOL || _la == MySQLParser::NOT2_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, 762, MySQLParser::RuleNot2Rule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6518);
    _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, 764, MySQLParser::RuleInterval);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6522);
    _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(6520);
        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(6521);
        _la = _input->LA(1);
        if (!(((((_la - 118) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 118)) & 15) != 0) || ((((_la - 226) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 226)) & 7) != 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, 766, MySQLParser::RuleIntervalTimeStamp);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6524);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DAY_SYMBOL || _la == MySQLParser::HOUR_SYMBOL || ((((_la - 337) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 337)) & 8257) != 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, 768, MySQLParser::RuleExprListWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6526);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6527);
    exprList();
    setState(6528);
    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, 770, MySQLParser::RuleExprWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6530);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6531);
    expr(0);
    setState(6532);
    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, 772, MySQLParser::RuleSimpleExprWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6534);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(6535);
    simpleExpr(0);
    setState(6536);
    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, 774, MySQLParser::RuleOrderList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(6538);
    orderExpression();
    setState(6543);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 823, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(6539);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6540);
        orderExpression(); 
      }
      setState(6545);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 823, _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, 776, MySQLParser::RuleOrderExpression);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 824, _ctx)) {
    case 1: {
      setState(6547);
      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, 778, MySQLParser::RuleGroupList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6550);
    groupingExpression();
    setState(6555);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(6551);
      match(MySQLParser::COMMA_SYMBOL);
      setState(6552);
      groupingExpression();
      setState(6557);
      _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, 780, MySQLParser::RuleGroupingExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6558);
    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, 782, MySQLParser::RuleChannel);

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

    if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
    setState(6561);
    match(MySQLParser::FOR_SYMBOL);
    setState(6562);
    match(MySQLParser::CHANNEL_SYMBOL);
    setState(6563);
    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, 784, MySQLParser::RuleCompoundStatement);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6566);
      returnStatement();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6567);
      ifStatement();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6568);
      caseStatement();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6569);
      labeledBlock();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(6570);
      unlabeledBlock();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(6571);
      labeledControl();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(6572);
      unlabeledControl();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(6573);
      leaveStatement();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(6574);
      iterateStatement();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(6575);
      cursorOpen();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(6576);
      cursorFetch();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(6577);
      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, 786, MySQLParser::RuleReturnStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6580);
    match(MySQLParser::RETURN_SYMBOL);
    setState(6581);
    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, 788, MySQLParser::RuleIfStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6583);
    match(MySQLParser::IF_SYMBOL);
    setState(6584);
    ifBody();
    setState(6585);
    match(MySQLParser::END_SYMBOL);
    setState(6586);
    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, 790, MySQLParser::RuleIfBody);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6588);
    expr(0);
    setState(6589);
    thenStatement();
    setState(6594);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ELSEIF_SYMBOL: {
        setState(6590);
        match(MySQLParser::ELSEIF_SYMBOL);
        setState(6591);
        ifBody();
        break;
      }

      case MySQLParser::ELSE_SYMBOL: {
        setState(6592);
        match(MySQLParser::ELSE_SYMBOL);
        setState(6593);
        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, 792, MySQLParser::RuleThenStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6596);
    match(MySQLParser::THEN_SYMBOL);
    setState(6597);
    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, 794, MySQLParser::RuleCompoundStatementList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(6602); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(6599);
              compoundStatement();
              setState(6600);
              match(MySQLParser::SEMICOLON_SYMBOL);
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(6604); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 828, _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, 796, MySQLParser::RuleCaseStatement);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 829, _ctx)) {
    case 1: {
      setState(6607);
      expr(0);
      break;
    }

    default:
      break;
    }
    setState(6613); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(6610);
      whenExpression();
      setState(6611);
      thenStatement();
      setState(6615); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == MySQLParser::WHEN_SYMBOL);
    setState(6618);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ELSE_SYMBOL) {
      setState(6617);
      elseStatement();
    }
    setState(6620);
    match(MySQLParser::END_SYMBOL);
    setState(6621);
    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, 798, MySQLParser::RuleElseStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6623);
    match(MySQLParser::ELSE_SYMBOL);
    setState(6624);
    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, 800, MySQLParser::RuleLabeledBlock);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 832, _ctx)) {
    case 1: {
      setState(6628);
      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, 802, MySQLParser::RuleUnlabeledBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6631);
    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, 804, MySQLParser::RuleLabel);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6633);
    labelIdentifier();
    setState(6634);
    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, 806, MySQLParser::RuleBeginEndBlock);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 833, _ctx)) {
    case 1: {
      setState(6637);
      spDeclarations();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 834, _ctx)) {
    case 1: {
      setState(6640);
      compoundStatementList();
      break;
    }

    default:
      break;
    }
    setState(6643);
    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, 808, MySQLParser::RuleLabeledControl);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 835, _ctx)) {
    case 1: {
      setState(6647);
      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, 810, MySQLParser::RuleUnlabeledControl);

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

      case MySQLParser::WHILE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6651);
        whileDoBlock();
        break;
      }

      case MySQLParser::REPEAT_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(6652);
        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, 812, MySQLParser::RuleLoopBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6655);
    match(MySQLParser::LOOP_SYMBOL);
    setState(6656);
    compoundStatementList();
    setState(6657);
    match(MySQLParser::END_SYMBOL);
    setState(6658);
    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, 814, MySQLParser::RuleWhileDoBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6660);
    match(MySQLParser::WHILE_SYMBOL);
    setState(6661);
    expr(0);
    setState(6662);
    match(MySQLParser::DO_SYMBOL);
    setState(6663);
    compoundStatementList();
    setState(6664);
    match(MySQLParser::END_SYMBOL);
    setState(6665);
    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, 816, MySQLParser::RuleRepeatUntilBlock);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6667);
    match(MySQLParser::REPEAT_SYMBOL);
    setState(6668);
    compoundStatementList();
    setState(6669);
    match(MySQLParser::UNTIL_SYMBOL);
    setState(6670);
    expr(0);
    setState(6671);
    match(MySQLParser::END_SYMBOL);
    setState(6672);
    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, 818, MySQLParser::RuleSpDeclarations);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(6677); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(6674);
              spDeclaration();
              setState(6675);
              match(MySQLParser::SEMICOLON_SYMBOL);
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(6679); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 837, _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, 820, MySQLParser::RuleSpDeclaration);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6682);
      conditionDeclaration();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6683);
      handlerDeclaration();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6684);
      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, 822, MySQLParser::RuleVariableDeclaration);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6687);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(6688);
    identifierList();
    setState(6689);
    dataType();
    setState(6691);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::COLLATE_SYMBOL) {
      setState(6690);
      collate();
    }
    setState(6695);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(6693);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(6694);
      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, 824, MySQLParser::RuleConditionDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6697);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(6698);
    identifier();
    setState(6699);
    match(MySQLParser::CONDITION_SYMBOL);
    setState(6700);
    match(MySQLParser::FOR_SYMBOL);
    setState(6701);
    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, 826, MySQLParser::RuleSpCondition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6705);
    _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(6703);
        ulong_number();
        break;
      }

      case MySQLParser::SQLSTATE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6704);
        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, 828, MySQLParser::RuleSqlstate);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 842, _ctx)) {
    case 1: {
      setState(6708);
      match(MySQLParser::VALUE_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(6711);
    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, 830, 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(6713);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(6714);
    _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(6715);
    match(MySQLParser::HANDLER_SYMBOL);
    setState(6716);
    match(MySQLParser::FOR_SYMBOL);
    setState(6717);
    handlerCondition();
    setState(6722);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 843, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(6718);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6719);
        handlerCondition(); 
      }
      setState(6724);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 843, _ctx);
    }
    setState(6725);
    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, 832, MySQLParser::RuleHandlerCondition);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6728);
      identifier();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6729);
      match(MySQLParser::SQLWARNING_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(6730);
      notRule();
      setState(6731);
      match(MySQLParser::FOUND_SYMBOL);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(6733);
      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, 834, MySQLParser::RuleCursorDeclaration);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6736);
    match(MySQLParser::DECLARE_SYMBOL);
    setState(6737);
    identifier();
    setState(6738);
    match(MySQLParser::CURSOR_SYMBOL);
    setState(6739);
    match(MySQLParser::FOR_SYMBOL);
    setState(6740);
    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, 836, MySQLParser::RuleIterateStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6742);
    match(MySQLParser::ITERATE_SYMBOL);
    setState(6743);
    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, 838, MySQLParser::RuleLeaveStatement);

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

  return _localctx;
}

//----------------- GetDiagnosticsContext ------------------------------------------------------------------

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

tree::TerminalNode* MySQLParser::GetDiagnosticsContext::GET_SYMBOL() {
  return getToken(MySQLParser::GET_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsContext::DIAGNOSTICS_SYMBOL() {
  return getToken(MySQLParser::DIAGNOSTICS_SYMBOL, 0);
}

std::vector<MySQLParser::StatementInformationItemContext *> MySQLParser::GetDiagnosticsContext::statementInformationItem() {
  return getRuleContexts<MySQLParser::StatementInformationItemContext>();
}

MySQLParser::StatementInformationItemContext* MySQLParser::GetDiagnosticsContext::statementInformationItem(size_t i) {
  return getRuleContext<MySQLParser::StatementInformationItemContext>(i);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsContext::CONDITION_SYMBOL() {
  return getToken(MySQLParser::CONDITION_SYMBOL, 0);
}

MySQLParser::SignalAllowedExprContext* MySQLParser::GetDiagnosticsContext::signalAllowedExpr() {
  return getRuleContext<MySQLParser::SignalAllowedExprContext>(0);
}

std::vector<MySQLParser::ConditionInformationItemContext *> MySQLParser::GetDiagnosticsContext::conditionInformationItem() {
  return getRuleContexts<MySQLParser::ConditionInformationItemContext>();
}

MySQLParser::ConditionInformationItemContext* MySQLParser::GetDiagnosticsContext::conditionInformationItem(size_t i) {
  return getRuleContext<MySQLParser::ConditionInformationItemContext>(i);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsContext::CURRENT_SYMBOL() {
  return getToken(MySQLParser::CURRENT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::GetDiagnosticsContext::STACKED_SYMBOL() {
  return getToken(MySQLParser::STACKED_SYMBOL, 0);
}

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

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


size_t MySQLParser::GetDiagnosticsContext::getRuleIndex() const {
  return MySQLParser::RuleGetDiagnostics;
}

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

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


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

MySQLParser::GetDiagnosticsContext* MySQLParser::getDiagnostics() {
  GetDiagnosticsContext *_localctx = _tracker.createInstance<GetDiagnosticsContext>(_ctx, getState());
  enterRule(_localctx, 840, MySQLParser::RuleGetDiagnostics);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 845, _ctx)) {
    case 1: {
      setState(6749);
      match(MySQLParser::CURRENT_SYMBOL);
      break;
    }

    case 2: {
      setState(6750);

      if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
      setState(6751);
      match(MySQLParser::STACKED_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(6754);
    match(MySQLParser::DIAGNOSTICS_SYMBOL);
    setState(6773);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 848, _ctx)) {
    case 1: {
      setState(6755);
      statementInformationItem();
      setState(6760);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6756);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6757);
        statementInformationItem();
        setState(6762);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 2: {
      setState(6763);
      match(MySQLParser::CONDITION_SYMBOL);
      setState(6764);
      signalAllowedExpr();
      setState(6765);
      conditionInformationItem();
      setState(6770);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6766);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6767);
        conditionInformationItem();
        setState(6772);
        _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::VariableContext* MySQLParser::SignalAllowedExprContext::variable() {
  return getRuleContext<MySQLParser::VariableContext>(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, 842, MySQLParser::RuleSignalAllowedExpr);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6776);
      variable();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(6777);
      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::VariableContext* MySQLParser::StatementInformationItemContext::variable() {
  return getRuleContext<MySQLParser::VariableContext>(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, 844, MySQLParser::RuleStatementInformationItem);
  size_t _la = 0;

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

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

    default:
      break;
    }
    setState(6784);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(6785);
    _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::VariableContext* MySQLParser::ConditionInformationItemContext::variable() {
  return getRuleContext<MySQLParser::VariableContext>(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, 846, MySQLParser::RuleConditionInformationItem);

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

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

    default:
      break;
    }
    setState(6791);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(6794);
    _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(6792);
        signalInformationItemName();
        break;
      }

      case MySQLParser::RETURNED_SQLSTATE_SYMBOL: {
        setState(6793);
        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, 848, MySQLParser::RuleSignalInformationItemName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6796);
    _la = _input->LA(1);
    if (!(((((_la - 53) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 53)) & 18014518769616897) != 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, 850, MySQLParser::RuleSignalStatement);
  size_t _la = 0;

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

    case 2: {
      setState(6800);
      sqlstate();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == MySQLParser::SET_SYMBOL) {
      setState(6803);
      match(MySQLParser::SET_SYMBOL);
      setState(6804);
      signalInformationItem();
      setState(6809);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6805);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6806);
        signalInformationItem();
        setState(6811);
        _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, 852, MySQLParser::RuleResignalStatement);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 856, _ctx)) {
    case 1: {
      setState(6815);
      identifier();
      break;
    }

    case 2: {
      setState(6816);
      sqlstate();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == MySQLParser::SET_SYMBOL) {
      setState(6819);
      match(MySQLParser::SET_SYMBOL);
      setState(6820);
      signalInformationItem();
      setState(6825);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(6821);
        match(MySQLParser::COMMA_SYMBOL);
        setState(6822);
        signalInformationItem();
        setState(6827);
        _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, 854, MySQLParser::RuleSignalInformationItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6830);
    signalInformationItemName();
    setState(6831);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(6832);
    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, 856, MySQLParser::RuleCursorOpen);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6834);
    match(MySQLParser::OPEN_SYMBOL);
    setState(6835);
    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, 858, MySQLParser::RuleCursorClose);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6837);
    match(MySQLParser::CLOSE_SYMBOL);
    setState(6838);
    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, 860, MySQLParser::RuleCursorFetch);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 860, _ctx)) {
    case 1: {
      setState(6842);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::NEXT_SYMBOL) {
        setState(6841);
        match(MySQLParser::NEXT_SYMBOL);
      }
      setState(6844);
      match(MySQLParser::FROM_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(6847);
    identifier();
    setState(6848);
    match(MySQLParser::INTO_SYMBOL);
    setState(6849);
    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, 862, MySQLParser::RuleSchedule);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(6864);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::AT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6851);
        match(MySQLParser::AT_SYMBOL);
        setState(6852);
        expr(0);
        break;
      }

      case MySQLParser::EVERY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6853);
        match(MySQLParser::EVERY_SYMBOL);
        setState(6854);
        expr(0);
        setState(6855);
        interval();
        setState(6858);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::STARTS_SYMBOL) {
          setState(6856);
          match(MySQLParser::STARTS_SYMBOL);
          setState(6857);
          expr(0);
        }
        setState(6862);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::ENDS_SYMBOL) {
          setState(6860);
          match(MySQLParser::ENDS_SYMBOL);
          setState(6861);
          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, 864, MySQLParser::RuleColumnDefinition);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 864, _ctx)) {
    case 1: {
      setState(6868);
      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, 866, MySQLParser::RuleCheckOrReferences);

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

      if (!(serverVersion < 80016)) throw FailedPredicateException(this, "serverVersion < 80016");
      setState(6872);
      checkConstraint();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(6873);
      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, 868, MySQLParser::RuleCheckConstraint);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(6876);
    match(MySQLParser::CHECK_SYMBOL);
    setState(6877);
    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, 870, MySQLParser::RuleConstraintEnforcement);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::NOT_SYMBOL) {
      setState(6879);
      match(MySQLParser::NOT_SYMBOL);
    }
    setState(6882);
    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::KeyListVariantsContext* MySQLParser::TableConstraintDefContext::keyListVariants() {
  return getRuleContext<MySQLParser::KeyListVariantsContext>(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, 872, MySQLParser::RuleTableConstraintDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(6959);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::INDEX_SYMBOL:
      case MySQLParser::KEY_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(6884);
        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(6886);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 867, _ctx)) {
        case 1: {
          setState(6885);
          indexNameAndType();
          break;
        }

        default:
          break;
        }
        setState(6888);
        keyListVariants();
        setState(6892);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 868, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(6889);
            indexOption(); 
          }
          setState(6894);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 868, _ctx);
        }
        break;
      }

      case MySQLParser::FULLTEXT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(6895);
        antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::FULLTEXT_SYMBOL);
        setState(6897);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 869, _ctx)) {
        case 1: {
          setState(6896);
          keyOrIndex();
          break;
        }

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

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 870, _ctx)) {
        case 1: {
          setState(6899);
          indexName();
          break;
        }

        default:
          break;
        }
        setState(6902);
        keyListVariants();
        setState(6906);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 871, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(6903);
            fulltextIndexOption(); 
          }
          setState(6908);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 871, _ctx);
        }
        break;
      }

      case MySQLParser::SPATIAL_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(6909);
        antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::SPATIAL_SYMBOL);
        setState(6911);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 872, _ctx)) {
        case 1: {
          setState(6910);
          keyOrIndex();
          break;
        }

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

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 873, _ctx)) {
        case 1: {
          setState(6913);
          indexName();
          break;
        }

        default:
          break;
        }
        setState(6916);
        keyListVariants();
        setState(6920);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 874, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(6917);
            spatialIndexOption(); 
          }
          setState(6922);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 874, _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(6924);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::CONSTRAINT_SYMBOL) {
          setState(6923);
          constraintName();
        }
        setState(6957);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case MySQLParser::PRIMARY_SYMBOL:
          case MySQLParser::UNIQUE_SYMBOL: {
            setState(6932);
            _errHandler->sync(this);
            switch (_input->LA(1)) {
              case MySQLParser::PRIMARY_SYMBOL: {
                setState(6926);
                antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::PRIMARY_SYMBOL);
                setState(6927);
                match(MySQLParser::KEY_SYMBOL);
                break;
              }

              case MySQLParser::UNIQUE_SYMBOL: {
                setState(6928);
                antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::UNIQUE_SYMBOL);
                setState(6930);
                _errHandler->sync(this);

                switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 876, _ctx)) {
                case 1: {
                  setState(6929);
                  keyOrIndex();
                  break;
                }

                default:
                  break;
                }
                break;
              }

            default:
              throw NoViableAltException(this);
            }
            setState(6935);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 878, _ctx)) {
            case 1: {
              setState(6934);
              indexNameAndType();
              break;
            }

            default:
              break;
            }
            setState(6937);
            keyListVariants();
            setState(6941);
            _errHandler->sync(this);
            alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 879, _ctx);
            while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
              if (alt == 1) {
                setState(6938);
                indexOption(); 
              }
              setState(6943);
              _errHandler->sync(this);
              alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 879, _ctx);
            }
            break;
          }

          case MySQLParser::FOREIGN_SYMBOL: {
            setState(6944);
            antlrcpp::downCast<TableConstraintDefContext *>(_localctx)->type = match(MySQLParser::FOREIGN_SYMBOL);
            setState(6945);
            match(MySQLParser::KEY_SYMBOL);
            setState(6947);
            _errHandler->sync(this);

            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 880, _ctx)) {
            case 1: {
              setState(6946);
              indexName();
              break;
            }

            default:
              break;
            }
            setState(6949);
            keyList();
            setState(6950);
            references();
            break;
          }

          case MySQLParser::CHECK_SYMBOL: {
            setState(6952);
            checkConstraint();
            setState(6955);
            _errHandler->sync(this);

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

              if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
              setState(6954);
              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, 874, MySQLParser::RuleConstraintName);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 884, _ctx)) {
    case 1: {
      setState(6962);
      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, 876, 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(6965);
    dataType();
    setState(7001);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 892, _ctx)) {
    case 1: {
      setState(6969);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 885, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(6966);
          columnAttribute(); 
        }
        setState(6971);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 885, _ctx);
      }
      break;
    }

    case 2: {
      setState(6972);

      if (!(serverVersion >= 50707)) throw FailedPredicateException(this, "serverVersion >= 50707");
      setState(6974);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::COLLATE_SYMBOL) {
        setState(6973);
        collate();
      }
      setState(6978);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::GENERATED_SYMBOL) {
        setState(6976);
        match(MySQLParser::GENERATED_SYMBOL);
        setState(6977);
        match(MySQLParser::ALWAYS_SYMBOL);
      }
      setState(6980);
      match(MySQLParser::AS_SYMBOL);
      setState(6981);
      exprWithParentheses();
      setState(6983);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 888, _ctx)) {
      case 1: {
        setState(6982);
        _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(6999);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 891, _ctx)) {
      case 1: {
        setState(6985);

        if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
        setState(6989);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 889, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(6986);
            gcolAttribute(); 
          }
          setState(6991);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 889, _ctx);
        }
        break;
      }

      case 2: {
        setState(6992);

        if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
        setState(6996);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 890, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(6993);
            columnAttribute(); 
          }
          setState(6998);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 890, _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::SignedLiteralContext* MySQLParser::ColumnAttributeContext::signedLiteral() {
  return getRuleContext<MySQLParser::SignedLiteralContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::NOW_SYMBOL() {
  return getToken(MySQLParser::NOW_SYMBOL, 0);
}

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

MySQLParser::TimeFunctionParametersContext* MySQLParser::ColumnAttributeContext::timeFunctionParameters() {
  return getRuleContext<MySQLParser::TimeFunctionParametersContext>(0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::UPDATE_SYMBOL() {
  return getToken(MySQLParser::UPDATE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::ColumnAttributeContext::ON_SYMBOL() {
  return getToken(MySQLParser::ON_SYMBOL, 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);
}


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, 878, MySQLParser::RuleColumnAttribute);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == MySQLParser::NOT_SYMBOL) {
        setState(7003);
        match(MySQLParser::NOT_SYMBOL);
      }
      setState(7006);
      nullLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7007);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(7008);
      match(MySQLParser::NOT_SYMBOL);
      setState(7009);
      match(MySQLParser::SECONDARY_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7010);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::DEFAULT_SYMBOL);
      setState(7018);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 895, _ctx)) {
      case 1: {
        setState(7011);
        signedLiteral();
        break;
      }

      case 2: {
        setState(7012);
        match(MySQLParser::NOW_SYMBOL);
        setState(7014);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 894, _ctx)) {
        case 1: {
          setState(7013);
          timeFunctionParameters();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 3: {
        setState(7016);

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

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7020);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::ON_SYMBOL);
      setState(7021);
      match(MySQLParser::UPDATE_SYMBOL);
      setState(7022);
      match(MySQLParser::NOW_SYMBOL);
      setState(7024);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 896, _ctx)) {
      case 1: {
        setState(7023);
        timeFunctionParameters();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7026);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::AUTO_INCREMENT_SYMBOL);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(7027);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::SERIAL_SYMBOL);
      setState(7028);
      match(MySQLParser::DEFAULT_SYMBOL);
      setState(7029);
      match(MySQLParser::VALUE_SYMBOL);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7031);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::PRIMARY_SYMBOL) {
        setState(7030);
        match(MySQLParser::PRIMARY_SYMBOL);
      }
      setState(7033);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::KEY_SYMBOL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7034);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::UNIQUE_SYMBOL);
      setState(7036);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 898, _ctx)) {
      case 1: {
        setState(7035);
        match(MySQLParser::KEY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(7038);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::COMMENT_SYMBOL);
      setState(7039);
      textLiteral();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(7040);
      collate();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(7041);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::COLUMN_FORMAT_SYMBOL);
      setState(7042);
      columnFormat();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(7043);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::STORAGE_SYMBOL);
      setState(7044);
      storageMedia();
      break;
    }

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

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(7046);
      antlrcpp::downCast<ColumnAttributeContext *>(_localctx)->value = match(MySQLParser::SRID_SYMBOL);
      setState(7047);
      real_ulonglong_number();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(7048);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(7050);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::CONSTRAINT_SYMBOL) {
        setState(7049);
        constraintName();
      }
      setState(7052);
      checkConstraint();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(7053);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(7054);
      constraintEnforcement();
      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, 880, MySQLParser::RuleColumnFormat);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7057);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::DEFAULT_SYMBOL

    || _la == MySQLParser::DYNAMIC_SYMBOL || _la == MySQLParser::FIXED_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;
}

//----------------- 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, 882, MySQLParser::RuleStorageMedia);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7059);
    _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;
}

//----------------- 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, 884, MySQLParser::RuleGcolAttribute);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7075);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UNIQUE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7061);
        match(MySQLParser::UNIQUE_SYMBOL);
        setState(7063);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 901, _ctx)) {
        case 1: {
          setState(7062);
          match(MySQLParser::KEY_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7065);
        match(MySQLParser::COMMENT_SYMBOL);
        setState(7066);
        textString();
        break;
      }

      case MySQLParser::NOT_SYMBOL:
      case MySQLParser::NULL_SYMBOL:
      case MySQLParser::NOT2_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(7068);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::NOT_SYMBOL || _la == MySQLParser::NOT2_SYMBOL) {
          setState(7067);
          notRule();
        }
        setState(7070);
        match(MySQLParser::NULL_SYMBOL);
        break;
      }

      case MySQLParser::KEY_SYMBOL:
      case MySQLParser::PRIMARY_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(7072);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::PRIMARY_SYMBOL) {
          setState(7071);
          match(MySQLParser::PRIMARY_SYMBOL);
        }
        setState(7074);
        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, 886, MySQLParser::RuleReferences);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(7079);
      identifierListWithParentheses();
    }
    setState(7084);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::MATCH_SYMBOL) {
      setState(7082);
      match(MySQLParser::MATCH_SYMBOL);
      setState(7083);
      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(7102);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 909, _ctx)) {
    case 1: {
      setState(7086);
      match(MySQLParser::ON_SYMBOL);
      setState(7087);
      antlrcpp::downCast<ReferencesContext *>(_localctx)->option = match(MySQLParser::UPDATE_SYMBOL);
      setState(7088);
      deleteOption();
      setState(7092);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ON_SYMBOL) {
        setState(7089);
        match(MySQLParser::ON_SYMBOL);
        setState(7090);
        match(MySQLParser::DELETE_SYMBOL);
        setState(7091);
        deleteOption();
      }
      break;
    }

    case 2: {
      setState(7094);
      match(MySQLParser::ON_SYMBOL);
      setState(7095);
      antlrcpp::downCast<ReferencesContext *>(_localctx)->option = match(MySQLParser::DELETE_SYMBOL);
      setState(7096);
      deleteOption();
      setState(7100);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::ON_SYMBOL) {
        setState(7097);
        match(MySQLParser::ON_SYMBOL);
        setState(7098);
        match(MySQLParser::UPDATE_SYMBOL);
        setState(7099);
        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::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, 888, MySQLParser::RuleDeleteOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7109);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::CASCADE_SYMBOL:
      case MySQLParser::RESTRICT_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7104);
        _la = _input->LA(1);
        if (!(_la == MySQLParser::CASCADE_SYMBOL || _la == MySQLParser::RESTRICT_SYMBOL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      case MySQLParser::SET_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7105);
        match(MySQLParser::SET_SYMBOL);
        setState(7106);
        nullLiteral();
        break;
      }

      case MySQLParser::NO_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(7107);
        match(MySQLParser::NO_SYMBOL);
        setState(7108);
        match(MySQLParser::ACTION_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;
}

//----------------- 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, 890, MySQLParser::RuleKeyList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7111);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7112);
    keyPart();
    setState(7117);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7113);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7114);
      keyPart();
      setState(7119);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(7120);
    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, 892, MySQLParser::RuleKeyPart);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(7123);
      fieldLength();
    }
    setState(7127);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
      setState(7126);
      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, 894, MySQLParser::RuleKeyListWithExpression);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7129);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7130);
    keyPartOrExpression();
    setState(7135);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7131);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7132);
      keyPartOrExpression();
      setState(7137);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(7138);
    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, 896, MySQLParser::RuleKeyPartOrExpression);
  size_t _la = 0;

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

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

      _la = _input->LA(1);
      if (_la == MySQLParser::ASC_SYMBOL || _la == MySQLParser::DESC_SYMBOL) {
        setState(7142);
        direction();
      }
      break;
    }

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

  return _localctx;
}

//----------------- KeyListVariantsContext ------------------------------------------------------------------

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

MySQLParser::KeyListWithExpressionContext* MySQLParser::KeyListVariantsContext::keyListWithExpression() {
  return getRuleContext<MySQLParser::KeyListWithExpressionContext>(0);
}

MySQLParser::KeyListContext* MySQLParser::KeyListVariantsContext::keyList() {
  return getRuleContext<MySQLParser::KeyListContext>(0);
}


size_t MySQLParser::KeyListVariantsContext::getRuleIndex() const {
  return MySQLParser::RuleKeyListVariants;
}

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

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


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

MySQLParser::KeyListVariantsContext* MySQLParser::keyListVariants() {
  KeyListVariantsContext *_localctx = _tracker.createInstance<KeyListVariantsContext>(_ctx, getState());
  enterRule(_localctx, 898, MySQLParser::RuleKeyListVariants);

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

      if (!(serverVersion >= 80013)) throw FailedPredicateException(this, "serverVersion >= 80013");
      setState(7148);
      keyListWithExpression();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7149);

      if (!(serverVersion < 80013)) throw FailedPredicateException(this, "serverVersion < 80013");
      setState(7150);
      keyList();
      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, 900, MySQLParser::RuleIndexType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7153);
    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, 902, MySQLParser::RuleIndexOption);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7156);
      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);
}


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, 904, MySQLParser::RuleCommonIndexOption);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7160);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7163);
      ulong_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7164);
      match(MySQLParser::COMMENT_SYMBOL);
      setState(7165);
      textLiteral();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7166);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(7167);
      visibility();
      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, 906, MySQLParser::RuleVisibility);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7170);
    _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, 908, MySQLParser::RuleIndexTypeClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7172);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::TYPE_SYMBOL

    || _la == MySQLParser::USING_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(7173);
    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, 910, MySQLParser::RuleFulltextIndexOption);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7176);
      match(MySQLParser::WITH_SYMBOL);
      setState(7177);
      match(MySQLParser::PARSER_SYMBOL);
      setState(7178);
      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, 912, MySQLParser::RuleSpatialIndexOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7181);
    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, 914, MySQLParser::RuleDataTypeDefinition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7183);
    dataType();
    setState(7184);
    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::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, 916, MySQLParser::RuleDataType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7333);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 955, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7186);
      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(7188);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 922, _ctx)) {
      case 1: {
        setState(7187);
        fieldLength();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 923, _ctx)) {
      case 1: {
        setState(7190);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7198);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::REAL_SYMBOL: {
          setState(7193);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::REAL_SYMBOL);
          break;
        }

        case MySQLParser::DOUBLE_SYMBOL: {
          setState(7194);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::DOUBLE_SYMBOL);
          setState(7196);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 924, _ctx)) {
          case 1: {
            setState(7195);
            match(MySQLParser::PRECISION_SYMBOL);
            break;
          }

          default:
            break;
          }
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(7201);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 926, _ctx)) {
      case 1: {
        setState(7200);
        precision();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 927, _ctx)) {
      case 1: {
        setState(7203);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7206);
      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(7208);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 928, _ctx)) {
      case 1: {
        setState(7207);
        floatOptions();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 929, _ctx)) {
      case 1: {
        setState(7210);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7213);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::BIT_SYMBOL);
      setState(7215);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 930, _ctx)) {
      case 1: {
        setState(7214);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7217);
      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(7218);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::CHAR_SYMBOL);
      setState(7220);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 931, _ctx)) {
      case 1: {
        setState(7219);
        fieldLength();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 932, _ctx)) {
      case 1: {
        setState(7222);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7225);
      nchar();
      setState(7227);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 933, _ctx)) {
      case 1: {
        setState(7226);
        fieldLength();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 934, _ctx)) {
      case 1: {
        setState(7229);
        match(MySQLParser::BINARY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7232);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::BINARY_SYMBOL);
      setState(7234);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 935, _ctx)) {
      case 1: {
        setState(7233);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(7239);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::CHAR_SYMBOL: {
          setState(7236);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::CHAR_SYMBOL);
          setState(7237);
          match(MySQLParser::VARYING_SYMBOL);
          break;
        }

        case MySQLParser::VARCHAR_SYMBOL: {
          setState(7238);
          antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::VARCHAR_SYMBOL);
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(7241);
      fieldLength();
      setState(7243);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 937, _ctx)) {
      case 1: {
        setState(7242);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(7255);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 938, _ctx)) {
      case 1: {
        setState(7245);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NATIONAL_SYMBOL);
        setState(7246);
        match(MySQLParser::VARCHAR_SYMBOL);
        break;
      }

      case 2: {
        setState(7247);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NVARCHAR_SYMBOL);
        break;
      }

      case 3: {
        setState(7248);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NCHAR_SYMBOL);
        setState(7249);
        match(MySQLParser::VARCHAR_SYMBOL);
        break;
      }

      case 4: {
        setState(7250);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NATIONAL_SYMBOL);
        setState(7251);
        match(MySQLParser::CHAR_SYMBOL);
        setState(7252);
        match(MySQLParser::VARYING_SYMBOL);
        break;
      }

      case 5: {
        setState(7253);
        antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::NCHAR_SYMBOL);
        setState(7254);
        match(MySQLParser::VARYING_SYMBOL);
        break;
      }

      default:
        break;
      }
      setState(7257);
      fieldLength();
      setState(7259);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 939, _ctx)) {
      case 1: {
        setState(7258);
        match(MySQLParser::BINARY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(7261);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::VARBINARY_SYMBOL);
      setState(7262);
      fieldLength();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(7263);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::YEAR_SYMBOL);
      setState(7265);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 940, _ctx)) {
      case 1: {
        setState(7264);
        fieldLength();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 941, _ctx)) {
      case 1: {
        setState(7267);
        fieldOptions();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(7270);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::DATE_SYMBOL);
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(7271);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TIME_SYMBOL);
      setState(7273);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 942, _ctx)) {
      case 1: {
        setState(7272);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(7275);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TIMESTAMP_SYMBOL);
      setState(7277);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 943, _ctx)) {
      case 1: {
        setState(7276);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(7279);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::DATETIME_SYMBOL);
      setState(7281);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 944, _ctx)) {
      case 1: {
        setState(7280);
        typeDatetimePrecision();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(7283);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TINYBLOB_SYMBOL);
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(7284);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::BLOB_SYMBOL);
      setState(7286);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 945, _ctx)) {
      case 1: {
        setState(7285);
        fieldLength();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(7288);
      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 20: {
      enterOuterAlt(_localctx, 20);
      setState(7289);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::LONG_SYMBOL);
      setState(7290);
      match(MySQLParser::VARBINARY_SYMBOL);
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(7291);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::LONG_SYMBOL);
      setState(7295);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 946, _ctx)) {
      case 1: {
        setState(7292);
        match(MySQLParser::CHAR_SYMBOL);
        setState(7293);
        match(MySQLParser::VARYING_SYMBOL);
        break;
      }

      case 2: {
        setState(7294);
        match(MySQLParser::VARCHAR_SYMBOL);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 947, _ctx)) {
      case 1: {
        setState(7297);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(7300);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TINYTEXT_SYMBOL);
      setState(7302);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 948, _ctx)) {
      case 1: {
        setState(7301);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(7304);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::TEXT_SYMBOL);
      setState(7306);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 949, _ctx)) {
      case 1: {
        setState(7305);
        fieldLength();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 950, _ctx)) {
      case 1: {
        setState(7308);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(7311);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::MEDIUMTEXT_SYMBOL);
      setState(7313);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 951, _ctx)) {
      case 1: {
        setState(7312);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(7315);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::LONGTEXT_SYMBOL);
      setState(7317);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 952, _ctx)) {
      case 1: {
        setState(7316);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(7319);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::ENUM_SYMBOL);
      setState(7320);
      stringList();
      setState(7322);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 953, _ctx)) {
      case 1: {
        setState(7321);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(7324);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::SET_SYMBOL);
      setState(7325);
      stringList();
      setState(7327);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 954, _ctx)) {
      case 1: {
        setState(7326);
        charsetWithOptBinary();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(7329);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::SERIAL_SYMBOL);
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(7330);

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(7331);
      antlrcpp::downCast<DataTypeContext *>(_localctx)->type = match(MySQLParser::JSON_SYMBOL);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(7332);
      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 - 351) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 351)) & 3458764513820540935) != 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, 918, MySQLParser::RuleNchar);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7338);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::NCHAR_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7335);
        antlrcpp::downCast<NcharContext *>(_localctx)->type = match(MySQLParser::NCHAR_SYMBOL);
        break;
      }

      case MySQLParser::NATIONAL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7336);
        antlrcpp::downCast<NcharContext *>(_localctx)->type = match(MySQLParser::NATIONAL_SYMBOL);
        setState(7337);
        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, 920, MySQLParser::RuleRealType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7345);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::REAL_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7340);
        antlrcpp::downCast<RealTypeContext *>(_localctx)->type = match(MySQLParser::REAL_SYMBOL);
        break;
      }

      case MySQLParser::DOUBLE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7341);
        antlrcpp::downCast<RealTypeContext *>(_localctx)->type = match(MySQLParser::DOUBLE_SYMBOL);
        setState(7343);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 957, _ctx)) {
        case 1: {
          setState(7342);
          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, 922, MySQLParser::RuleFieldLength);

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

    case 2: {
      setState(7349);
      match(MySQLParser::DECIMAL_NUMBER);
      break;
    }

    default:
      break;
    }
    setState(7352);
    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, 924, 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(7355); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(7354);
              _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(7357); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 960, _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, 926, MySQLParser::RuleCharsetWithOptBinary);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7360);
      unicode();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7361);
      match(MySQLParser::BYTE_SYMBOL);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7362);
      charset();
      setState(7363);
      charsetName();
      setState(7365);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 961, _ctx)) {
      case 1: {
        setState(7364);
        match(MySQLParser::BINARY_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7367);
      match(MySQLParser::BINARY_SYMBOL);
      setState(7371);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 962, _ctx)) {
      case 1: {
        setState(7368);
        charset();
        setState(7369);
        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, 928, MySQLParser::RuleAscii);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7381);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::ASCII_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7375);
        match(MySQLParser::ASCII_SYMBOL);
        setState(7377);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 964, _ctx)) {
        case 1: {
          setState(7376);
          match(MySQLParser::BINARY_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::BINARY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7379);
        match(MySQLParser::BINARY_SYMBOL);
        setState(7380);
        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, 930, MySQLParser::RuleUnicode);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7389);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::UNICODE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7383);
        match(MySQLParser::UNICODE_SYMBOL);
        setState(7385);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 966, _ctx)) {
        case 1: {
          setState(7384);
          match(MySQLParser::BINARY_SYMBOL);
          break;
        }

        default:
          break;
        }
        break;
      }

      case MySQLParser::BINARY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7387);
        match(MySQLParser::BINARY_SYMBOL);
        setState(7388);
        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, 932, MySQLParser::RuleWsNumCodepoints);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7391);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7392);
    real_ulong_number();
    setState(7393);
    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, 934, MySQLParser::RuleTypeDatetimePrecision);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7395);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7396);
    match(MySQLParser::INT_NUMBER);
    setState(7397);
    match(MySQLParser::CLOSE_PAR_SYMBOL);
   
  }
  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, 936, MySQLParser::RuleCharsetName);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7400);
      match(MySQLParser::BINARY_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7401);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(7402);
      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, 938, MySQLParser::RuleCollationName);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7406);

      if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
      setState(7407);
      match(MySQLParser::DEFAULT_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7408);

      if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
      setState(7409);
      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, 940, MySQLParser::RuleCreateTableOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7412);
    createTableOption();
    setState(7419);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 971, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7414);
        _errHandler->sync(this);

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

        default:
          break;
        }
        setState(7416);
        createTableOption(); 
      }
      setState(7421);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 971, _ctx);
    }
   
  }
  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, 942, MySQLParser::RuleCreateTableOptionsSpaceSeparated);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7423); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(7422);
              createTableOption();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(7425); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 972, _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::Ulonglong_numberContext* MySQLParser::CreateTableOptionContext::ulonglong_number() {
  return getRuleContext<MySQLParser::Ulonglong_numberContext>(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);
}

MySQLParser::Ulong_numberContext* MySQLParser::CreateTableOptionContext::ulong_number() {
  return getRuleContext<MySQLParser::Ulong_numberContext>(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);
}

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


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, 944, MySQLParser::RuleCreateTableOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7556);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 997, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7427);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ENGINE_SYMBOL);
      setState(7429);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7431);
      engineRef();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7432);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(7433);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::SECONDARY_ENGINE_SYMBOL);
      setState(7435);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 974, _ctx)) {
      case 1: {
        setState(7434);
        equal();
        break;
      }

      default:
        break;
      }
      setState(7439);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 975, _ctx)) {
      case 1: {
        setState(7437);
        match(MySQLParser::NULL_SYMBOL);
        break;
      }

      case 2: {
        setState(7438);
        textOrIdentifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(7441);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::MAX_ROWS_SYMBOL);
      setState(7443);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7442);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7445);
      ulonglong_number();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(7446);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::MIN_ROWS_SYMBOL);
      setState(7448);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7447);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7450);
      ulonglong_number();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(7451);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::AVG_ROW_LENGTH_SYMBOL);
      setState(7453);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7452);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7455);
      ulong_number();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(7456);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::PASSWORD_SYMBOL);
      setState(7458);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7460);
      textStringLiteral();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(7461);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::COMMENT_SYMBOL);
      setState(7463);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7465);
      textStringLiteral();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(7466);

      if (!(serverVersion >= 50708)) throw FailedPredicateException(this, "serverVersion >= 50708");
      setState(7467);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::COMPRESSION_SYMBOL);
      setState(7469);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7471);
      textString();
      break;
    }

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

      if (!(serverVersion >= 50711)) throw FailedPredicateException(this, "serverVersion >= 50711");
      setState(7473);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ENCRYPTION_SYMBOL);
      setState(7475);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7477);
      textString();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(7478);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::AUTO_INCREMENT_SYMBOL);
      setState(7480);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7479);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7482);
      ulonglong_number();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(7483);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::PACK_KEYS_SYMBOL);
      setState(7485);
      _errHandler->sync(this);

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

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(7488);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 544) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 544)) & 7) != 0))) {
        antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(7490);
      _errHandler->sync(this);

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

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(7493);
      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(7495);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7494);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7497);
      ulong_number();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(7498);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::DELAY_KEY_WRITE_SYMBOL);
      setState(7500);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7499);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7502);
      ulong_number();
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(7503);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::ROW_FORMAT_SYMBOL);
      setState(7505);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7504);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7507);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->format = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 78) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 78)) & 1125899906842629) != 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(7508);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::UNION_SYMBOL);
      setState(7510);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7509);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7512);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7513);
      tableRefList();
      setState(7514);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(7516);
      defaultCharset();
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(7517);
      defaultCollation();
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(7518);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::INSERT_METHOD_SYMBOL);
      setState(7520);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7519);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7522);
      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(7523);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::DATA_SYMBOL);
      setState(7524);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(7526);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7528);
      textString();
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(7529);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::INDEX_SYMBOL);
      setState(7530);
      match(MySQLParser::DIRECTORY_SYMBOL);
      setState(7532);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7534);
      textString();
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(7535);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::TABLESPACE_SYMBOL);
      setState(7541);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 994, _ctx)) {
      case 1: {
        setState(7536);

        if (!(serverVersion >= 50707)) throw FailedPredicateException(this, "serverVersion >= 50707");
        setState(7538);
        _errHandler->sync(this);

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

        default:
          break;
        }
        break;
      }

      case 2: {
        break;
      }

      default:
        break;
      }
      setState(7543);
      identifier();
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(7544);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::STORAGE_SYMBOL);
      setState(7545);
      _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(7546);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::CONNECTION_SYMBOL);
      setState(7548);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(7550);
      textString();
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(7551);
      antlrcpp::downCast<CreateTableOptionContext *>(_localctx)->option = match(MySQLParser::KEY_BLOCK_SIZE_SYMBOL);
      setState(7553);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::EQUAL_OPERATOR) {
        setState(7552);
        match(MySQLParser::EQUAL_OPERATOR);
      }
      setState(7555);
      ulong_number();
      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, 946, MySQLParser::RuleTernaryOption);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7560);
    _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(7558);
        ulong_number();
        break;
      }

      case MySQLParser::DEFAULT_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7559);
        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, 948, MySQLParser::RuleDefaultCollation);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(7562);
      match(MySQLParser::DEFAULT_SYMBOL);
    }
    setState(7565);
    match(MySQLParser::COLLATE_SYMBOL);
    setState(7567);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(7569);
    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, 950, MySQLParser::RuleDefaultEncryption);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(7571);
      match(MySQLParser::DEFAULT_SYMBOL);
    }
    setState(7574);
    match(MySQLParser::ENCRYPTION_SYMBOL);
    setState(7576);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(7578);
    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, 952, MySQLParser::RuleDefaultCharset);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::DEFAULT_SYMBOL) {
      setState(7580);
      match(MySQLParser::DEFAULT_SYMBOL);
    }
    setState(7583);
    charset();
    setState(7585);
    _errHandler->sync(this);

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

    default:
      break;
    }
    setState(7587);
    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, 954, MySQLParser::RulePartitionClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7589);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(7590);
    match(MySQLParser::BY_SYMBOL);
    setState(7591);
    partitionTypeDef();
    setState(7594);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1005, _ctx)) {
    case 1: {
      setState(7592);
      match(MySQLParser::PARTITIONS_SYMBOL);
      setState(7593);
      real_ulong_number();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1006, _ctx)) {
    case 1: {
      setState(7596);
      subPartitions();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1007, _ctx)) {
    case 1: {
      setState(7599);
      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, 956, MySQLParser::RulePartitionTypeDef);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7635);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1014, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<MySQLParser::PartitionDefKeyContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(7603);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LINEAR_SYMBOL) {
        setState(7602);
        match(MySQLParser::LINEAR_SYMBOL);
      }
      setState(7605);
      match(MySQLParser::KEY_SYMBOL);
      setState(7607);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1009, _ctx)) {
      case 1: {
        setState(7606);
        partitionKeyAlgorithm();
        break;
      }

      default:
        break;
      }
      setState(7609);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7611);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1010, _ctx)) {
      case 1: {
        setState(7610);
        identifierList();
        break;
      }

      default:
        break;
      }
      setState(7613);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<MySQLParser::PartitionDefHashContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(7615);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::LINEAR_SYMBOL) {
        setState(7614);
        match(MySQLParser::LINEAR_SYMBOL);
      }
      setState(7617);
      match(MySQLParser::HASH_SYMBOL);
      setState(7618);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7619);
      bitExpr(0);
      setState(7620);
      match(MySQLParser::CLOSE_PAR_SYMBOL);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<MySQLParser::PartitionDefRangeListContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(7622);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::LIST_SYMBOL || _la == MySQLParser::RANGE_SYMBOL)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(7633);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::OPEN_PAR_SYMBOL: {
          setState(7623);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(7624);
          bitExpr(0);
          setState(7625);
          match(MySQLParser::CLOSE_PAR_SYMBOL);
          break;
        }

        case MySQLParser::COLUMNS_SYMBOL: {
          setState(7627);
          match(MySQLParser::COLUMNS_SYMBOL);
          setState(7628);
          match(MySQLParser::OPEN_PAR_SYMBOL);
          setState(7630);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1012, _ctx)) {
          case 1: {
            setState(7629);
            identifierList();
            break;
          }

          default:
            break;
          }
          setState(7632);
          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, 958, MySQLParser::RuleSubPartitions);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == MySQLParser::LINEAR_SYMBOL) {
      setState(7639);
      match(MySQLParser::LINEAR_SYMBOL);
    }
    setState(7652);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::HASH_SYMBOL: {
        setState(7642);
        match(MySQLParser::HASH_SYMBOL);
        setState(7643);
        match(MySQLParser::OPEN_PAR_SYMBOL);
        setState(7644);
        bitExpr(0);
        setState(7645);
        match(MySQLParser::CLOSE_PAR_SYMBOL);
        break;
      }

      case MySQLParser::KEY_SYMBOL: {
        setState(7647);
        match(MySQLParser::KEY_SYMBOL);
        setState(7649);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1016, _ctx)) {
        case 1: {
          setState(7648);
          partitionKeyAlgorithm();
          break;
        }

        default:
          break;
        }
        setState(7651);
        identifierListWithParentheses();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(7656);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1018, _ctx)) {
    case 1: {
      setState(7654);
      match(MySQLParser::SUBPARTITIONS_SYMBOL);
      setState(7655);
      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, 960, MySQLParser::RulePartitionKeyAlgorithm);

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

    if (!(serverVersion >= 50700)) throw FailedPredicateException(this, "serverVersion >= 50700");
    setState(7659);
    match(MySQLParser::ALGORITHM_SYMBOL);
    setState(7660);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(7661);
    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, 962, MySQLParser::RulePartitionDefinitions);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7663);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7664);
    partitionDefinition();
    setState(7669);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7665);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7666);
      partitionDefinition();
      setState(7671);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(7672);
    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, 964, MySQLParser::RulePartitionDefinition);
  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::PARTITION_SYMBOL);
    setState(7675);
    identifier();
    setState(7686);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1021, _ctx)) {
    case 1: {
      setState(7676);
      match(MySQLParser::VALUES_SYMBOL);
      setState(7677);
      match(MySQLParser::LESS_SYMBOL);
      setState(7678);
      match(MySQLParser::THAN_SYMBOL);
      setState(7681);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case MySQLParser::OPEN_PAR_SYMBOL: {
          setState(7679);
          partitionValueItemListParen();
          break;
        }

        case MySQLParser::MAXVALUE_SYMBOL: {
          setState(7680);
          match(MySQLParser::MAXVALUE_SYMBOL);
          break;
        }

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

    case 2: {
      setState(7683);
      match(MySQLParser::VALUES_SYMBOL);
      setState(7684);
      match(MySQLParser::IN_SYMBOL);
      setState(7685);
      partitionValuesIn();
      break;
    }

    default:
      break;
    }
    setState(7691);
    _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 - 323) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 323)) & 35184374185985) != 0) || _la == MySQLParser::STORAGE_SYMBOL

    || _la == MySQLParser::TABLESPACE_SYMBOL) {
      setState(7688);
      partitionOption();
      setState(7693);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(7705);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == MySQLParser::OPEN_PAR_SYMBOL) {
      setState(7694);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7695);
      subpartitionDefinition();
      setState(7700);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7696);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7697);
        subpartitionDefinition();
        setState(7702);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(7703);
      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, 966, MySQLParser::RulePartitionValuesIn);
  size_t _la = 0;

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7708);
      match(MySQLParser::OPEN_PAR_SYMBOL);
      setState(7709);
      partitionValueItemListParen();
      setState(7714);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == MySQLParser::COMMA_SYMBOL) {
        setState(7710);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7711);
        partitionValueItemListParen();
        setState(7716);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(7717);
      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, 968, MySQLParser::RulePartitionOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7755);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::TABLESPACE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7721);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::TABLESPACE_SYMBOL);
        setState(7723);
        _errHandler->sync(this);

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

        default:
          break;
        }
        setState(7725);
        identifier();
        break;
      }

      case MySQLParser::ENGINE_SYMBOL:
      case MySQLParser::STORAGE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7727);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::STORAGE_SYMBOL) {
          setState(7726);
          match(MySQLParser::STORAGE_SYMBOL);
        }
        setState(7729);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::ENGINE_SYMBOL);
        setState(7731);
        _errHandler->sync(this);

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

        default:
          break;
        }
        setState(7733);
        engineRef();
        break;
      }

      case MySQLParser::NODEGROUP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(7734);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::NODEGROUP_SYMBOL);
        setState(7736);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::EQUAL_OPERATOR) {
          setState(7735);
          match(MySQLParser::EQUAL_OPERATOR);
        }
        setState(7738);
        real_ulong_number();
        break;
      }

      case MySQLParser::MAX_ROWS_SYMBOL:
      case MySQLParser::MIN_ROWS_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(7739);
        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(7741);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::EQUAL_OPERATOR) {
          setState(7740);
          match(MySQLParser::EQUAL_OPERATOR);
        }
        setState(7743);
        real_ulong_number();
        break;
      }

      case MySQLParser::DATA_SYMBOL:
      case MySQLParser::INDEX_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(7744);
        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(7745);
        match(MySQLParser::DIRECTORY_SYMBOL);
        setState(7747);
        _errHandler->sync(this);

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

        default:
          break;
        }
        setState(7749);
        textLiteral();
        break;
      }

      case MySQLParser::COMMENT_SYMBOL: {
        enterOuterAlt(_localctx, 6);
        setState(7750);
        antlrcpp::downCast<PartitionOptionContext *>(_localctx)->option = match(MySQLParser::COMMENT_SYMBOL);
        setState(7752);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1033, _ctx)) {
        case 1: {
          setState(7751);
          match(MySQLParser::EQUAL_OPERATOR);
          break;
        }

        default:
          break;
        }
        setState(7754);
        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, 970, MySQLParser::RuleSubpartitionDefinition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7757);
    match(MySQLParser::SUBPARTITION_SYMBOL);
    setState(7758);
    textOrIdentifier();
    setState(7762);
    _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 - 323) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 323)) & 35184374185985) != 0) || _la == MySQLParser::STORAGE_SYMBOL

    || _la == MySQLParser::TABLESPACE_SYMBOL) {
      setState(7759);
      partitionOption();
      setState(7764);
      _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, 972, MySQLParser::RulePartitionValueItemListParen);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7765);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7766);
    partitionValueItem();
    setState(7771);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7767);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7768);
      partitionValueItem();
      setState(7773);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(7774);
    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, 974, MySQLParser::RulePartitionValueItem);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7778);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1037, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7776);
      bitExpr(0);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7777);
      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, 976, MySQLParser::RuleDefinerClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7780);
    match(MySQLParser::DEFINER_SYMBOL);
    setState(7781);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(7782);
    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, 978, MySQLParser::RuleIfExists);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7784);
    match(MySQLParser::IF_SYMBOL);
    setState(7785);
    match(MySQLParser::EXISTS_SYMBOL);
   
  }
  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, 980, MySQLParser::RuleIfNotExists);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7787);
    match(MySQLParser::IF_SYMBOL);
    setState(7788);
    notRule();
    setState(7789);
    match(MySQLParser::EXISTS_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, 982, MySQLParser::RuleProcedureParameter);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7792);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1038, _ctx)) {
    case 1: {
      setState(7791);
      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(7794);
    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, 984, MySQLParser::RuleFunctionParameter);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7796);
    parameterName();
    setState(7797);
    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, 986, MySQLParser::RuleCollate);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7799);
    match(MySQLParser::COLLATE_SYMBOL);
    setState(7800);
    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, 988, MySQLParser::RuleTypeWithOptCollate);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7802);
    dataType();
    setState(7804);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1039, _ctx)) {
    case 1: {
      setState(7803);
      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, 990, MySQLParser::RuleSchemaIdentifierPair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7806);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(7807);
    schemaRef();
    setState(7808);
    match(MySQLParser::COMMA_SYMBOL);
    setState(7809);
    schemaRef();
    setState(7810);
    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, 992, MySQLParser::RuleViewRefList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7812);
    viewRef();
    setState(7817);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(7813);
      match(MySQLParser::COMMA_SYMBOL);
      setState(7814);
      viewRef();
      setState(7819);
      _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, 994, MySQLParser::RuleUpdateList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7820);
    updateElement();
    setState(7825);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1041, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7821);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7822);
        updateElement(); 
      }
      setState(7827);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1041, _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, 996, MySQLParser::RuleUpdateElement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7828);
    columnRef();
    setState(7829);
    match(MySQLParser::EQUAL_OPERATOR);
    setState(7832);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1042, _ctx)) {
    case 1: {
      setState(7830);
      expr(0);
      break;
    }

    case 2: {
      setState(7831);
      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, 998, MySQLParser::RuleCharsetClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7834);
    charset();
    setState(7835);
    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, 1000, MySQLParser::RuleFieldsClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7837);
    match(MySQLParser::COLUMNS_SYMBOL);
    setState(7839); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(7838);
              fieldTerm();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(7841); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1043, _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);
}


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, 1002, MySQLParser::RuleFieldTerm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7855);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::TERMINATED_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7843);
        match(MySQLParser::TERMINATED_SYMBOL);
        setState(7844);
        match(MySQLParser::BY_SYMBOL);
        setState(7845);
        textString();
        break;
      }

      case MySQLParser::ENCLOSED_SYMBOL:
      case MySQLParser::OPTIONALLY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7847);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::OPTIONALLY_SYMBOL) {
          setState(7846);
          match(MySQLParser::OPTIONALLY_SYMBOL);
        }
        setState(7849);
        match(MySQLParser::ENCLOSED_SYMBOL);
        setState(7850);
        match(MySQLParser::BY_SYMBOL);
        setState(7851);
        textString();
        break;
      }

      case MySQLParser::ESCAPED_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(7852);
        match(MySQLParser::ESCAPED_SYMBOL);
        setState(7853);
        match(MySQLParser::BY_SYMBOL);
        setState(7854);
        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;
}

//----------------- 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, 1004, MySQLParser::RuleLinesClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7857);
    match(MySQLParser::LINES_SYMBOL);
    setState(7859); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(7858);
              lineTerm();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(7861); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1046, _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, 1006, MySQLParser::RuleLineTerm);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7863);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::STARTING_SYMBOL

    || _la == MySQLParser::TERMINATED_SYMBOL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(7864);
    match(MySQLParser::BY_SYMBOL);
    setState(7865);
    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, 1008, MySQLParser::RuleUserList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7867);
    user();
    setState(7872);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1047, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7868);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7869);
        user(); 
      }
      setState(7874);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1047, _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::CreateUserEntryContext *> MySQLParser::CreateUserListContext::createUserEntry() {
  return getRuleContexts<MySQLParser::CreateUserEntryContext>();
}

MySQLParser::CreateUserEntryContext* MySQLParser::CreateUserListContext::createUserEntry(size_t i) {
  return getRuleContext<MySQLParser::CreateUserEntryContext>(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, 1010, MySQLParser::RuleCreateUserList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7875);
    createUserEntry();
    setState(7880);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1048, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7876);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7877);
        createUserEntry(); 
      }
      setState(7882);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1048, _ctx);
    }
   
  }
  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::AlterUserEntryContext *> MySQLParser::AlterUserListContext::alterUserEntry() {
  return getRuleContexts<MySQLParser::AlterUserEntryContext>();
}

MySQLParser::AlterUserEntryContext* MySQLParser::AlterUserListContext::alterUserEntry(size_t i) {
  return getRuleContext<MySQLParser::AlterUserEntryContext>(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, 1012, MySQLParser::RuleAlterUserList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(7883);
    alterUserEntry();
    setState(7888);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1049, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(7884);
        match(MySQLParser::COMMA_SYMBOL);
        setState(7885);
        alterUserEntry(); 
      }
      setState(7890);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1049, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateUserEntryContext ------------------------------------------------------------------

MySQLParser::CreateUserEntryContext::CreateUserEntryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserContext* MySQLParser::CreateUserEntryContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::CreateUserEntryContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUserEntryContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

MySQLParser::TextStringContext* MySQLParser::CreateUserEntryContext::textString() {
  return getRuleContext<MySQLParser::TextStringContext>(0);
}

tree::TerminalNode* MySQLParser::CreateUserEntryContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::CreateUserEntryContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

tree::TerminalNode* MySQLParser::CreateUserEntryContext::RANDOM_SYMBOL() {
  return getToken(MySQLParser::RANDOM_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUserEntryContext::PASSWORD_SYMBOL() {
  return getToken(MySQLParser::PASSWORD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::CreateUserEntryContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::TextStringHashContext* MySQLParser::CreateUserEntryContext::textStringHash() {
  return getRuleContext<MySQLParser::TextStringHashContext>(0);
}


size_t MySQLParser::CreateUserEntryContext::getRuleIndex() const {
  return MySQLParser::RuleCreateUserEntry;
}

void MySQLParser::CreateUserEntryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterCreateUserEntry(this);
}

void MySQLParser::CreateUserEntryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitCreateUserEntry(this);
}


std::any MySQLParser::CreateUserEntryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitCreateUserEntry(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::CreateUserEntryContext* MySQLParser::createUserEntry() {
  CreateUserEntryContext *_localctx = _tracker.createInstance<CreateUserEntryContext>(_ctx, getState());
  enterRule(_localctx, 1014, MySQLParser::RuleCreateUserEntry);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7891);
    user();
    setState(7918);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1054, _ctx)) {
    case 1: {
      setState(7892);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(7916);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1053, _ctx)) {
      case 1: {
        setState(7893);
        match(MySQLParser::BY_SYMBOL);
        setState(7896);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1050, _ctx)) {
        case 1: {
          setState(7894);

          if (!(serverVersion < 80011)) throw FailedPredicateException(this, "serverVersion < 80011");
          setState(7895);
          match(MySQLParser::PASSWORD_SYMBOL);
          break;
        }

        default:
          break;
        }
        setState(7898);
        textString();
        break;
      }

      case 2: {
        setState(7899);
        match(MySQLParser::WITH_SYMBOL);
        setState(7900);
        textOrIdentifier();
        setState(7906);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1051, _ctx)) {
        case 1: {
          setState(7901);
          match(MySQLParser::AS_SYMBOL);
          setState(7902);
          textStringHash();
          break;
        }

        case 2: {
          setState(7903);

          if (!(serverVersion >= 50706)) throw FailedPredicateException(this, "serverVersion >= 50706");
          setState(7904);
          match(MySQLParser::BY_SYMBOL);
          setState(7905);
          textString();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 3: {
        setState(7908);

        if (!(serverVersion >= 80018)) throw FailedPredicateException(this, "serverVersion >= 80018");
        setState(7911);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WITH_SYMBOL) {
          setState(7909);
          match(MySQLParser::WITH_SYMBOL);
          setState(7910);
          textOrIdentifier();
        }
        setState(7913);
        match(MySQLParser::BY_SYMBOL);
        setState(7914);
        match(MySQLParser::RANDOM_SYMBOL);
        setState(7915);
        match(MySQLParser::PASSWORD_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;
}

//----------------- AlterUserEntryContext ------------------------------------------------------------------

MySQLParser::AlterUserEntryContext::AlterUserEntryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::UserContext* MySQLParser::AlterUserEntryContext::user() {
  return getRuleContext<MySQLParser::UserContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserEntryContext::IDENTIFIED_SYMBOL() {
  return getToken(MySQLParser::IDENTIFIED_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::AlterUserEntryContext::BY_SYMBOL() {
  return getToken(MySQLParser::BY_SYMBOL, 0);
}

std::vector<MySQLParser::TextStringContext *> MySQLParser::AlterUserEntryContext::textString() {
  return getRuleContexts<MySQLParser::TextStringContext>();
}

MySQLParser::TextStringContext* MySQLParser::AlterUserEntryContext::textString(size_t i) {
  return getRuleContext<MySQLParser::TextStringContext>(i);
}

tree::TerminalNode* MySQLParser::AlterUserEntryContext::WITH_SYMBOL() {
  return getToken(MySQLParser::WITH_SYMBOL, 0);
}

MySQLParser::TextOrIdentifierContext* MySQLParser::AlterUserEntryContext::textOrIdentifier() {
  return getRuleContext<MySQLParser::TextOrIdentifierContext>(0);
}

MySQLParser::DiscardOldPasswordContext* MySQLParser::AlterUserEntryContext::discardOldPassword() {
  return getRuleContext<MySQLParser::DiscardOldPasswordContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserEntryContext::REPLACE_SYMBOL() {
  return getToken(MySQLParser::REPLACE_SYMBOL, 0);
}

MySQLParser::RetainCurrentPasswordContext* MySQLParser::AlterUserEntryContext::retainCurrentPassword() {
  return getRuleContext<MySQLParser::RetainCurrentPasswordContext>(0);
}

tree::TerminalNode* MySQLParser::AlterUserEntryContext::AS_SYMBOL() {
  return getToken(MySQLParser::AS_SYMBOL, 0);
}

MySQLParser::TextStringHashContext* MySQLParser::AlterUserEntryContext::textStringHash() {
  return getRuleContext<MySQLParser::TextStringHashContext>(0);
}


size_t MySQLParser::AlterUserEntryContext::getRuleIndex() const {
  return MySQLParser::RuleAlterUserEntry;
}

void MySQLParser::AlterUserEntryContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAlterUserEntry(this);
}

void MySQLParser::AlterUserEntryContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAlterUserEntry(this);
}


std::any MySQLParser::AlterUserEntryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitAlterUserEntry(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::AlterUserEntryContext* MySQLParser::alterUserEntry() {
  AlterUserEntryContext *_localctx = _tracker.createInstance<AlterUserEntryContext>(_ctx, getState());
  enterRule(_localctx, 1016, MySQLParser::RuleAlterUserEntry);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7920);
    user();
    setState(7949);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1062, _ctx)) {
    case 1: {
      setState(7921);
      match(MySQLParser::IDENTIFIED_SYMBOL);
      setState(7944);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1060, _ctx)) {
      case 1: {
        setState(7924);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::WITH_SYMBOL) {
          setState(7922);
          match(MySQLParser::WITH_SYMBOL);
          setState(7923);
          textOrIdentifier();
        }
        setState(7926);
        match(MySQLParser::BY_SYMBOL);
        setState(7927);
        textString();
        setState(7930);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1056, _ctx)) {
        case 1: {
          setState(7928);
          match(MySQLParser::REPLACE_SYMBOL);
          setState(7929);
          textString();
          break;
        }

        default:
          break;
        }
        setState(7933);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1057, _ctx)) {
        case 1: {
          setState(7932);
          retainCurrentPassword();
          break;
        }

        default:
          break;
        }
        break;
      }

      case 2: {
        setState(7935);
        match(MySQLParser::WITH_SYMBOL);
        setState(7936);
        textOrIdentifier();
        setState(7942);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1059, _ctx)) {
        case 1: {
          setState(7937);
          match(MySQLParser::AS_SYMBOL);
          setState(7938);
          textStringHash();
          setState(7940);
          _errHandler->sync(this);

          switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1058, _ctx)) {
          case 1: {
            setState(7939);
            retainCurrentPassword();
            break;
          }

          default:
            break;
          }
          break;
        }

        default:
          break;
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      setState(7947);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1061, _ctx)) {
      case 1: {
        setState(7946);
        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;
}

//----------------- 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, 1018, MySQLParser::RuleRetainCurrentPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7951);
    match(MySQLParser::RETAIN_SYMBOL);
    setState(7952);
    match(MySQLParser::CURRENT_SYMBOL);
    setState(7953);
    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, 1020, MySQLParser::RuleDiscardOldPassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7955);
    match(MySQLParser::DISCARD_SYMBOL);
    setState(7956);
    match(MySQLParser::OLD_SYMBOL);
    setState(7957);
    match(MySQLParser::PASSWORD_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, 1022, MySQLParser::RuleReplacePassword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7959);
    match(MySQLParser::REPLACE_SYMBOL);
    setState(7960);
    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::AT_TEXT_SUFFIX() {
  return getToken(MySQLParser::AT_TEXT_SUFFIX, 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, 1024, MySQLParser::RuleUserIdentifierOrText);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7962);
    textOrIdentifier();
    setState(7966);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1063, _ctx)) {
    case 1: {
      setState(7963);
      match(MySQLParser::AT_SIGN_SYMBOL);
      setState(7964);
      textOrIdentifier();
      break;
    }

    case 2: {
      setState(7965);
      match(MySQLParser::AT_TEXT_SUFFIX);
      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, 1026, MySQLParser::RuleUser);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7973);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1065, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7968);
      userIdentifierOrText();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7969);
      match(MySQLParser::CURRENT_USER_SYMBOL);
      setState(7971);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1064, _ctx)) {
      case 1: {
        setState(7970);
        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, 1028, MySQLParser::RuleLikeClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7975);
    match(MySQLParser::LIKE_SYMBOL);
    setState(7976);
    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, 1030, MySQLParser::RuleLikeOrWhere);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7980);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::LIKE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(7978);
        likeClause();
        break;
      }

      case MySQLParser::WHERE_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(7979);
        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, 1032, MySQLParser::RuleOnlineOption);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7982);
    _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, 1034, MySQLParser::RuleNoWriteToBinLog);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7984);
    _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, 1036, MySQLParser::RuleUsePartition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(7986);

    if (!(serverVersion >= 50602)) throw FailedPredicateException(this, "serverVersion >= 50602");
    setState(7987);
    match(MySQLParser::PARTITION_SYMBOL);
    setState(7988);
    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, 1038, MySQLParser::RuleFieldIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(7995);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1068, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7990);
      dotIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7991);
      qualifiedIdentifier();
      setState(7993);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1067, _ctx)) {
      case 1: {
        setState(7992);
        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, 1040, MySQLParser::RuleColumnName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8001);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1069, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(7997);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(7998);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(7999);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(8000);
      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, 1042, MySQLParser::RuleColumnInternalRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8003);
    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, 1044, MySQLParser::RuleColumnInternalRefList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8005);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8006);
    columnInternalRef();
    setState(8011);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8007);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8008);
      columnInternalRef();
      setState(8013);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8014);
    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, 1046, MySQLParser::RuleColumnRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8016);
    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, 1048, MySQLParser::RuleInsertIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8020);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1071, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8018);
      columnRef();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8019);
      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, 1050, MySQLParser::RuleIndexName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8022);
    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, 1052, MySQLParser::RuleIndexRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8024);
    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, 1054, MySQLParser::RuleTableWild);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8026);
    identifier();
    setState(8027);
    match(MySQLParser::DOT_SYMBOL);
    setState(8031);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1072, _ctx)) {
    case 1: {
      setState(8028);
      identifier();
      setState(8029);
      match(MySQLParser::DOT_SYMBOL);
      break;
    }

    default:
      break;
    }
    setState(8033);
    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, 1056, MySQLParser::RuleSchemaName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8035);
    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, 1058, MySQLParser::RuleSchemaRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8037);
    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, 1060, MySQLParser::RuleProcedureName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8039);
    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, 1062, MySQLParser::RuleProcedureRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8041);
    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, 1064, MySQLParser::RuleFunctionName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8043);
    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, 1066, MySQLParser::RuleFunctionRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8045);
    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, 1068, MySQLParser::RuleTriggerName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8047);
    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, 1070, MySQLParser::RuleTriggerRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8049);
    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, 1072, MySQLParser::RuleViewName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8053);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1073, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8051);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8052);
      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, 1074, MySQLParser::RuleViewRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8057);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1074, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8055);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8056);
      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, 1076, MySQLParser::RuleTablespaceName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8059);
    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, 1078, MySQLParser::RuleTablespaceRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8061);
    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, 1080, MySQLParser::RuleLogfileGroupName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8063);
    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, 1082, MySQLParser::RuleLogfileGroupRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8065);
    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, 1084, MySQLParser::RuleEventName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8067);
    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, 1086, MySQLParser::RuleEventRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8069);
    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, 1088, MySQLParser::RuleUdfName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8071);
    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, 1090, MySQLParser::RuleServerName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8073);
    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, 1092, MySQLParser::RuleServerRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8075);
    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, 1094, MySQLParser::RuleEngineRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8077);
    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, 1096, MySQLParser::RuleTableName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8081);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1075, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8079);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8080);
      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, 1098, MySQLParser::RuleFilterTableRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8083);
    schemaRef();
    setState(8084);
    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, 1100, MySQLParser::RuleTableRefWithWildcard);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8086);
    identifier();
    setState(8094);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1077, _ctx)) {
    case 1: {
      setState(8087);
      match(MySQLParser::DOT_SYMBOL);
      setState(8088);
      match(MySQLParser::MULT_OPERATOR);
      break;
    }

    case 2: {
      setState(8089);
      dotIdentifier();
      setState(8092);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1076, _ctx)) {
      case 1: {
        setState(8090);
        match(MySQLParser::DOT_SYMBOL);
        setState(8091);
        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, 1102, MySQLParser::RuleTableRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8098);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1078, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8096);
      qualifiedIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8097);
      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, 1104, MySQLParser::RuleTableRefList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8100);
    tableRef();
    setState(8105);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1079, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(8101);
        match(MySQLParser::COMMA_SYMBOL);
        setState(8102);
        tableRef(); 
      }
      setState(8107);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1079, _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, 1106, MySQLParser::RuleTableAliasRefList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8108);
    tableRefWithWildcard();
    setState(8113);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1080, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(8109);
        match(MySQLParser::COMMA_SYMBOL);
        setState(8110);
        tableRefWithWildcard(); 
      }
      setState(8115);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1080, _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, 1108, MySQLParser::RuleParameterName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8116);
    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, 1110, MySQLParser::RuleLabelIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8120);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1081, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8118);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8119);
      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, 1112, MySQLParser::RuleLabelRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8122);
    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, 1114, MySQLParser::RuleRoleIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8126);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1082, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8124);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8125);
      roleKeyword();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RoleRefContext ------------------------------------------------------------------

MySQLParser::RoleRefContext::RoleRefContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MySQLParser::RoleIdentifierContext* MySQLParser::RoleRefContext::roleIdentifier() {
  return getRuleContext<MySQLParser::RoleIdentifierContext>(0);
}


size_t MySQLParser::RoleRefContext::getRuleIndex() const {
  return MySQLParser::RuleRoleRef;
}

void MySQLParser::RoleRefContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterRoleRef(this);
}

void MySQLParser::RoleRefContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitRoleRef(this);
}


std::any MySQLParser::RoleRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitRoleRef(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::RoleRefContext* MySQLParser::roleRef() {
  RoleRefContext *_localctx = _tracker.createInstance<RoleRefContext>(_ctx, getState());
  enterRule(_localctx, 1116, MySQLParser::RuleRoleRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8128);
    roleIdentifier();
   
  }
  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, 1118, MySQLParser::RulePluginRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8130);
    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, 1120, MySQLParser::RuleComponentRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8132);
    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, 1122, MySQLParser::RuleResourceGroupRef);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8134);
    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, 1124, MySQLParser::RuleWindowName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8136);
    identifier();
   
  }
  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, 1126, MySQLParser::RulePureIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8141);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1083, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8138);
      _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(8139);

      if (!(isSqlModeActive(AnsiQuotes))) throw FailedPredicateException(this, "isSqlModeActive(AnsiQuotes)");
      setState(8140);
      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, 1128, MySQLParser::RuleIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8145);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1084, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8143);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8144);
      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, 1130, MySQLParser::RuleIdentifierList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8147);
    identifier();
    setState(8152);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1085, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(8148);
        match(MySQLParser::COMMA_SYMBOL);
        setState(8149);
        identifier(); 
      }
      setState(8154);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1085, _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, 1132, MySQLParser::RuleIdentifierListWithParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8155);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8156);
    identifierList();
    setState(8157);
    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, 1134, MySQLParser::RuleQualifiedIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8159);
    identifier();
    setState(8161);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1086, _ctx)) {
    case 1: {
      setState(8160);
      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, 1136, MySQLParser::RuleSimpleIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8174);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1089, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8163);
      identifier();
      setState(8168);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::DOT_SYMBOL) {
        setState(8164);
        dotIdentifier();
        setState(8166);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == MySQLParser::DOT_SYMBOL) {
          setState(8165);
          dotIdentifier();
        }
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8170);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(8171);
      dotIdentifier();
      setState(8172);
      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, 1138, MySQLParser::RuleDotIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8176);
    match(MySQLParser::DOT_SYMBOL);
    setState(8177);
    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, 1140, 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(8179);
    _la = _input->LA(1);
    if (!(((((_la - 747) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 747)) & 28587302322183) != 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, 1142, 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(8181);
    _la = _input->LA(1);
    if (!(((((_la - 747) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 747)) & 2199023255559) != 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;
}

//----------------- Ulonglong_numberContext ------------------------------------------------------------------

MySQLParser::Ulonglong_numberContext::Ulonglong_numberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::Ulonglong_numberContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulonglong_numberContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulonglong_numberContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulonglong_numberContext::DECIMAL_NUMBER() {
  return getToken(MySQLParser::DECIMAL_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::Ulonglong_numberContext::FLOAT_NUMBER() {
  return getToken(MySQLParser::FLOAT_NUMBER, 0);
}


size_t MySQLParser::Ulonglong_numberContext::getRuleIndex() const {
  return MySQLParser::RuleUlonglong_number;
}

void MySQLParser::Ulonglong_numberContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterUlonglong_number(this);
}

void MySQLParser::Ulonglong_numberContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitUlonglong_number(this);
}


std::any MySQLParser::Ulonglong_numberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitUlonglong_number(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::Ulonglong_numberContext* MySQLParser::ulonglong_number() {
  Ulonglong_numberContext *_localctx = _tracker.createInstance<Ulonglong_numberContext>(_ctx, getState());
  enterRule(_localctx, 1144, MySQLParser::RuleUlonglong_number);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8183);
    _la = _input->LA(1);
    if (!(((((_la - 747) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 747)) & 26388279066631) != 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, 1146, MySQLParser::RuleReal_ulonglong_number);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8190);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1090, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8185);
      match(MySQLParser::INT_NUMBER);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8186);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(8187);
      match(MySQLParser::HEX_NUMBER);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8188);
      match(MySQLParser::ULONGLONG_NUMBER);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8189);
      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;
}

//----------------- 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, 1148, MySQLParser::RuleLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8201);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1092, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8192);
      textLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8193);
      numLiteral();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8194);
      temporalLiteral();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8195);
      nullLiteral();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(8196);
      boolLiteral();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(8198);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == MySQLParser::UNDERSCORE_CHARSET) {
        setState(8197);
        match(MySQLParser::UNDERSCORE_CHARSET);
      }
      setState(8200);
      _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;
}

//----------------- 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, 1150, MySQLParser::RuleSignedLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8208);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1093, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8203);
      literal();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8204);
      match(MySQLParser::PLUS_OPERATOR);
      setState(8205);
      ulong_number();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8206);
      match(MySQLParser::MINUS_OPERATOR);
      setState(8207);
      ulong_number();
      break;
    }

    default:
      break;
    }
   
  }
  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, 1152, MySQLParser::RuleStringList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8210);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8211);
    textString();
    setState(8216);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8212);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8213);
      textString();
      setState(8218);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(8219);
    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, 1154, MySQLParser::RuleTextStringLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8224);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1095, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8221);
      antlrcpp::downCast<TextStringLiteralContext *>(_localctx)->value = match(MySQLParser::SINGLE_QUOTED_TEXT);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8222);

      if (!(!isSqlModeActive(AnsiQuotes))) throw FailedPredicateException(this, "!isSqlModeActive(AnsiQuotes)");
      setState(8223);
      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, 1156, MySQLParser::RuleTextString);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8229);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1096, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8226);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8227);
      match(MySQLParser::HEX_NUMBER);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8228);
      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, 1158, MySQLParser::RuleTextStringHash);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8234);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1097, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8231);
      textStringLiteral();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8232);

      if (!(serverVersion >= 80017)) throw FailedPredicateException(this, "serverVersion >= 80017");
      setState(8233);
      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, 1160, MySQLParser::RuleTextLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(8241);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1099, _ctx)) {
    case 1: {
      setState(8237);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1098, _ctx)) {
      case 1: {
        setState(8236);
        match(MySQLParser::UNDERSCORE_CHARSET);
        break;
      }

      default:
        break;
      }
      setState(8239);
      textStringLiteral();
      break;
    }

    case 2: {
      setState(8240);
      match(MySQLParser::NCHAR_TEXT);
      break;
    }

    default:
      break;
    }
    setState(8246);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1100, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(8243);
        textStringLiteral(); 
      }
      setState(8248);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1100, _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, 1162, MySQLParser::RuleTextStringNoLinebreak);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8249);
    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, 1164, MySQLParser::RuleTextStringLiteralList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8251);
    textStringLiteral();
    setState(8256);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MySQLParser::COMMA_SYMBOL) {
      setState(8252);
      match(MySQLParser::COMMA_SYMBOL);
      setState(8253);
      textStringLiteral();
      setState(8258);
      _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;
}

//----------------- NumLiteralContext ------------------------------------------------------------------

MySQLParser::NumLiteralContext::NumLiteralContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::NumLiteralContext::INT_NUMBER() {
  return getToken(MySQLParser::INT_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::NumLiteralContext::LONG_NUMBER() {
  return getToken(MySQLParser::LONG_NUMBER, 0);
}

tree::TerminalNode* MySQLParser::NumLiteralContext::ULONGLONG_NUMBER() {
  return getToken(MySQLParser::ULONGLONG_NUMBER, 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, 1166, MySQLParser::RuleNumLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8259);
    _la = _input->LA(1);
    if (!(((((_la - 747) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 747)) & 26388279066631) != 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;
}

//----------------- 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, 1168, MySQLParser::RuleBoolLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8261);
    _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, 1170, MySQLParser::RuleNullLiteral);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8263);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::NULL_SYMBOL || _la == MySQLParser::NULL2_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;
}

//----------------- 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, 1172, MySQLParser::RuleTemporalLiteral);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8271);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::DATE_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8265);
        match(MySQLParser::DATE_SYMBOL);
        setState(8266);
        match(MySQLParser::SINGLE_QUOTED_TEXT);
        break;
      }

      case MySQLParser::TIME_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8267);
        match(MySQLParser::TIME_SYMBOL);
        setState(8268);
        match(MySQLParser::SINGLE_QUOTED_TEXT);
        break;
      }

      case MySQLParser::TIMESTAMP_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(8269);
        match(MySQLParser::TIMESTAMP_SYMBOL);
        setState(8270);
        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, 1174, MySQLParser::RuleFloatOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8275);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1103, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8273);
      fieldLength();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8274);
      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, 1176, MySQLParser::RuleStandardFloatOptions);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8277);
    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, 1178, MySQLParser::RulePrecision);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8279);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8280);
    match(MySQLParser::INT_NUMBER);
    setState(8281);
    match(MySQLParser::COMMA_SYMBOL);
    setState(8282);
    match(MySQLParser::INT_NUMBER);
    setState(8283);
    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, 1180, MySQLParser::RuleTextOrIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8287);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1104, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8285);
      identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8286);
      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, 1182, MySQLParser::RuleLValueIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8291);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1105, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8289);
      pureIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8290);
      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, 1184, MySQLParser::RuleRoleIdentifierOrText);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8295);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1106, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8293);
      roleIdentifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8294);
      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, 1186, MySQLParser::RuleSizeNumber);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8299);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1107, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8297);
      real_ulonglong_number();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8298);
      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, 1188, MySQLParser::RuleParentheses);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8301);
    match(MySQLParser::OPEN_PAR_SYMBOL);
    setState(8302);
    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, 1190, MySQLParser::RuleEqual);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8304);
    _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, 1192, MySQLParser::RuleOptionType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8306);
    _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;
}

//----------------- VarIdentTypeContext ------------------------------------------------------------------

MySQLParser::VarIdentTypeContext::VarIdentTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MySQLParser::VarIdentTypeContext::GLOBAL_SYMBOL() {
  return getToken(MySQLParser::GLOBAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::VarIdentTypeContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::VarIdentTypeContext::LOCAL_SYMBOL() {
  return getToken(MySQLParser::LOCAL_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::VarIdentTypeContext::SESSION_SYMBOL() {
  return getToken(MySQLParser::SESSION_SYMBOL, 0);
}


size_t MySQLParser::VarIdentTypeContext::getRuleIndex() const {
  return MySQLParser::RuleVarIdentType;
}

void MySQLParser::VarIdentTypeContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterVarIdentType(this);
}

void MySQLParser::VarIdentTypeContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<MySQLParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitVarIdentType(this);
}


std::any MySQLParser::VarIdentTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MySQLParserVisitor*>(visitor))
    return parserVisitor->visitVarIdentType(this);
  else
    return visitor->visitChildren(this);
}

MySQLParser::VarIdentTypeContext* MySQLParser::varIdentType() {
  VarIdentTypeContext *_localctx = _tracker.createInstance<VarIdentTypeContext>(_ctx, getState());
  enterRule(_localctx, 1194, MySQLParser::RuleVarIdentType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8314);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::GLOBAL_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8308);
        match(MySQLParser::GLOBAL_SYMBOL);
        setState(8309);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::LOCAL_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8310);
        match(MySQLParser::LOCAL_SYMBOL);
        setState(8311);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::SESSION_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(8312);
        match(MySQLParser::SESSION_SYMBOL);
        setState(8313);
        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::PERSIST_SYMBOL() {
  return getToken(MySQLParser::PERSIST_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::SetVarIdentTypeContext::DOT_SYMBOL() {
  return getToken(MySQLParser::DOT_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, 1196, MySQLParser::RuleSetVarIdentType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8326);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MySQLParser::PERSIST_SYMBOL: {
        enterOuterAlt(_localctx, 1);
        setState(8316);
        match(MySQLParser::PERSIST_SYMBOL);
        setState(8317);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::PERSIST_ONLY_SYMBOL: {
        enterOuterAlt(_localctx, 2);
        setState(8318);
        match(MySQLParser::PERSIST_ONLY_SYMBOL);
        setState(8319);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::GLOBAL_SYMBOL: {
        enterOuterAlt(_localctx, 3);
        setState(8320);
        match(MySQLParser::GLOBAL_SYMBOL);
        setState(8321);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::LOCAL_SYMBOL: {
        enterOuterAlt(_localctx, 4);
        setState(8322);
        match(MySQLParser::LOCAL_SYMBOL);
        setState(8323);
        match(MySQLParser::DOT_SYMBOL);
        break;
      }

      case MySQLParser::SESSION_SYMBOL: {
        enterOuterAlt(_localctx, 5);
        setState(8324);
        match(MySQLParser::SESSION_SYMBOL);
        setState(8325);
        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;
}

//----------------- 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, 1198, MySQLParser::RuleIdentifierKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8345);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1112, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8328);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(8336);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1110, _ctx)) {
      case 1: {
        setState(8329);
        labelKeyword();
        break;
      }

      case 2: {
        setState(8330);
        roleOrIdentifierKeyword();
        break;
      }

      case 3: {
        setState(8331);
        match(MySQLParser::EXECUTE_SYMBOL);
        break;
      }

      case 4: {
        setState(8332);

        if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
        setState(8333);
        match(MySQLParser::SHUTDOWN_SYMBOL);
        break;
      }

      case 5: {
        setState(8334);

        if (!(serverVersion >= 80011)) throw FailedPredicateException(this, "serverVersion >= 80011");
        setState(8335);
        match(MySQLParser::RESTART_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8343);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1111, _ctx)) {
      case 1: {
        setState(8338);
        identifierKeywordsUnambiguous();
        break;
      }

      case 2: {
        setState(8339);
        identifierKeywordsAmbiguous1RolesAndLabels();
        break;
      }

      case 3: {
        setState(8340);
        identifierKeywordsAmbiguous2Labels();
        break;
      }

      case 4: {
        setState(8341);
        identifierKeywordsAmbiguous3Roles();
        break;
      }

      case 5: {
        setState(8342);
        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, 1200, MySQLParser::RuleIdentifierKeywordsAmbiguous1RolesAndLabels);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8347);
    _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);
}


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, 1202, MySQLParser::RuleIdentifierKeywordsAmbiguous2Labels);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8349);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 2594284492135333888) != 0) || ((((_la - 75) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 75)) & 281474976743429) != 0) || ((((_la - 147) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 147)) & 1688849860268033) != 0) || ((((_la - 219) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 219)) & 281475043852297) != 0) || ((((_la - 373) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 373)) & 21990232555521) != 0) || ((((_la - 455) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 455)) & 720575957592711169) != 0) || ((((_la - 543) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 543)) & -9205357638345293311) != 0) || _la == MySQLParser::UNINSTALL_SYMBOL

    || _la == MySQLParser::XA_SYMBOL || _la == MySQLParser::CLONE_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;
}

//----------------- 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, 1204, MySQLParser::RuleLabelKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8369);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1115, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8351);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(8362);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1113, _ctx)) {
      case 1: {
        setState(8352);
        roleOrLabelKeyword();
        break;
      }

      case 2: {
        setState(8353);
        match(MySQLParser::EVENT_SYMBOL);
        break;
      }

      case 3: {
        setState(8354);
        match(MySQLParser::FILE_SYMBOL);
        break;
      }

      case 4: {
        setState(8355);
        match(MySQLParser::NONE_SYMBOL);
        break;
      }

      case 5: {
        setState(8356);
        match(MySQLParser::PROCESS_SYMBOL);
        break;
      }

      case 6: {
        setState(8357);
        match(MySQLParser::PROXY_SYMBOL);
        break;
      }

      case 7: {
        setState(8358);
        match(MySQLParser::RELOAD_SYMBOL);
        break;
      }

      case 8: {
        setState(8359);
        match(MySQLParser::REPLICATION_SYMBOL);
        break;
      }

      case 9: {
        setState(8360);
        match(MySQLParser::RESOURCE_SYMBOL);
        break;
      }

      case 10: {
        setState(8361);
        match(MySQLParser::SUPER_SYMBOL);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8367);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1114, _ctx)) {
      case 1: {
        setState(8364);
        identifierKeywordsUnambiguous();
        break;
      }

      case 2: {
        setState(8365);
        identifierKeywordsAmbiguous3Roles();
        break;
      }

      case 3: {
        setState(8366);
        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, 1206, MySQLParser::RuleIdentifierKeywordsAmbiguous3Roles);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8371);
    _la = _input->LA(1);
    if (!(_la == MySQLParser::EVENT_SYMBOL

    || _la == MySQLParser::FILE_SYMBOL || ((((_la - 369) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 369)) & 306244774661193729) != 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::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::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::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::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::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::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::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::KEY_BLOCK_SIZE_SYMBOL() {
  return getToken(MySQLParser::KEY_BLOCK_SIZE_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::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::REORGANIZE_SYMBOL() {
  return getToken(MySQLParser::REORGANIZE_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::REPEATABLE_SYMBOL() {
  return getToken(MySQLParser::REPEATABLE_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::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::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_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_SYMBOL() {
  return getToken(MySQLParser::SOURCE_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::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::TIMESTAMP_ADD_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::IdentifierKeywordsUnambiguousContext::TIMESTAMP_DIFF_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_DIFF_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::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::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::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);
}


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, 1208, MySQLParser::RuleIdentifierKeywordsUnambiguous);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8376);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1116, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8373);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -8979026322011384852) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & 293728076221109983) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 129)) & -1036516489208775157) != 0) || ((((_la - 201) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 201)) & -6430563964047286645) != 0) || ((((_la - 268) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 268)) & 1868853107068508261) != 0) || ((((_la - 333) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 333)) & 173760286417661087) != 0) || ((((_la - 398) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 398)) & -4228991016542077057) != 0) || ((((_la - 462) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 462)) & 2209089036834331935) != 0) || ((((_la - 528) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 528)) & 556082145862309015) != 0) || ((((_la - 592) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 592)) & 3874169395838459587) != 0) || ((((_la - 656) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 656)) & -315315032541044359) != 0) || ((((_la - 720) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 720)) & 497599) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8374);

      if (!(serverVersion >= 80019)) throw FailedPredicateException(this, "serverVersion >= 80019");
      setState(8375);
      _la = _input->LA(1);
      if (!(_la == MySQLParser::TIMESTAMP_SYMBOL

      || _la == MySQLParser::TIME_SYMBOL || ((((_la - 731) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 731)) & 16381) != 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;
}

//----------------- 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, 1210, MySQLParser::RuleRoleKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8388);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1119, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8378);

      if (!(serverVersion < 80017)) throw FailedPredicateException(this, "serverVersion < 80017");
      setState(8381);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1117, _ctx)) {
      case 1: {
        setState(8379);
        roleOrLabelKeyword();
        break;
      }

      case 2: {
        setState(8380);
        roleOrIdentifierKeyword();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8386);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1118, _ctx)) {
      case 1: {
        setState(8383);
        identifierKeywordsUnambiguous();
        break;
      }

      case 2: {
        setState(8384);
        identifierKeywordsAmbiguous2Labels();
        break;
      }

      case 3: {
        setState(8385);
        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, 1212, MySQLParser::RuleLValueKeyword);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8394);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1120, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8390);
      identifierKeywordsUnambiguous();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8391);
      identifierKeywordsAmbiguous1RolesAndLabels();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8392);
      identifierKeywordsAmbiguous2Labels();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(8393);
      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, 1214, MySQLParser::RuleIdentifierKeywordsAmbiguous4SystemVariables);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(8396);
    _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, 1216, MySQLParser::RuleRoleOrIdentifierKeyword);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8403);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1121, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8398);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 2594284492269555716) != 0) || ((((_la - 66) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 66)) & 144115188092635649) != 0) || ((((_la - 147) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 147)) & -9203668788485025791) != 0) || ((((_la - 219) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 219)) & 281475043819561) != 0) || ((((_la - 373) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 373)) & 23094341287937) != 0) || ((((_la - 452) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 452)) & 5766877052741681161) != 0) || ((((_la - 519) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 519)) & 8606711811) != 0) || ((((_la - 597) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 597)) & 4631952216750818817) != 0) || ((((_la - 661) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 661)) & 8646911284551417859) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8399);

      if (!(serverVersion >= 50709)) throw FailedPredicateException(this, "serverVersion >= 50709");
      setState(8400);
      match(MySQLParser::SHUTDOWN_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8401);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(8402);
      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::AUTHORS_SYMBOL() {
  return getToken(MySQLParser::AUTHORS_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::CONTRIBUTORS_SYMBOL() {
  return getToken(MySQLParser::CONTRIBUTORS_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::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_SERVER_ID_SYMBOL() {
  return getToken(MySQLParser::MASTER_SERVER_ID_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::TIMESTAMP_ADD_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_ADD_SYMBOL, 0);
}

tree::TerminalNode* MySQLParser::RoleOrLabelKeywordContext::TIMESTAMP_DIFF_SYMBOL() {
  return getToken(MySQLParser::TIMESTAMP_DIFF_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);
}


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, 1218, MySQLParser::RuleRoleOrLabelKeyword);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(8414);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 1122, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(8405);
      _la = _input->LA(1);
      if (!((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -8979026322141404184) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & 293728076757980891) != 0) || ((((_la - 129) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 129)) & -1036806760278507893) != 0) || ((((_la - 202) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 202)) & 6008090054826942021) != 0) || ((((_la - 268) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 268)) & 2012968295144429669) != 0) || ((((_la - 333) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 333)) & 3186450531003551) != 0) || ((((_la - 399) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 399)) & -2123500508502540357) != 0) || ((((_la - 463) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 463)) & 888371177957633551) != 0) || ((((_la - 528) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 528)) & 556082283301262519) != 0) || ((((_la - 592) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 592)) & 3784097394692726723) != 0) || ((((_la - 656) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 656)) & -5647576991346663167) != 0) || ((((_la - 724) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 724)) & 27) != 0))) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(8406);

      if (!(serverVersion < 50709)) throw FailedPredicateException(this, "serverVersion < 50709");
      setState(8407);
      match(MySQLParser::SHUTDOWN_SYMBOL);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(8408);

      if (!(serverVersion < 80000)) throw FailedPredicateException(this, "serverVersion < 80000");
      setState(8409);
      _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(8410);

      if (!(serverVersion >= 80000)) throw FailedPredicateException(this, "serverVersion >= 80000");
      setState(8411);
      _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(8412);

      if (!(serverVersion >= 80014)) throw FailedPredicateException(this, "serverVersion >= 80014");
      setState(8413);
      match(MySQLParser::ADMIN_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 9: return alterTableSempred(antlrcpp::downCast<AlterTableContext *>(context), predicateIndex);
    case 13: return standaloneAlterCommandsSempred(antlrcpp::downCast<StandaloneAlterCommandsContext *>(context), predicateIndex);
    case 14: return alterPartitionSempred(antlrcpp::downCast<AlterPartitionContext *>(context), predicateIndex);
    case 17: return alterListItemSempred(antlrcpp::downCast<AlterListItemContext *>(context), predicateIndex);
    case 24: return withValidationSempred(antlrcpp::downCast<WithValidationContext *>(context), predicateIndex);
    case 27: return alterTablespaceSempred(antlrcpp::downCast<AlterTablespaceContext *>(context), predicateIndex);
    case 38: return createStatementSempred(antlrcpp::downCast<CreateStatementContext *>(context), predicateIndex);
    case 40: return createDatabaseOptionSempred(antlrcpp::downCast<CreateDatabaseOptionContext *>(context), predicateIndex);
    case 53: return createIndexSempred(antlrcpp::downCast<CreateIndexContext *>(context), predicateIndex);
    case 64: return tsDataFileNameSempred(antlrcpp::downCast<TsDataFileNameContext *>(context), predicateIndex);
    case 67: return tablespaceOptionSempred(antlrcpp::downCast<TablespaceOptionContext *>(context), predicateIndex);
    case 84: return triggerFollowsPrecedesClauseSempred(antlrcpp::downCast<TriggerFollowsPrecedesClauseContext *>(context), predicateIndex);
    case 89: return dropStatementSempred(antlrcpp::downCast<DropStatementContext *>(context), predicateIndex);
    case 110: return deleteStatementSempred(antlrcpp::downCast<DeleteStatementContext *>(context), predicateIndex);
    case 111: return partitionDeleteSempred(antlrcpp::downCast<PartitionDeleteContext *>(context), predicateIndex);
    case 113: return doStatementSempred(antlrcpp::downCast<DoStatementContext *>(context), predicateIndex);
    case 116: return insertStatementSempred(antlrcpp::downCast<InsertStatementContext *>(context), predicateIndex);
    case 135: return queryExpressionSempred(antlrcpp::downCast<QueryExpressionContext *>(context), predicateIndex);
    case 138: return queryPrimarySempred(antlrcpp::downCast<QueryPrimaryContext *>(context), predicateIndex);
    case 139: return querySpecificationSempred(antlrcpp::downCast<QuerySpecificationContext *>(context), predicateIndex);
    case 163: return olapOptionSempred(antlrcpp::downCast<OlapOptionContext *>(context), predicateIndex);
    case 171: return selectOptionSempred(antlrcpp::downCast<SelectOptionContext *>(context), predicateIndex);
    case 173: return lockingClauseSempred(antlrcpp::downCast<LockingClauseContext *>(context), predicateIndex);
    case 174: return lockStrenghSempred(antlrcpp::downCast<LockStrenghContext *>(context), predicateIndex);
    case 180: return tableReferenceSempred(antlrcpp::downCast<TableReferenceContext *>(context), predicateIndex);
    case 186: return tableFactorSempred(antlrcpp::downCast<TableFactorContext *>(context), predicateIndex);
    case 189: return derivedTableSempred(antlrcpp::downCast<DerivedTableContext *>(context), predicateIndex);
    case 193: return jtColumnSempred(antlrcpp::downCast<JtColumnContext *>(context), predicateIndex);
    case 199: return tableAliasSempred(antlrcpp::downCast<TableAliasContext *>(context), predicateIndex);
    case 208: return updateStatementSempred(antlrcpp::downCast<UpdateStatementContext *>(context), predicateIndex);
    case 212: return transactionCharacteristicSempred(antlrcpp::downCast<TransactionCharacteristicContext *>(context), predicateIndex);
    case 214: return lockStatementSempred(antlrcpp::downCast<LockStatementContext *>(context), predicateIndex);
    case 218: return xaConvertSempred(antlrcpp::downCast<XaConvertContext *>(context), predicateIndex);
    case 220: return replicationStatementSempred(antlrcpp::downCast<ReplicationStatementContext *>(context), predicateIndex);
    case 221: return resetOptionSempred(antlrcpp::downCast<ResetOptionContext *>(context), predicateIndex);
    case 222: return masterResetOptionsSempred(antlrcpp::downCast<MasterResetOptionsContext *>(context), predicateIndex);
    case 232: return changeReplicationSempred(antlrcpp::downCast<ChangeReplicationContext *>(context), predicateIndex);
    case 240: return slaveUntilOptionsSempred(antlrcpp::downCast<SlaveUntilOptionsContext *>(context), predicateIndex);
    case 241: return slaveConnectionOptionsSempred(antlrcpp::downCast<SlaveConnectionOptionsContext *>(context), predicateIndex);
    case 248: return cloneStatementSempred(antlrcpp::downCast<CloneStatementContext *>(context), predicateIndex);
    case 251: return accountManagementStatementSempred(antlrcpp::downCast<AccountManagementStatementContext *>(context), predicateIndex);
    case 252: return alterUserSempred(antlrcpp::downCast<AlterUserContext *>(context), predicateIndex);
    case 253: return alterUserTailSempred(antlrcpp::downCast<AlterUserTailContext *>(context), predicateIndex);
    case 255: return createUserSempred(antlrcpp::downCast<CreateUserContext *>(context), predicateIndex);
    case 256: return createUserTailSempred(antlrcpp::downCast<CreateUserTailContext *>(context), predicateIndex);
    case 257: return defaultRoleClauseSempred(antlrcpp::downCast<DefaultRoleClauseContext *>(context), predicateIndex);
    case 260: return accountLockPasswordExpireOptionsSempred(antlrcpp::downCast<AccountLockPasswordExpireOptionsContext *>(context), predicateIndex);
    case 261: return dropUserSempred(antlrcpp::downCast<DropUserContext *>(context), predicateIndex);
    case 262: return grantSempred(antlrcpp::downCast<GrantContext *>(context), predicateIndex);
    case 263: return grantTargetListSempred(antlrcpp::downCast<GrantTargetListContext *>(context), predicateIndex);
    case 264: return grantOptionsSempred(antlrcpp::downCast<GrantOptionsContext *>(context), predicateIndex);
    case 268: return versionedRequireClauseSempred(antlrcpp::downCast<VersionedRequireClauseContext *>(context), predicateIndex);
    case 270: return revokeSempred(antlrcpp::downCast<RevokeContext *>(context), predicateIndex);
    case 271: return onTypeToSempred(antlrcpp::downCast<OnTypeToContext *>(context), predicateIndex);
    case 274: return roleOrPrivilegeSempred(antlrcpp::downCast<RoleOrPrivilegeContext *>(context), predicateIndex);
    case 275: return grantIdentifierSempred(antlrcpp::downCast<GrantIdentifierContext *>(context), predicateIndex);
    case 282: return tableAdministrationStatementSempred(antlrcpp::downCast<TableAdministrationStatementContext *>(context), predicateIndex);
    case 288: return startOptionValueListSempred(antlrcpp::downCast<StartOptionValueListContext *>(context), predicateIndex);
    case 293: return optionValueNoOptionTypeSempred(antlrcpp::downCast<OptionValueNoOptionTypeContext *>(context), predicateIndex);
    case 298: return setExprOrDefaultSempred(antlrcpp::downCast<SetExprOrDefaultContext *>(context), predicateIndex);
    case 299: return showStatementSempred(antlrcpp::downCast<ShowStatementContext *>(context), predicateIndex);
    case 300: return showCommandTypeSempred(antlrcpp::downCast<ShowCommandTypeContext *>(context), predicateIndex);
    case 301: return nonBlockingSempred(antlrcpp::downCast<NonBlockingContext *>(context), predicateIndex);
    case 305: return otherAdministrativeStatementSempred(antlrcpp::downCast<OtherAdministrativeStatementContext *>(context), predicateIndex);
    case 313: return flushOptionSempred(antlrcpp::downCast<FlushOptionContext *>(context), predicateIndex);
    case 316: return flushTablesOptionsSempred(antlrcpp::downCast<FlushTablesOptionsContext *>(context), predicateIndex);
    case 331: return utilityStatementSempred(antlrcpp::downCast<UtilityStatementContext *>(context), predicateIndex);
    case 333: return explainStatementSempred(antlrcpp::downCast<ExplainStatementContext *>(context), predicateIndex);
    case 334: return explainableStatementSempred(antlrcpp::downCast<ExplainableStatementContext *>(context), predicateIndex);
    case 338: return exprSempred(antlrcpp::downCast<ExprContext *>(context), predicateIndex);
    case 339: return boolPriSempred(antlrcpp::downCast<BoolPriContext *>(context), predicateIndex);
    case 341: return predicateSempred(antlrcpp::downCast<PredicateContext *>(context), predicateIndex);
    case 343: return bitExprSempred(antlrcpp::downCast<BitExprContext *>(context), predicateIndex);
    case 344: return simpleExprSempred(antlrcpp::downCast<SimpleExprContext *>(context), predicateIndex);
    case 345: return arrayCastSempred(antlrcpp::downCast<ArrayCastContext *>(context), predicateIndex);
    case 346: return jsonOperatorSempred(antlrcpp::downCast<JsonOperatorContext *>(context), predicateIndex);
    case 347: return sumExprSempred(antlrcpp::downCast<SumExprContext *>(context), predicateIndex);
    case 358: return runtimeFunctionCallSempred(antlrcpp::downCast<RuntimeFunctionCallContext *>(context), predicateIndex);
    case 359: return geometryFunctionSempred(antlrcpp::downCast<GeometryFunctionContext *>(context), predicateIndex);
    case 361: return fractionalPrecisionSempred(antlrcpp::downCast<FractionalPrecisionContext *>(context), predicateIndex);
    case 373: return internalVariableNameSempred(antlrcpp::downCast<InternalVariableNameContext *>(context), predicateIndex);
    case 377: return castTypeSempred(antlrcpp::downCast<CastTypeContext *>(context), predicateIndex);
    case 391: return channelSempred(antlrcpp::downCast<ChannelContext *>(context), predicateIndex);
    case 420: return getDiagnosticsSempred(antlrcpp::downCast<GetDiagnosticsContext *>(context), predicateIndex);
    case 433: return checkOrReferencesSempred(antlrcpp::downCast<CheckOrReferencesContext *>(context), predicateIndex);
    case 436: return tableConstraintDefSempred(antlrcpp::downCast<TableConstraintDefContext *>(context), predicateIndex);
    case 438: return fieldDefinitionSempred(antlrcpp::downCast<FieldDefinitionContext *>(context), predicateIndex);
    case 439: return columnAttributeSempred(antlrcpp::downCast<ColumnAttributeContext *>(context), predicateIndex);
    case 449: return keyListVariantsSempred(antlrcpp::downCast<KeyListVariantsContext *>(context), predicateIndex);
    case 452: return commonIndexOptionSempred(antlrcpp::downCast<CommonIndexOptionContext *>(context), predicateIndex);
    case 458: return dataTypeSempred(antlrcpp::downCast<DataTypeContext *>(context), predicateIndex);
    case 468: return charsetNameSempred(antlrcpp::downCast<CharsetNameContext *>(context), predicateIndex);
    case 469: return collationNameSempred(antlrcpp::downCast<CollationNameContext *>(context), predicateIndex);
    case 472: return createTableOptionSempred(antlrcpp::downCast<CreateTableOptionContext *>(context), predicateIndex);
    case 480: return partitionKeyAlgorithmSempred(antlrcpp::downCast<PartitionKeyAlgorithmContext *>(context), predicateIndex);
    case 507: return createUserEntrySempred(antlrcpp::downCast<CreateUserEntryContext *>(context), predicateIndex);
    case 518: return usePartitionSempred(antlrcpp::downCast<UsePartitionContext *>(context), predicateIndex);
    case 520: return columnNameSempred(antlrcpp::downCast<ColumnNameContext *>(context), predicateIndex);
    case 563: return pureIdentifierSempred(antlrcpp::downCast<PureIdentifierContext *>(context), predicateIndex);
    case 568: return simpleIdentifierSempred(antlrcpp::downCast<SimpleIdentifierContext *>(context), predicateIndex);
    case 573: return real_ulonglong_numberSempred(antlrcpp::downCast<Real_ulonglong_numberContext *>(context), predicateIndex);
    case 577: return textStringLiteralSempred(antlrcpp::downCast<TextStringLiteralContext *>(context), predicateIndex);
    case 579: return textStringHashSempred(antlrcpp::downCast<TextStringHashContext *>(context), predicateIndex);
    case 599: return identifierKeywordSempred(antlrcpp::downCast<IdentifierKeywordContext *>(context), predicateIndex);
    case 602: return labelKeywordSempred(antlrcpp::downCast<LabelKeywordContext *>(context), predicateIndex);
    case 604: return identifierKeywordsUnambiguousSempred(antlrcpp::downCast<IdentifierKeywordsUnambiguousContext *>(context), predicateIndex);
    case 605: return roleKeywordSempred(antlrcpp::downCast<RoleKeywordContext *>(context), predicateIndex);
    case 608: return roleOrIdentifierKeywordSempred(antlrcpp::downCast<RoleOrIdentifierKeywordContext *>(context), predicateIndex);
    case 609: 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 >= 80000;
    case 3: return serverVersion >= 50604;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterStatementSempred(AlterStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 4: return serverVersion >= 80014;
    case 5: return serverVersion >= 50713;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterDatabaseSempred(AlterDatabaseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 6: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterTableSempred(AlterTableContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 7: return serverVersion < 50700;

  default:
    break;
  }
  return true;
}

bool MySQLParser::standaloneAlterCommandsSempred(StandaloneAlterCommandsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 8: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterPartitionSempred(AlterPartitionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 9: return serverVersion >= 50704;
    case 10: return serverVersion >= 50704;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterListItemSempred(AlterListItemContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 11: return serverVersion >= 50700;
    case 12: return serverVersion < 50700;
    case 13: return serverVersion >= 80017;
    case 14: return serverVersion >= 80019;
    case 15: return serverVersion >= 80014;
    case 16: return serverVersion >= 80000;
    case 17: return serverVersion >= 80017;
    case 18: return serverVersion >= 80019;
    case 19: return serverVersion >= 80000;
    case 20: return serverVersion >= 50700;
    case 21: return serverVersion >= 80014;
    case 22: return serverVersion >= 50708 && serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::withValidationSempred(WithValidationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 23: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterTablespaceSempred(AlterTablespaceContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 24: return serverVersion < 80000;
    case 25: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createStatementSempred(CreateStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 26: return serverVersion >= 80000;
    case 27: return serverVersion >= 80011;
    case 28: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createDatabaseOptionSempred(CreateDatabaseOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 29: return serverVersion >= 80016;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createIndexSempred(CreateIndexContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 30: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tsDataFileNameSempred(TsDataFileNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 31: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tablespaceOptionSempred(TablespaceOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 32: return serverVersion >= 50707;
    case 33: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::triggerFollowsPrecedesClauseSempred(TriggerFollowsPrecedesClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 34: return serverVersion >= 50700;

  default:
    break;
  }
  return true;
}

bool MySQLParser::dropStatementSempred(DropStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 35: return serverVersion >= 80000;
    case 36: return serverVersion >= 80011;
    case 37: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::deleteStatementSempred(DeleteStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 38: return serverVersion >= 80000;
    case 39: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::partitionDeleteSempred(PartitionDeleteContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 40: return serverVersion >= 50602;

  default:
    break;
  }
  return true;
}

bool MySQLParser::doStatementSempred(DoStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 41: return serverVersion < 50709;
    case 42: return serverVersion >= 50709;

  default:
    break;
  }
  return true;
}

bool MySQLParser::insertStatementSempred(InsertStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 43: return  serverVersion >= 80018;
    case 44: return  serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::queryExpressionSempred(QueryExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 45: return serverVersion >= 80000;
    case 46: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::queryPrimarySempred(QueryPrimaryContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 47: return serverVersion >= 80019;
    case 48: return serverVersion >= 80019;

  default:
    break;
  }
  return true;
}

bool MySQLParser::querySpecificationSempred(QuerySpecificationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 49: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::olapOptionSempred(OlapOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 50: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::selectOptionSempred(SelectOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 51: return serverVersion < 80000;
    case 52: return serverVersion >= 50704 && serverVersion < 50708;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockingClauseSempred(LockingClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 53: return serverVersion >= 80000;
    case 54: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockStrenghSempred(LockStrenghContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 55: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableReferenceSempred(TableReferenceContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 56: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableFactorSempred(TableFactorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 57: return serverVersion >= 80004;

  default:
    break;
  }
  return true;
}

bool MySQLParser::derivedTableSempred(DerivedTableContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 58: return serverVersion >= 80000;
    case 59: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::jtColumnSempred(JtColumnContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 60: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableAliasSempred(TableAliasContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 61: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::updateStatementSempred(UpdateStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 62: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::transactionCharacteristicSempred(TransactionCharacteristicContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 63: return serverVersion >= 50605;

  default:
    break;
  }
  return true;
}

bool MySQLParser::lockStatementSempred(LockStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 64: return serverVersion >= 80000;
    case 65: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::xaConvertSempred(XaConvertContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 66: return serverVersion >= 50704;

  default:
    break;
  }
  return true;
}

bool MySQLParser::replicationStatementSempred(ReplicationStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 67: return serverVersion > 80000;
    case 68: return serverVersion >= 50700;
    case 69: return serverVersion > 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::resetOptionSempred(ResetOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 70: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::masterResetOptionsSempred(MasterResetOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 71: return serverVersion >= 80000;
    case 72: return serverVersion < 80017;
    case 73: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::changeReplicationSempred(ChangeReplicationContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 74: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::slaveUntilOptionsSempred(SlaveUntilOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 75: return serverVersion >= 50606;
    case 76: return serverVersion >= 50606;

  default:
    break;
  }
  return true;
}

bool MySQLParser::slaveConnectionOptionsSempred(SlaveConnectionOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 77: return serverVersion >= 50604;

  default:
    break;
  }
  return true;
}

bool MySQLParser::cloneStatementSempred(CloneStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 78: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::accountManagementStatementSempred(AccountManagementStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 79: return serverVersion >= 50606;
    case 80: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterUserSempred(AlterUserContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 81: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::alterUserTailSempred(AlterUserTailContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 82: return serverVersion < 80014;
    case 83: return serverVersion >= 80014;
    case 84: return serverVersion >= 50706;
    case 85: return serverVersion >= 80014;
    case 86: return serverVersion >= 80014;
    case 87: return serverVersion >= 80014;
    case 88: return serverVersion >= 80000;
    case 89: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUserSempred(CreateUserContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 90: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUserTailSempred(CreateUserTailContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 91: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::defaultRoleClauseSempred(DefaultRoleClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 92: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::accountLockPasswordExpireOptionsSempred(AccountLockPasswordExpireOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 93: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

bool MySQLParser::dropUserSempred(DropUserContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 94: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantSempred(GrantContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 95: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantTargetListSempred(GrantTargetListContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 96: return serverVersion < 80011;
    case 97: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantOptionsSempred(GrantOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 98: return serverVersion < 80011;
    case 99: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::versionedRequireClauseSempred(VersionedRequireClauseContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 100: return serverVersion < 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::revokeSempred(RevokeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 101: return serverVersion >= 80000;
    case 102: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::onTypeToSempred(OnTypeToContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 103: return serverVersion < 80000;
    case 104: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleOrPrivilegeSempred(RoleOrPrivilegeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 105: return serverVersion > 80000;
    case 106: return serverVersion > 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::grantIdentifierSempred(GrantIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 107: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableAdministrationStatementSempred(TableAdministrationStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 108: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::startOptionValueListSempred(StartOptionValueListContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 109: return serverVersion < 50706;
    case 110: return serverVersion < 80014;
    case 111: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::optionValueNoOptionTypeSempred(OptionValueNoOptionTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 112: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::setExprOrDefaultSempred(SetExprOrDefaultContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 113: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showStatementSempred(ShowStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 114: return serverVersion < 50700;
    case 115: return serverVersion >= 80000;
    case 116: return serverVersion < 50700;
    case 117: return serverVersion >= 50704;

  default:
    break;
  }
  return true;
}

bool MySQLParser::showCommandTypeSempred(ShowCommandTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 118: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::nonBlockingSempred(NonBlockingContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 119: return serverVersion >= 50700 && serverVersion < 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::otherAdministrativeStatementSempred(OtherAdministrativeStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 120: return serverVersion >= 50709;

  default:
    break;
  }
  return true;
}

bool MySQLParser::flushOptionSempred(FlushOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 121: return serverVersion < 80000;
    case 122: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::flushTablesOptionsSempred(FlushTablesOptionsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 123: return serverVersion >= 50606;

  default:
    break;
  }
  return true;
}

bool MySQLParser::utilityStatementSempred(UtilityStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 124: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::explainStatementSempred(ExplainStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 125: return serverVersion < 80000;
    case 126: return serverVersion < 80000;
    case 127: return serverVersion >= 50605;
    case 128: return serverVersion >= 80018;
    case 129: return serverVersion >= 80019;

  default:
    break;
  }
  return true;
}

bool MySQLParser::explainableStatementSempred(ExplainableStatementContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 130: return serverVersion >= 50603;
    case 131: return serverVersion >= 50700;

  default:
    break;
  }
  return true;
}

bool MySQLParser::exprSempred(ExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 132: return precpred(_ctx, 3);
    case 133: return precpred(_ctx, 2);
    case 134: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool MySQLParser::boolPriSempred(BoolPriContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 135: return precpred(_ctx, 3);
    case 136: return precpred(_ctx, 2);
    case 137: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool MySQLParser::predicateSempred(PredicateContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 138: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::bitExprSempred(BitExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 139: return precpred(_ctx, 7);
    case 140: return precpred(_ctx, 6);
    case 141: return precpred(_ctx, 5);
    case 142: return precpred(_ctx, 3);
    case 143: return precpred(_ctx, 2);
    case 144: return precpred(_ctx, 1);
    case 145: return precpred(_ctx, 4);

  default:
    break;
  }
  return true;
}

bool MySQLParser::simpleExprSempred(SimpleExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 146: return serverVersion >= 80000;
    case 147: return serverVersion >= 80000;
    case 148: return precpred(_ctx, 15);
    case 149: return precpred(_ctx, 21);

  default:
    break;
  }
  return true;
}

bool MySQLParser::arrayCastSempred(ArrayCastContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 150: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::jsonOperatorSempred(JsonOperatorContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 151: return serverVersion >= 50708;
    case 152: return serverVersion >= 50713;

  default:
    break;
  }
  return true;
}

bool MySQLParser::sumExprSempred(SumExprContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 153: return serverVersion >= 80000;
    case 154: return serverVersion >= 80000;
    case 155: return serverVersion >= 80000;
    case 156: return serverVersion >= 80000;
    case 157: return serverVersion >= 80000;
    case 158: return serverVersion >= 80000;
    case 159: return serverVersion >= 80000;
    case 160: return serverVersion >= 80000;
    case 161: return serverVersion >= 80000;
    case 162: return serverVersion >= 80000;
    case 163: return serverVersion >= 80000;
    case 164: return serverVersion >= 80000;
    case 165: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::runtimeFunctionCallSempred(RuntimeFunctionCallContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 166: return serverVersion < 50607;
    case 167: return serverVersion < 80011;
    case 168: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::geometryFunctionSempred(GeometryFunctionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 169: return serverVersion < 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::fractionalPrecisionSempred(FractionalPrecisionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 170: return serverVersion >= 50604;

  default:
    break;
  }
  return true;
}

bool MySQLParser::internalVariableNameSempred(InternalVariableNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 171: return serverVersion < 80017;
    case 172: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::castTypeSempred(CastTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 173: return serverVersion >= 50708;
    case 174: return serverVersion >= 80017;
    case 175: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::channelSempred(ChannelContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 176: return serverVersion >= 50706;

  default:
    break;
  }
  return true;
}

bool MySQLParser::getDiagnosticsSempred(GetDiagnosticsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 177: return serverVersion >= 50700;

  default:
    break;
  }
  return true;
}

bool MySQLParser::checkOrReferencesSempred(CheckOrReferencesContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 178: return serverVersion < 80016;

  default:
    break;
  }
  return true;
}

bool MySQLParser::tableConstraintDefSempred(TableConstraintDefContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 179: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::fieldDefinitionSempred(FieldDefinitionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 180: return serverVersion >= 50707;
    case 181: return serverVersion < 80000;
    case 182: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::columnAttributeSempred(ColumnAttributeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 183: return serverVersion >= 80014;
    case 184: return serverVersion >= 80013;
    case 185: return serverVersion >= 80000;
    case 186: return serverVersion >= 80017;
    case 187: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::keyListVariantsSempred(KeyListVariantsContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 188: return serverVersion >= 80013;
    case 189: return serverVersion < 80013;

  default:
    break;
  }
  return true;
}

bool MySQLParser::commonIndexOptionSempred(CommonIndexOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 190: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::dataTypeSempred(DataTypeContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 191: return serverVersion >= 50708;

  default:
    break;
  }
  return true;
}

bool MySQLParser::charsetNameSempred(CharsetNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 192: return serverVersion < 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::collationNameSempred(CollationNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 193: return serverVersion < 80011;
    case 194: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createTableOptionSempred(CreateTableOptionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 195: return serverVersion >= 80014;
    case 196: return serverVersion >= 50708;
    case 197: return serverVersion >= 50711;
    case 198: return serverVersion >= 50707;

  default:
    break;
  }
  return true;
}

bool MySQLParser::partitionKeyAlgorithmSempred(PartitionKeyAlgorithmContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 199: return serverVersion >= 50700;

  default:
    break;
  }
  return true;
}

bool MySQLParser::createUserEntrySempred(CreateUserEntryContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 200: return serverVersion < 80011;
    case 201: return serverVersion >= 50706;
    case 202: return serverVersion >= 80018;

  default:
    break;
  }
  return true;
}

bool MySQLParser::usePartitionSempred(UsePartitionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 203: return serverVersion >= 50602;

  default:
    break;
  }
  return true;
}

bool MySQLParser::columnNameSempred(ColumnNameContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 204: return serverVersion >= 80000;
    case 205: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::pureIdentifierSempred(PureIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 206: return isSqlModeActive(AnsiQuotes);

  default:
    break;
  }
  return true;
}

bool MySQLParser::simpleIdentifierSempred(SimpleIdentifierContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 207: return serverVersion < 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::real_ulonglong_numberSempred(Real_ulonglong_numberContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 208: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::textStringLiteralSempred(TextStringLiteralContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 209: return !isSqlModeActive(AnsiQuotes);

  default:
    break;
  }
  return true;
}

bool MySQLParser::textStringHashSempred(TextStringHashContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 210: return serverVersion >= 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identifierKeywordSempred(IdentifierKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 211: return serverVersion < 80017;
    case 212: return serverVersion >= 50709;
    case 213: return serverVersion >= 80011;

  default:
    break;
  }
  return true;
}

bool MySQLParser::labelKeywordSempred(LabelKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 214: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::identifierKeywordsUnambiguousSempred(IdentifierKeywordsUnambiguousContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 215: return serverVersion >= 80019;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleKeywordSempred(RoleKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 216: return serverVersion < 80017;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleOrIdentifierKeywordSempred(RoleOrIdentifierKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 217: return serverVersion >= 50709;
    case 218: return serverVersion >= 80000;

  default:
    break;
  }
  return true;
}

bool MySQLParser::roleOrLabelKeywordSempred(RoleOrLabelKeywordContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 219: return serverVersion < 50709;
    case 220: return serverVersion < 80000;
    case 221: return serverVersion >= 80000;
    case 222: return serverVersion >= 80014;

  default:
    break;
  }
  return true;
}

void MySQLParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  mysqlparserParserInitialize();
#else
  ::antlr4::internal::call_once(mysqlparserParserOnceFlag, mysqlparserParserInitialize);
#endif
}
