
// Generated from fugue_sql.g4 by ANTLR 4.10.1


#include "fugue_sqlVisitor.h"

#include "fugue_sqlParser.h"


using namespace antlrcpp;

using namespace antlr4;

namespace {

struct Fugue_sqlParserStaticData final {
  Fugue_sqlParserStaticData(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) {}

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

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

std::once_flag fugue_sqlParserOnceFlag;
Fugue_sqlParserStaticData *fugue_sqlParserStaticData = nullptr;

void fugue_sqlParserInitialize() {
  assert(fugue_sqlParserStaticData == nullptr);
  auto staticData = std::make_unique<Fugue_sqlParserStaticData>(
    std::vector<std::string>{
      "fugueLanguage", "fugueSingleStatement", "fugueSingleTask", "fugueNestableTask", 
      "fugueNestableTaskCollectionNoSelect", "fugueTransformTask", "fugueProcessTask", 
      "fugueSaveAndUseTask", "fugueRenameColumnsTask", "fugueAlterColumnsTask", 
      "fugueDropColumnsTask", "fugueDropnaTask", "fugueFillnaTask", "fugueSampleTask", 
      "fugueTakeTask", "fugueZipTask", "fugueCreateTask", "fugueCreateDataTask", 
      "fugueLoadTask", "fugueOutputTask", "fuguePrintTask", "fugueSaveTask", 
      "fugueOutputTransformTask", "fugueModuleTask", "fugueSqlEngine", "fugueSingleFile", 
      "fugueLoadColumns", "fugueSaveMode", "fugueFileFormat", "fuguePath", 
      "fugueCheckpoint", "fugueCheckpointNamespace", "fugueYield", "fugueBroadcast", 
      "fugueDataFrames", "fugueDataFramePair", "fugueDataFrame", "fugueDataFrameMember", 
      "fugueAssignment", "fugueAssignmentSign", "fugueSingleOutputExtensionCommonWild", 
      "fugueSingleOutputExtensionCommon", "fugueExtension", "fugueSampleMethod", 
      "fugueZipType", "fuguePrepartition", "fuguePartitionAlgo", "fuguePartitionNum", 
      "fuguePartitionNumber", "fugueParams", "fugueCols", "fugueColsSort", 
      "fugueColSort", "fugueColumnIdentifier", "fugueRenameExpression", 
      "fugueWildSchema", "fugueWildSchemaPair", "fugueSchemaOp", "fugueSchema", 
      "fugueSchemaPair", "fugueSchemaKey", "fugueSchemaType", "fugueRenamePair", 
      "fugueJson", "fugueJsonObj", "fugueJsonPairs", "fugueJsonPair", "fugueJsonKey", 
      "fugueJsonArray", "fugueJsonValue", "fugueJsonNumber", "fugueJsonString", 
      "fugueJsonBool", "fugueJsonNull", "fugueIdentifier", "singleStatement", 
      "singleExpression", "singleTableIdentifier", "singleMultipartIdentifier", 
      "singleFunctionIdentifier", "singleDataType", "singleTableSchema", 
      "statement", "unsupportedHiveNativeCommands", "createTableHeader", 
      "replaceTableHeader", "bucketSpec", "skewSpec", "locationSpec", "commentSpec", 
      "query", "insertInto", "partitionSpecLocation", "partitionSpec", "partitionVal", 
      "theNamespace", "describeFuncName", "describeColName", "ctes", "namedQuery", 
      "tableProvider", "createTableClauses", "tablePropertyList", "tableProperty", 
      "tablePropertyKey", "tablePropertyValue", "constantList", "nestedConstantList", 
      "createFileFormat", "fileFormat", "storageHandler", "resource", "dmlStatementNoWith", 
      "queryOrganization", "multiInsertQueryBody", "queryTerm", "queryPrimary", 
      "sortItem", "fromStatement", "fromStatementBody", "querySpecification", 
      "optionalFromClause", "transformClause", "selectClause", "setClause", 
      "matchedClause", "notMatchedClause", "matchedAction", "notMatchedAction", 
      "assignmentList", "assignment", "whereClause", "havingClause", "hint", 
      "hintStatement", "fromClause", "aggregationClause", "groupingSet", 
      "pivotClause", "pivotColumn", "pivotValue", "lateralView", "setQuantifier", 
      "relation", "joinRelation", "joinType", "joinCriteria", "sample", 
      "sampleMethod", "identifierList", "identifierSeq", "orderedIdentifierList", 
      "orderedIdentifier", "identifierCommentList", "identifierComment", 
      "relationPrimary", "inlineTable", "functionTable", "tableAlias", "rowFormat", 
      "multipartIdentifierList", "multipartIdentifier", "tableIdentifier", 
      "functionIdentifier", "namedExpression", "namedExpressionSeq", "transformList", 
      "transform", "transformArgument", "expression", "booleanExpression", 
      "predicate", "valueExpression", "primaryExpression", "constant", "comparisonOperator", 
      "comparisonEqualOperator", "arithmeticOperator", "predicateOperator", 
      "booleanValue", "interval", "errorCapturingMultiUnitsInterval", "multiUnitsInterval", 
      "errorCapturingUnitToUnitInterval", "unitToUnitInterval", "intervalValue", 
      "intervalUnit", "colPosition", "dataType", "qualifiedColTypeWithPositionList", 
      "qualifiedColTypeWithPosition", "colTypeList", "colType", "complexColTypeList", 
      "complexColType", "whenClause", "windowClause", "namedWindow", "windowSpec", 
      "windowFrame", "frameBound", "qualifiedNameList", "functionName", 
      "qualifiedName", "errorCapturingIdentifier", "errorCapturingIdentifierExtra", 
      "identifier", "strictIdentifier", "quotedIdentifier", "number", "alterColumnAction", 
      "ansiNonReserved", "strictNonReserved", "nonReserved"
    },
    std::vector<std::string>{
      "", "','", "':'", "'('", "')'", "'['", "']'", "'.'", "'{'", "'}'", 
      "'true'", "'false'", "'null'", "';'", "'/*+'", "'*/'", "'->'", "'FILL'", 
      "'TAKE'", "'HASH'", "'RAND'", "'EVEN'", "'PRESORT'", "'PERSIST'", 
      "'BROADCAST'", "'PARAMS'", "'PROCESS'", "'OUTPUT'", "'OUTTRANSFORM'", 
      "'ROWCOUNT'", "'CONCURRENCY'", "'PREPARTITION'", "'ZIP'", "'PRINT'", 
      "'TITLE'", "'SAVE'", "'APPEND'", "'PARQUET'", "'CSV'", "'JSON'", "'SINGLE'", 
      "'CHECKPOINT'", "'WEAK'", "'STRONG'", "'DETERMINISTIC'", "'YIELD'", 
      "'CONNECT'", "'SAMPLE'", "'SEED'", "'SUB'", "'CALLBACK'", "'DATAFRAME'", 
      "'FILE'", "'ADD'", "'AFTER'", "'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", 
      "'ANTI'", "'ANY'", "'ARCHIVE'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", 
      "'AUTHORIZATION'", "'BETWEEN'", "'BOTH'", "'BUCKET'", "'BUCKETS'", 
      "'BY'", "'CACHE'", "'CASCADE'", "'CASE'", "", "'CHANGE'", "'CHECK'", 
      "'CLEAR'", "'CLUSTER'", "'CLUSTERED'", "'CODEGEN'", "'COLLATE'", "'COLLECTION'", 
      "'COLUMN'", "'COLUMNS'", "'COMMENT'", "'COMMIT'", "'COMPACT'", "'COMPACTIONS'", 
      "'COMPUTE'", "'CONCATENATE'", "'CONSTRAINT'", "'COST'", "'CREATE'", 
      "'CROSS'", "'CUBE'", "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_TIME'", 
      "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'DATA'", "'DATABASE'", "", 
      "'DAY'", "'DBPROPERTIES'", "'DEFINED'", "'DELETE'", "'DELIMITED'", 
      "'DESC'", "'DESCRIBE'", "'DFS'", "'DIRECTORIES'", "'DIRECTORY'", "'DISTINCT'", 
      "'DISTRIBUTE'", "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", "'ESCAPED'", 
      "'EXCEPT'", "'EXCHANGE'", "'EXISTS'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'", 
      "'EXTERNAL'", "'EXTRACT'", "'FALSE'", "'FETCH'", "'FIELDS'", "'FILTER'", 
      "'FILEFORMAT'", "'FIRST'", "'FOLLOWING'", "'FOR'", "'FOREIGN'", "'FORMAT'", 
      "'FORMATTED'", "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", "'GLOBAL'", 
      "'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", "'HOUR'", "'IF'", 
      "'IGNORE'", "'IMPORT'", "'IN'", "'INDEX'", "'INDEXES'", "'INNER'", 
      "'INPATH'", "'INPUTFORMAT'", "'INSERT'", "'INTERSECT'", "'INTERVAL'", 
      "'INTO'", "'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", "'LATERAL'", 
      "'LAZY'", "'LEADING'", "'LEFT'", "'LIKE'", "'LIMIT'", "'LINES'", "'LIST'", 
      "'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'", 
      "'MACRO'", "'MAP'", "'MATCHED'", "'MERGE'", "'MINUTE'", "'MONTH'", 
      "'MSCK'", "'NAMESPACE'", "'NAMESPACES'", "'NATURAL'", "'NO'", "", 
      "'NULL'", "'NULLS'", "'OF'", "'ON'", "'ONLY'", "'OPTION'", "'OPTIONS'", 
      "'OR'", "'ORDER'", "'OUT'", "'OUTER'", "'OUTPUTFORMAT'", "'OVER'", 
      "'OVERLAPS'", "'OVERLAY'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONED'", 
      "'PARTITIONS'", "'PERCENT'", "'PIVOT'", "'PLACING'", "'POSITION'", 
      "'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'", "'PURGE'", 
      "'QUERY'", "'RANGE'", "'RECORDREADER'", "'RECORDWRITER'", "'RECOVER'", 
      "'REDUCE'", "'REFERENCES'", "'REFRESH'", "'RENAME'", "'REPAIR'", "'REPLACE'", 
      "'RESET'", "'RESTRICT'", "'REVOKE'", "'RIGHT'", "", "'ROLE'", "'ROLES'", 
      "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", "'SCHEMA'", "'SECOND'", 
      "'SELECT'", "'SEMI'", "'SEPARATED'", "'SERDE'", "'SERDEPROPERTIES'", 
      "'SESSION_USER'", "'SET'", "'MINUS'", "'SETS'", "'SHOW'", "'SKEWED'", 
      "'SOME'", "'SORT'", "'SORTED'", "'START'", "'STATISTICS'", "'STORED'", 
      "'STRATIFY'", "'STRUCT'", "'SUBSTR'", "'SUBSTRING'", "'TABLE'", "'TABLES'", 
      "'TABLESAMPLE'", "'TBLPROPERTIES'", "", "'TERMINATED'", "'THEN'", 
      "'TO'", "'TOUCH'", "'TRAILING'", "'TRANSACTION'", "'TRANSACTIONS'", 
      "'TRANSFORM'", "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TYPE'", "'UNARCHIVE'", 
      "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'", "'UNKNOWN'", "'UNLOCK'", 
      "'UNSET'", "'UPDATE'", "'USE'", "'USER'", "'USING'", "'VALUES'", "'VIEW'", 
      "'VIEWS'", "'WHEN'", "'WHERE'", "'WINDOW'", "'WITH'", "'YEAR'", "'='", 
      "'=='", "'<=>'", "'<>'", "'!='", "'<'", "", "'>'", "", "'+'", "'-'", 
      "'*'", "'/'", "'%'", "'DIV'", "'~'", "'&'", "'|'", "'||'", "'^'"
    },
    std::vector<std::string>{
      "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 
      "FILL", "TAKE", "HASH", "RAND", "EVEN", "PRESORT", "PERSIST", "BROADCAST", 
      "PARAMS", "PROCESS", "OUTPUT", "OUTTRANSFORM", "ROWCOUNT", "CONCURRENCY", 
      "PREPARTITION", "ZIP", "PRINT", "TITLE", "SAVE", "APPEND", "PARQUET", 
      "CSV", "JSON", "SINGLE", "CHECKPOINT", "WEAK", "STRONG", "DETERMINISTIC", 
      "YIELD", "CONNECT", "SAMPLE", "SEED", "SUB", "CALLBACK", "DATAFRAME", 
      "FILE", "ADD", "AFTER", "ALL", "ALTER", "ANALYZE", "AND", "ANTI", 
      "ANY", "ARCHIVE", "ARRAY", "AS", "ASC", "AT", "AUTHORIZATION", "BETWEEN", 
      "BOTH", "BUCKET", "BUCKETS", "BY", "CACHE", "CASCADE", "CASE", "CAST", 
      "CHANGE", "CHECK", "CLEAR", "CLUSTER", "CLUSTERED", "CODEGEN", "COLLATE", 
      "COLLECTION", "COLUMN", "COLUMNS", "COMMENT", "COMMIT", "COMPACT", 
      "COMPACTIONS", "COMPUTE", "CONCATENATE", "CONSTRAINT", "COST", "CREATE", 
      "CROSS", "CUBE", "CURRENT", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", 
      "CURRENT_USER", "DATA", "DATABASE", "DATABASES", "DAY", "DBPROPERTIES", 
      "DEFINED", "DELETE", "DELIMITED", "DESC", "DESCRIBE", "DFS", "DIRECTORIES", 
      "DIRECTORY", "DISTINCT", "DISTRIBUTE", "DROP", "ELSE", "END", "ESCAPE", 
      "ESCAPED", "EXCEPT", "EXCHANGE", "EXISTS", "EXPLAIN", "EXPORT", "EXTENDED", 
      "EXTERNAL", "EXTRACT", "FALSE", "FETCH", "FIELDS", "FILTER", "FILEFORMAT", 
      "FIRST", "FOLLOWING", "FOR", "FOREIGN", "FORMAT", "FORMATTED", "FROM", 
      "FULL", "FUNCTION", "FUNCTIONS", "GLOBAL", "GRANT", "GROUP", "GROUPING", 
      "HAVING", "HOUR", "IF", "IGNORE", "IMPORT", "IN", "INDEX", "INDEXES", 
      "INNER", "INPATH", "INPUTFORMAT", "INSERT", "INTERSECT", "INTERVAL", 
      "INTO", "IS", "ITEMS", "JOIN", "KEYS", "LAST", "LATERAL", "LAZY", 
      "LEADING", "LEFT", "LIKE", "LIMIT", "LINES", "LIST", "LOAD", "LOCAL", 
      "LOCATION", "LOCK", "LOCKS", "LOGICAL", "MACRO", "MAP", "MATCHED", 
      "MERGE", "MINUTE", "MONTH", "MSCK", "NAMESPACE", "NAMESPACES", "NATURAL", 
      "NO", "NOT", "THENULL", "THENULLS", "OF", "ON", "ONLY", "OPTION", 
      "OPTIONS", "OR", "ORDER", "OUT", "OUTER", "OUTPUTFORMAT", "OVER", 
      "OVERLAPS", "OVERLAY", "OVERWRITE", "PARTITION", "PARTITIONED", "PARTITIONS", 
      "PERCENTLIT", "PIVOT", "PLACING", "POSITION", "PRECEDING", "PRIMARY", 
      "PRINCIPALS", "PROPERTIES", "PURGE", "QUERY", "RANGE", "RECORDREADER", 
      "RECORDWRITER", "RECOVER", "REDUCE", "REFERENCES", "REFRESH", "RENAME", 
      "REPAIR", "REPLACE", "RESET", "RESTRICT", "REVOKE", "RIGHT", "RLIKE", 
      "ROLE", "ROLES", "ROLLBACK", "ROLLUP", "ROW", "ROWS", "SCHEMA", "SECOND", 
      "SELECT", "SEMI", "SEPARATED", "SERDE", "SERDEPROPERTIES", "SESSION_USER", 
      "SET", "SETMINUS", "SETS", "SHOW", "SKEWED", "SOME", "SORT", "SORTED", 
      "START", "STATISTICS", "STORED", "STRATIFY", "STRUCT", "SUBSTR", "SUBSTRING", 
      "TABLE", "TABLES", "TABLESAMPLE", "TBLPROPERTIES", "TEMPORARY", "TERMINATED", 
      "THEN", "TO", "TOUCH", "TRAILING", "TRANSACTION", "TRANSACTIONS", 
      "TRANSFORM", "TRIM", "TRUE", "TRUNCATE", "TYPE", "UNARCHIVE", "UNBOUNDED", 
      "UNCACHE", "UNION", "UNIQUE", "UNKNOWN", "UNLOCK", "UNSET", "UPDATE", 
      "USE", "USER", "USING", "VALUES", "VIEW", "VIEWS", "WHEN", "WHERE", 
      "WINDOW", "WITH", "YEAR", "EQUAL", "DOUBLEEQUAL", "NSEQ", "NEQ", "NEQJ", 
      "LT", "LTE", "GT", "GTE", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", 
      "DIV", "TILDE", "AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT", "STRING", 
      "BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", 
      "EXPONENT_VALUE", "DECIMAL_VALUE", "DOUBLE_LITERAL", "BIGDECIMAL_LITERAL", 
      "IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", "BRACKETED_COMMENT", 
      "WS", "UNRECOGNIZED"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,339,3834,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,1,0,4,0,430,8,0,11,0,12,0,431,1,0,1,0,1,1,1,1,1,1,1,
  	2,1,2,1,2,1,2,1,2,1,2,3,2,445,8,2,1,3,3,3,448,8,3,1,3,1,3,3,3,452,8,3,
  	1,3,3,3,455,8,3,1,3,3,3,458,8,3,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,4,1,
  	4,1,4,1,4,1,4,1,4,3,4,474,8,4,1,5,1,5,3,5,478,8,5,1,5,3,5,481,8,5,1,5,
  	1,5,1,5,3,5,486,8,5,1,6,1,6,3,6,490,8,6,1,6,3,6,493,8,6,1,6,1,6,1,7,1,
  	7,1,7,1,7,3,7,501,8,7,1,7,3,7,504,8,7,1,7,1,7,3,7,508,8,7,1,7,3,7,511,
  	8,7,1,7,1,7,3,7,515,8,7,1,8,1,8,1,8,1,8,1,8,3,8,522,8,8,1,9,1,9,1,9,1,
  	9,1,9,3,9,529,8,9,1,10,1,10,1,10,1,10,1,10,3,10,536,8,10,1,10,1,10,3,
  	10,540,8,10,1,11,1,11,1,11,1,11,1,11,1,11,1,11,3,11,549,8,11,1,11,1,11,
  	3,11,553,8,11,1,12,1,12,1,12,1,12,1,12,3,12,560,8,12,1,13,1,13,3,13,564,
  	8,13,1,13,1,13,1,13,3,13,569,8,13,1,13,1,13,3,13,573,8,13,1,14,1,14,1,
  	14,3,14,578,8,14,1,14,1,14,3,14,582,8,14,1,14,1,14,1,14,3,14,587,8,14,
  	1,14,1,14,3,14,591,8,14,1,15,1,15,1,15,3,15,596,8,15,1,15,1,15,3,15,600,
  	8,15,1,15,1,15,3,15,604,8,15,1,16,1,16,1,16,1,17,1,17,3,17,611,8,17,1,
  	17,1,17,1,17,1,17,1,18,1,18,3,18,619,8,18,1,18,1,18,3,18,623,8,18,1,18,
  	1,18,3,18,627,8,18,1,19,1,19,3,19,631,8,19,1,19,3,19,634,8,19,1,19,1,
  	19,1,19,3,19,639,8,19,1,20,1,20,1,20,1,20,1,20,3,20,646,8,20,1,20,3,20,
  	649,8,20,1,20,1,20,3,20,653,8,20,1,20,1,20,3,20,657,8,20,1,20,3,20,660,
  	8,20,1,20,1,20,3,20,664,8,20,3,20,666,8,20,1,21,1,21,3,21,670,8,21,1,
  	21,3,21,673,8,21,1,21,1,21,3,21,677,8,21,1,21,3,21,680,8,21,1,21,1,21,
  	3,21,684,8,21,1,22,1,22,3,22,688,8,22,1,22,3,22,691,8,22,1,22,1,22,1,
  	22,3,22,696,8,22,1,22,1,22,3,22,700,8,22,1,23,3,23,703,8,23,1,23,1,23,
  	3,23,707,8,23,1,23,1,23,1,23,3,23,712,8,23,1,24,1,24,1,24,3,24,717,8,
  	24,1,25,1,25,1,26,1,26,3,26,723,8,26,1,27,1,27,1,28,1,28,1,29,1,29,1,
  	30,3,30,732,8,30,1,30,1,30,1,30,3,30,737,8,30,1,30,3,30,740,8,30,1,30,
  	3,30,743,8,30,1,30,3,30,746,8,30,1,30,1,30,3,30,750,8,30,1,30,3,30,753,
  	8,30,1,30,3,30,756,8,30,1,30,3,30,759,8,30,1,30,1,30,1,30,3,30,764,8,
  	30,1,30,3,30,767,8,30,1,30,3,30,770,8,30,1,30,3,30,773,8,30,3,30,775,
  	8,30,1,31,1,31,1,32,1,32,1,32,1,32,3,32,783,8,32,1,32,1,32,3,32,787,8,
  	32,1,32,1,32,1,32,3,32,792,8,32,3,32,794,8,32,1,33,1,33,1,34,1,34,1,34,
  	5,34,801,8,34,10,34,12,34,804,9,34,1,34,1,34,1,34,5,34,809,8,34,10,34,
  	12,34,812,9,34,3,34,814,8,34,1,35,1,35,1,35,1,35,1,36,1,36,3,36,822,8,
  	36,1,36,1,36,1,36,1,36,3,36,828,8,36,1,37,1,37,1,37,3,37,833,8,37,1,37,
  	1,37,1,38,1,38,1,38,1,39,1,39,1,40,1,40,1,40,3,40,845,8,40,1,40,1,40,
  	3,40,849,8,40,1,41,1,41,1,41,3,41,854,8,41,1,41,1,41,3,41,858,8,41,1,
  	42,1,42,1,42,5,42,863,8,42,10,42,12,42,866,9,42,1,43,1,43,1,43,1,43,3,
  	43,872,8,43,1,44,1,44,1,44,1,44,1,44,1,44,1,44,1,44,3,44,882,8,44,1,45,
  	3,45,885,8,45,1,45,1,45,1,45,1,45,3,45,891,8,45,1,45,1,45,3,45,895,8,
  	45,1,45,3,45,898,8,45,1,45,1,45,1,45,1,45,1,45,3,45,905,8,45,3,45,907,
  	8,45,1,46,1,46,1,47,1,47,1,47,1,47,1,47,1,47,3,47,917,8,47,1,47,1,47,
  	1,47,5,47,922,8,47,10,47,12,47,925,9,47,1,48,3,48,928,8,48,1,48,1,48,
  	3,48,932,8,48,1,48,1,48,1,48,3,48,937,8,48,1,49,1,49,1,49,3,49,942,8,
  	49,1,49,3,49,945,8,49,1,50,1,50,1,50,5,50,950,8,50,10,50,12,50,953,9,
  	50,1,51,1,51,1,51,5,51,958,8,51,10,51,12,51,961,9,51,1,52,1,52,3,52,965,
  	8,52,1,53,1,53,1,54,1,54,1,54,5,54,972,8,54,10,54,12,54,975,9,54,1,55,
  	1,55,1,55,5,55,980,8,55,10,55,12,55,983,9,55,1,55,5,55,986,8,55,10,55,
  	12,55,989,9,55,1,56,1,56,3,56,993,8,56,1,57,1,57,1,57,1,57,5,57,999,8,
  	57,10,57,12,57,1002,9,57,1,57,1,57,3,57,1006,8,57,1,58,1,58,1,58,5,58,
  	1011,8,58,10,58,12,58,1014,9,58,1,59,1,59,1,59,1,59,1,60,1,60,1,61,1,
  	61,1,61,1,61,1,61,1,61,1,61,1,61,1,61,3,61,1031,8,61,1,62,1,62,1,62,1,
  	62,1,63,1,63,1,64,1,64,1,64,3,64,1042,8,64,1,64,1,64,1,64,1,64,1,64,1,
  	64,1,64,3,64,1051,8,64,1,64,1,64,1,64,1,64,3,64,1057,8,64,1,65,1,65,1,
  	65,5,65,1062,8,65,10,65,12,65,1065,9,65,1,66,1,66,1,66,1,66,1,67,1,67,
  	3,67,1073,8,67,1,68,1,68,1,68,1,68,5,68,1079,8,68,10,68,12,68,1082,9,
  	68,1,68,3,68,1085,8,68,1,68,1,68,1,68,1,68,3,68,1091,8,68,1,69,1,69,1,
  	69,1,69,1,69,1,69,3,69,1099,8,69,1,70,1,70,1,71,1,71,1,72,1,72,1,73,1,
  	73,1,74,1,74,1,75,1,75,5,75,1113,8,75,10,75,12,75,1116,9,75,1,75,1,75,
  	1,76,1,76,1,76,1,77,1,77,1,77,1,78,1,78,1,78,1,79,1,79,1,79,1,80,1,80,
  	1,80,1,81,1,81,1,81,1,82,1,82,3,82,1140,8,82,1,82,1,82,1,82,3,82,1145,
  	8,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1153,8,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,5,82,1161,8,82,10,82,12,82,1164,9,82,1,82,1,82,1,82,1,82,1,
  	82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1183,
  	8,82,1,82,1,82,3,82,1187,8,82,1,82,1,82,1,82,1,82,3,82,1193,8,82,1,82,
  	3,82,1196,8,82,1,82,3,82,1199,8,82,1,82,1,82,1,82,1,82,1,82,3,82,1206,
  	8,82,1,82,1,82,1,82,3,82,1211,8,82,1,82,3,82,1214,8,82,1,82,1,82,1,82,
  	1,82,1,82,3,82,1221,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,3,82,1233,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,5,82,1242,8,82,
  	10,82,12,82,1245,9,82,1,82,3,82,1248,8,82,1,82,3,82,1251,8,82,1,82,1,
  	82,1,82,1,82,1,82,3,82,1258,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,
  	82,1,82,5,82,1269,8,82,10,82,12,82,1272,9,82,1,82,1,82,1,82,1,82,1,82,
  	3,82,1279,8,82,1,82,1,82,1,82,3,82,1284,8,82,1,82,3,82,1287,8,82,1,82,
  	1,82,1,82,1,82,3,82,1293,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,3,82,1304,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1368,8,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,3,82,1377,8,82,1,82,1,82,3,82,1381,8,82,
  	1,82,1,82,1,82,1,82,3,82,1387,8,82,1,82,1,82,3,82,1391,8,82,1,82,1,82,
  	1,82,3,82,1396,8,82,1,82,1,82,1,82,1,82,3,82,1402,8,82,1,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1414,8,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,3,82,1422,8,82,1,82,1,82,1,82,1,82,3,82,1428,8,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1441,8,82,1,82,4,82,
  	1444,8,82,11,82,12,82,1445,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,
  	82,1,82,1,82,1,82,1,82,1,82,3,82,1462,8,82,1,82,1,82,1,82,5,82,1467,8,
  	82,10,82,12,82,1470,9,82,1,82,3,82,1473,8,82,1,82,1,82,1,82,1,82,3,82,
  	1479,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,3,82,1494,8,82,1,82,1,82,3,82,1498,8,82,1,82,1,82,1,82,1,82,3,82,
  	1504,8,82,1,82,1,82,1,82,1,82,3,82,1510,8,82,1,82,3,82,1513,8,82,1,82,
  	3,82,1516,8,82,1,82,1,82,1,82,1,82,3,82,1522,8,82,1,82,1,82,3,82,1526,
  	8,82,1,82,1,82,1,82,1,82,1,82,1,82,5,82,1534,8,82,10,82,12,82,1537,9,
  	82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1545,8,82,1,82,3,82,1548,8,82,1,
  	82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1557,8,82,1,82,1,82,1,82,3,82,1562,
  	8,82,1,82,1,82,1,82,1,82,3,82,1568,8,82,1,82,1,82,1,82,1,82,1,82,3,82,
  	1575,8,82,1,82,3,82,1578,8,82,1,82,1,82,1,82,1,82,3,82,1584,8,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,5,82,1593,8,82,10,82,12,82,1596,9,82,3,
  	82,1598,8,82,1,82,1,82,3,82,1602,8,82,1,82,1,82,1,82,3,82,1607,8,82,1,
  	82,1,82,1,82,3,82,1612,8,82,1,82,1,82,1,82,1,82,1,82,3,82,1619,8,82,1,
  	82,3,82,1622,8,82,1,82,3,82,1625,8,82,1,82,1,82,1,82,1,82,1,82,3,82,1632,
  	8,82,1,82,1,82,1,82,3,82,1637,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	3,82,1646,8,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1654,8,82,1,82,1,82,
  	1,82,1,82,3,82,1660,8,82,1,82,3,82,1663,8,82,1,82,3,82,1666,8,82,1,82,
  	1,82,1,82,1,82,3,82,1672,8,82,1,82,1,82,3,82,1676,8,82,1,82,1,82,3,82,
  	1680,8,82,1,82,1,82,3,82,1684,8,82,3,82,1686,8,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,3,82,1694,8,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1702,8,82,
  	1,82,1,82,1,82,1,82,3,82,1708,8,82,1,82,1,82,1,82,1,82,3,82,1714,8,82,
  	1,82,3,82,1717,8,82,1,82,1,82,3,82,1721,8,82,1,82,3,82,1724,8,82,1,82,
  	1,82,3,82,1728,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,5,82,1751,8,82,
  	10,82,12,82,1754,9,82,3,82,1756,8,82,1,82,1,82,3,82,1760,8,82,1,82,1,
  	82,1,82,1,82,3,82,1766,8,82,1,82,3,82,1769,8,82,1,82,3,82,1772,8,82,1,
  	82,1,82,1,82,1,82,3,82,1778,8,82,1,82,1,82,1,82,1,82,1,82,1,82,3,82,1786,
  	8,82,1,82,1,82,1,82,3,82,1791,8,82,1,82,1,82,1,82,1,82,3,82,1797,8,82,
  	1,82,1,82,1,82,1,82,3,82,1803,8,82,1,82,1,82,1,82,1,82,1,82,1,82,1,82,
  	1,82,5,82,1813,8,82,10,82,12,82,1816,9,82,3,82,1818,8,82,1,82,1,82,1,
  	82,5,82,1823,8,82,10,82,12,82,1826,9,82,1,82,1,82,5,82,1830,8,82,10,82,
  	12,82,1833,9,82,1,82,1,82,1,82,5,82,1838,8,82,10,82,12,82,1841,9,82,3,
  	82,1843,8,82,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1851,8,83,1,83,1,83,3,
  	83,1855,8,83,1,83,1,83,1,83,1,83,1,83,3,83,1862,8,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,
  	83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1978,
  	8,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,1986,8,83,1,83,1,83,1,83,1,83,
  	1,83,1,83,3,83,1994,8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,2003,
  	8,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,1,83,3,83,2013,8,83,1,84,1,84,
  	3,84,2017,8,84,1,84,3,84,2020,8,84,1,84,1,84,1,84,1,84,3,84,2026,8,84,
  	1,84,1,84,1,85,1,85,3,85,2032,8,85,1,85,1,85,1,85,1,85,1,86,1,86,1,86,
  	1,86,1,86,1,86,3,86,2044,8,86,1,86,1,86,1,86,1,86,1,87,1,87,1,87,1,87,
  	1,87,1,87,3,87,2056,8,87,1,87,1,87,1,87,3,87,2061,8,87,1,88,1,88,1,88,
  	1,89,1,89,1,89,1,90,3,90,2070,8,90,1,90,3,90,2073,8,90,1,90,1,90,1,90,
  	1,91,1,91,1,91,3,91,2081,8,91,1,91,1,91,1,91,1,91,1,91,3,91,2088,8,91,
  	3,91,2090,8,91,1,91,1,91,1,91,3,91,2095,8,91,1,91,1,91,3,91,2099,8,91,
  	1,91,1,91,1,91,3,91,2104,8,91,1,91,1,91,1,91,3,91,2109,8,91,1,91,1,91,
  	1,91,3,91,2114,8,91,1,91,3,91,2117,8,91,1,91,1,91,1,91,3,91,2122,8,91,
  	1,91,1,91,3,91,2126,8,91,1,91,1,91,1,91,3,91,2131,8,91,3,91,2133,8,91,
  	1,92,1,92,3,92,2137,8,92,1,93,1,93,1,93,1,93,1,93,5,93,2144,8,93,10,93,
  	12,93,2147,9,93,1,93,1,93,1,94,1,94,1,94,3,94,2154,8,94,1,95,1,95,1,96,
  	1,96,1,96,1,96,1,96,3,96,2163,8,96,1,97,1,97,1,97,5,97,2168,8,97,10,97,
  	12,97,2171,9,97,1,98,1,98,1,98,1,98,5,98,2177,8,98,10,98,12,98,2180,9,
  	98,1,99,1,99,3,99,2184,8,99,1,99,3,99,2187,8,99,1,99,1,99,1,99,1,99,1,
  	100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,1,101,
  	1,101,5,101,2206,8,101,10,101,12,101,2209,9,101,1,102,1,102,1,102,1,102,
  	5,102,2215,8,102,10,102,12,102,2218,9,102,1,102,1,102,1,103,1,103,3,103,
  	2224,8,103,1,103,3,103,2227,8,103,1,104,1,104,1,104,5,104,2232,8,104,
  	10,104,12,104,2235,9,104,1,104,3,104,2238,8,104,1,105,1,105,1,105,1,105,
  	3,105,2244,8,105,1,106,1,106,1,106,1,106,5,106,2250,8,106,10,106,12,106,
  	2253,9,106,1,106,1,106,1,107,1,107,1,107,1,107,5,107,2261,8,107,10,107,
  	12,107,2264,9,107,1,107,1,107,1,108,1,108,1,108,1,108,1,108,1,108,3,108,
  	2274,8,108,1,109,1,109,1,109,1,109,1,109,3,109,2281,8,109,1,110,1,110,
  	1,110,1,110,3,110,2287,8,110,1,111,1,111,1,111,1,112,1,112,1,112,1,112,
  	1,112,1,112,4,112,2298,8,112,11,112,12,112,2299,1,112,1,112,1,112,1,112,
  	1,112,3,112,2307,8,112,1,112,1,112,1,112,1,112,1,112,3,112,2314,8,112,
  	1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,1,112,3,112,2326,
  	8,112,1,112,1,112,1,112,1,112,5,112,2332,8,112,10,112,12,112,2335,9,112,
  	1,112,5,112,2338,8,112,10,112,12,112,2341,9,112,3,112,2343,8,112,1,113,
  	1,113,1,113,1,113,1,113,5,113,2350,8,113,10,113,12,113,2353,9,113,3,113,
  	2355,8,113,1,113,1,113,1,113,1,113,1,113,5,113,2362,8,113,10,113,12,113,
  	2365,9,113,3,113,2367,8,113,1,113,1,113,1,113,1,113,1,113,5,113,2374,
  	8,113,10,113,12,113,2377,9,113,3,113,2379,8,113,1,113,1,113,1,113,1,113,
  	1,113,5,113,2386,8,113,10,113,12,113,2389,9,113,3,113,2391,8,113,1,113,
  	3,113,2394,8,113,1,113,1,113,1,113,3,113,2399,8,113,3,113,2401,8,113,
  	1,114,1,114,1,114,1,115,1,115,1,115,3,115,2409,8,115,1,115,1,115,1,115,
  	3,115,2414,8,115,1,115,1,115,1,115,1,115,3,115,2420,8,115,1,115,1,115,
  	1,115,1,115,3,115,2426,8,115,1,115,5,115,2429,8,115,10,115,12,115,2432,
  	9,115,1,116,1,116,1,116,1,116,1,116,3,116,2439,8,116,1,117,1,117,3,117,
  	2443,8,117,1,117,1,117,3,117,2447,8,117,1,118,1,118,4,118,2451,8,118,
  	11,118,12,118,2452,1,119,1,119,3,119,2457,8,119,1,119,1,119,1,119,1,119,
  	5,119,2463,8,119,10,119,12,119,2466,9,119,1,119,3,119,2469,8,119,1,119,
  	3,119,2472,8,119,1,119,3,119,2475,8,119,1,119,3,119,2478,8,119,1,119,
  	1,119,3,119,2482,8,119,1,120,1,120,1,120,3,120,2487,8,120,1,120,1,120,
  	1,120,5,120,2492,8,120,10,120,12,120,2495,9,120,1,120,3,120,2498,8,120,
  	1,120,3,120,2501,8,120,1,120,3,120,2504,8,120,1,120,3,120,2507,8,120,
  	3,120,2509,8,120,1,121,3,121,2512,8,121,1,122,1,122,1,122,1,122,1,122,
  	1,122,1,122,1,122,1,122,1,122,3,122,2524,8,122,1,122,3,122,2527,8,122,
  	1,122,1,122,3,122,2531,8,122,1,122,1,122,1,122,1,122,1,122,1,122,1,122,
  	1,122,3,122,2541,8,122,1,122,1,122,3,122,2545,8,122,3,122,2547,8,122,
  	1,122,3,122,2550,8,122,1,122,1,122,3,122,2554,8,122,1,123,1,123,5,123,
  	2558,8,123,10,123,12,123,2561,9,123,1,123,3,123,2564,8,123,1,123,1,123,
  	1,124,1,124,1,124,1,125,1,125,1,125,1,125,3,125,2575,8,125,1,125,1,125,
  	1,125,1,126,1,126,1,126,1,126,1,126,3,126,2585,8,126,1,126,1,126,1,126,
  	1,127,1,127,1,127,1,127,1,127,1,127,1,127,3,127,2597,8,127,1,128,1,128,
  	1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,1,128,5,128,2610,8,128,
  	10,128,12,128,2613,9,128,1,128,1,128,3,128,2617,8,128,1,129,1,129,1,129,
  	5,129,2622,8,129,10,129,12,129,2625,9,129,1,130,1,130,1,130,1,130,1,131,
  	1,131,1,131,1,132,1,132,1,132,1,133,1,133,1,133,3,133,2640,8,133,1,133,
  	5,133,2643,8,133,10,133,12,133,2646,9,133,1,133,1,133,1,134,1,134,1,134,
  	1,134,1,134,1,134,5,134,2656,8,134,10,134,12,134,2659,9,134,1,134,1,134,
  	3,134,2663,8,134,1,135,1,135,1,135,1,135,5,135,2669,8,135,10,135,12,135,
  	2672,9,135,1,135,5,135,2675,8,135,10,135,12,135,2678,9,135,1,135,3,135,
  	2681,8,135,1,136,1,136,1,136,1,136,1,136,5,136,2688,8,136,10,136,12,136,
  	2691,9,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,
  	5,136,2703,8,136,10,136,12,136,2706,9,136,1,136,1,136,3,136,2710,8,136,
  	1,136,1,136,1,136,1,136,1,136,1,136,1,136,1,136,5,136,2720,8,136,10,136,
  	12,136,2723,9,136,1,136,1,136,3,136,2727,8,136,1,137,1,137,1,137,1,137,
  	5,137,2733,8,137,10,137,12,137,2736,9,137,3,137,2738,8,137,1,137,1,137,
  	3,137,2742,8,137,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,1,138,
  	1,138,5,138,2754,8,138,10,138,12,138,2757,9,138,1,138,1,138,1,138,1,139,
  	1,139,1,139,1,139,1,139,5,139,2767,8,139,10,139,12,139,2770,9,139,1,139,
  	1,139,3,139,2774,8,139,1,140,1,140,3,140,2778,8,140,1,140,3,140,2781,
  	8,140,1,141,1,141,1,141,3,141,2786,8,141,1,141,1,141,1,141,1,141,1,141,
  	5,141,2793,8,141,10,141,12,141,2796,9,141,3,141,2798,8,141,1,141,1,141,
  	1,141,3,141,2803,8,141,1,141,1,141,1,141,5,141,2808,8,141,10,141,12,141,
  	2811,9,141,3,141,2813,8,141,1,142,1,142,1,143,1,143,5,143,2819,8,143,
  	10,143,12,143,2822,9,143,1,144,1,144,1,144,1,144,3,144,2828,8,144,1,144,
  	1,144,1,144,1,144,1,144,3,144,2835,8,144,1,145,3,145,2838,8,145,1,145,
  	1,145,1,145,3,145,2843,8,145,1,145,3,145,2846,8,145,1,145,1,145,1,145,
  	3,145,2851,8,145,1,145,1,145,3,145,2855,8,145,1,145,3,145,2858,8,145,
  	1,145,3,145,2861,8,145,1,146,1,146,1,146,1,146,3,146,2867,8,146,1,147,
  	1,147,1,147,3,147,2872,8,147,1,147,1,147,1,148,3,148,2877,8,148,1,148,
  	1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,1,148,
  	1,148,1,148,1,148,3,148,2895,8,148,3,148,2897,8,148,1,148,3,148,2900,
  	8,148,1,149,1,149,1,149,1,149,1,150,1,150,1,150,5,150,2909,8,150,10,150,
  	12,150,2912,9,150,1,151,1,151,1,151,1,151,5,151,2918,8,151,10,151,12,
  	151,2921,9,151,1,151,1,151,1,152,1,152,3,152,2927,8,152,1,153,1,153,1,
  	153,1,153,5,153,2933,8,153,10,153,12,153,2936,9,153,1,153,1,153,1,154,
  	1,154,3,154,2942,8,154,1,155,1,155,3,155,2946,8,155,1,155,3,155,2949,
  	8,155,1,155,1,155,1,155,1,155,1,155,1,155,3,155,2957,8,155,1,155,1,155,
  	1,155,1,155,1,155,1,155,3,155,2965,8,155,1,155,1,155,1,155,1,155,3,155,
  	2971,8,155,1,156,1,156,1,156,1,156,5,156,2977,8,156,10,156,12,156,2980,
  	9,156,1,156,1,156,1,157,1,157,1,157,1,157,1,157,5,157,2989,8,157,10,157,
  	12,157,2992,9,157,3,157,2994,8,157,1,157,1,157,1,157,1,158,3,158,3000,
  	8,158,1,158,1,158,3,158,3004,8,158,3,158,3006,8,158,1,159,1,159,1,159,
  	1,159,1,159,1,159,1,159,3,159,3015,8,159,1,159,1,159,1,159,1,159,1,159,
  	1,159,1,159,1,159,1,159,1,159,3,159,3027,8,159,3,159,3029,8,159,1,159,
  	1,159,1,159,1,159,1,159,3,159,3036,8,159,1,159,1,159,1,159,1,159,1,159,
  	3,159,3043,8,159,1,159,1,159,1,159,1,159,3,159,3049,8,159,1,159,1,159,
  	1,159,1,159,3,159,3055,8,159,3,159,3057,8,159,1,160,1,160,1,160,5,160,
  	3062,8,160,10,160,12,160,3065,9,160,1,161,1,161,1,161,5,161,3070,8,161,
  	10,161,12,161,3073,9,161,1,162,1,162,1,162,3,162,3078,8,162,1,162,1,162,
  	1,163,1,163,1,163,3,163,3085,8,163,1,163,1,163,1,164,1,164,3,164,3091,
  	8,164,1,164,1,164,3,164,3095,8,164,3,164,3097,8,164,1,165,1,165,1,165,
  	5,165,3102,8,165,10,165,12,165,3105,9,165,1,166,1,166,1,166,1,166,5,166,
  	3111,8,166,10,166,12,166,3114,9,166,1,166,1,166,1,167,1,167,1,167,1,167,
  	1,167,1,167,5,167,3124,8,167,10,167,12,167,3127,9,167,1,167,1,167,3,167,
  	3131,8,167,1,168,1,168,3,168,3135,8,168,1,169,1,169,1,170,1,170,1,170,
  	1,170,1,170,1,170,1,170,1,170,1,170,1,170,3,170,3149,8,170,3,170,3151,
  	8,170,1,170,1,170,1,170,1,170,1,170,1,170,5,170,3159,8,170,10,170,12,
  	170,3162,9,170,1,171,3,171,3165,8,171,1,171,1,171,1,171,1,171,1,171,1,
  	171,3,171,3173,8,171,1,171,1,171,1,171,1,171,1,171,5,171,3180,8,171,10,
  	171,12,171,3183,9,171,1,171,1,171,1,171,3,171,3188,8,171,1,171,1,171,
  	1,171,1,171,1,171,1,171,3,171,3196,8,171,1,171,1,171,1,171,3,171,3201,
  	8,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,1,171,5,171,3211,8,171,
  	10,171,12,171,3214,9,171,1,171,1,171,3,171,3218,8,171,1,171,3,171,3221,
  	8,171,1,171,1,171,1,171,1,171,3,171,3227,8,171,1,171,1,171,3,171,3231,
  	8,171,1,171,1,171,1,171,3,171,3236,8,171,1,171,1,171,1,171,3,171,3241,
  	8,171,1,171,1,171,1,171,3,171,3246,8,171,1,172,1,172,1,172,1,172,3,172,
  	3252,8,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,
  	1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,1,172,5,172,3273,8,172,
  	10,172,12,172,3276,9,172,1,173,1,173,1,173,1,173,4,173,3282,8,173,11,
  	173,12,173,3283,1,173,1,173,3,173,3288,8,173,1,173,1,173,1,173,1,173,
  	1,173,4,173,3295,8,173,11,173,12,173,3296,1,173,1,173,3,173,3301,8,173,
  	1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,
  	1,173,1,173,5,173,3317,8,173,10,173,12,173,3320,9,173,3,173,3322,8,173,
  	1,173,1,173,1,173,1,173,1,173,1,173,3,173,3330,8,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,3,173,3339,8,173,1,173,1,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,
  	1,173,1,173,4,173,3360,8,173,11,173,12,173,3361,1,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,1,173,3,173,3373,8,173,1,173,1,173,1,173,5,173,
  	3378,8,173,10,173,12,173,3381,9,173,3,173,3383,8,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,3,173,3392,8,173,1,173,1,173,3,173,3396,8,173,
  	1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,4,173,3406,8,173,11,173,
  	12,173,3407,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,
  	1,173,3,173,3433,8,173,1,173,1,173,1,173,1,173,1,173,3,173,3440,8,173,
  	1,173,3,173,3443,8,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,
  	1,173,1,173,1,173,1,173,1,173,3,173,3458,8,173,1,173,1,173,3,173,3462,
  	8,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,1,173,5,173,3472,8,173,
  	10,173,12,173,3475,9,173,1,174,1,174,1,174,1,174,1,174,1,174,1,174,1,
  	174,4,174,3485,8,174,11,174,12,174,3486,3,174,3489,8,174,1,175,1,175,
  	1,175,1,175,1,175,1,175,1,175,1,175,3,175,3499,8,175,1,176,1,176,1,177,
  	1,177,1,178,1,178,1,179,1,179,1,180,1,180,1,180,3,180,3512,8,180,1,181,
  	1,181,3,181,3516,8,181,1,182,1,182,1,182,4,182,3521,8,182,11,182,12,182,
  	3522,1,183,1,183,1,183,3,183,3528,8,183,1,184,1,184,1,184,1,184,1,184,
  	1,185,3,185,3536,8,185,1,185,1,185,3,185,3540,8,185,1,186,1,186,1,186,
  	1,186,1,186,1,186,1,186,3,186,3549,8,186,1,187,1,187,1,187,3,187,3554,
  	8,187,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,1,188,
  	1,188,1,188,1,188,1,188,3,188,3571,8,188,1,188,1,188,3,188,3575,8,188,
  	1,188,1,188,1,188,1,188,1,188,5,188,3582,8,188,10,188,12,188,3585,9,188,
  	1,188,3,188,3588,8,188,3,188,3590,8,188,1,189,1,189,1,189,5,189,3595,
  	8,189,10,189,12,189,3598,9,189,1,190,1,190,1,190,1,190,3,190,3604,8,190,
  	1,190,3,190,3607,8,190,1,190,3,190,3610,8,190,1,191,1,191,1,191,5,191,
  	3615,8,191,10,191,12,191,3618,9,191,1,192,1,192,1,192,1,192,3,192,3624,
  	8,192,1,192,3,192,3627,8,192,1,193,1,193,1,193,5,193,3632,8,193,10,193,
  	12,193,3635,9,193,1,194,1,194,1,194,1,194,1,194,3,194,3642,8,194,1,194,
  	3,194,3645,8,194,1,195,1,195,1,195,1,195,1,195,1,196,1,196,1,196,1,196,
  	5,196,3656,8,196,10,196,12,196,3659,9,196,1,197,1,197,1,197,1,197,1,198,
  	1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,1,198,5,198,3676,
  	8,198,10,198,12,198,3679,9,198,1,198,1,198,1,198,1,198,1,198,5,198,3686,
  	8,198,10,198,12,198,3689,9,198,3,198,3691,8,198,1,198,1,198,1,198,1,198,
  	1,198,5,198,3698,8,198,10,198,12,198,3701,9,198,3,198,3703,8,198,3,198,
  	3705,8,198,1,198,3,198,3708,8,198,1,198,3,198,3711,8,198,1,199,1,199,
  	1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,1,199,
  	1,199,1,199,3,199,3729,8,199,1,200,1,200,1,200,1,200,1,200,1,200,1,200,
  	3,200,3738,8,200,1,201,1,201,1,201,5,201,3743,8,201,10,201,12,201,3746,
  	9,201,1,202,1,202,1,202,1,202,3,202,3752,8,202,1,203,1,203,1,203,5,203,
  	3757,8,203,10,203,12,203,3760,9,203,1,204,1,204,1,205,1,205,4,205,3766,
  	8,205,11,205,12,205,3767,1,206,1,206,3,206,3772,8,206,1,207,1,207,1,207,
  	3,207,3777,8,207,1,208,1,208,1,209,3,209,3782,8,209,1,209,1,209,3,209,
  	3786,8,209,1,209,1,209,3,209,3790,8,209,1,209,1,209,3,209,3794,8,209,
  	1,209,1,209,3,209,3798,8,209,1,209,1,209,3,209,3802,8,209,1,209,1,209,
  	3,209,3806,8,209,1,209,1,209,3,209,3810,8,209,1,209,1,209,3,209,3814,
  	8,209,1,209,3,209,3817,8,209,1,210,1,210,1,210,1,210,1,210,1,210,1,210,
  	3,210,3826,8,210,1,211,1,211,1,212,1,212,1,213,1,213,1,213,5,1752,1814,
  	1824,1831,1839,5,94,230,340,344,346,214,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,0,53,2,0,55,55,
  	60,60,1,0,195,196,1,0,243,244,2,0,135,135,168,168,3,0,36,36,210,210,275,
  	275,1,0,37,39,2,0,2,2,305,305,2,0,329,329,331,331,1,0,19,21,1,0,314,317,
  	2,0,64,64,110,110,2,0,315,315,320,320,3,0,10,11,130,130,282,282,2,0,12,
  	12,195,195,2,0,106,106,221,221,2,0,73,73,235,235,2,0,104,104,191,191,
  	2,0,141,141,154,154,1,0,84,85,2,0,268,268,298,298,2,0,56,56,76,76,5,0,
  	81,81,93,93,127,127,140,140,182,182,1,0,110,111,2,0,127,127,140,140,2,
  	0,195,195,325,325,2,0,53,53,176,176,3,0,103,103,190,190,245,245,4,0,122,
  	122,161,161,254,254,288,288,3,0,122,122,254,254,288,288,2,0,55,55,115,
  	115,3,0,55,55,60,60,258,258,3,0,130,130,282,282,290,290,2,0,314,315,320,
  	320,1,0,316,319,2,0,314,315,323,323,2,0,98,98,100,100,1,0,266,267,2,0,
  	1,1,141,141,2,0,1,1,137,137,3,0,68,68,171,171,277,277,1,0,305,306,1,0,
  	314,324,4,0,58,58,154,154,194,194,202,202,2,0,130,130,282,282,1,0,314,
  	315,2,0,116,116,211,211,2,0,203,203,259,259,2,0,136,136,218,218,1,0,330,
  	331,2,0,117,117,253,253,51,0,53,54,56,57,61,62,64,65,67,67,69,73,76,76,
  	78,81,83,83,85,91,93,93,96,97,102,104,106,114,116,117,121,121,123,129,
  	132,132,134,136,139,140,143,145,148,148,151,153,155,156,158,160,162,162,
  	165,165,167,170,173,186,189,191,193,193,196,197,200,201,204,204,206,207,
  	209,218,220,228,230,236,238,245,249,251,253,253,255,257,259,267,269,273,
  	276,276,278,283,285,287,291,294,297,299,302,302,319,319,15,0,59,59,95,
  	95,122,122,142,142,157,157,161,161,166,166,172,172,192,192,198,198,237,
  	237,248,248,254,254,288,288,296,296,17,0,53,58,60,94,96,121,123,141,143,
  	156,158,160,162,165,167,171,173,191,193,197,199,236,238,247,249,253,255,
  	287,289,295,297,304,319,319,4386,0,429,1,0,0,0,2,435,1,0,0,0,4,444,1,
  	0,0,0,6,447,1,0,0,0,8,473,1,0,0,0,10,475,1,0,0,0,12,487,1,0,0,0,14,496,
  	1,0,0,0,16,516,1,0,0,0,18,523,1,0,0,0,20,530,1,0,0,0,22,541,1,0,0,0,24,
  	554,1,0,0,0,26,561,1,0,0,0,28,574,1,0,0,0,30,592,1,0,0,0,32,605,1,0,0,
  	0,34,608,1,0,0,0,36,616,1,0,0,0,38,628,1,0,0,0,40,665,1,0,0,0,42,667,
  	1,0,0,0,44,685,1,0,0,0,46,702,1,0,0,0,48,713,1,0,0,0,50,718,1,0,0,0,52,
  	722,1,0,0,0,54,724,1,0,0,0,56,726,1,0,0,0,58,728,1,0,0,0,60,774,1,0,0,
  	0,62,776,1,0,0,0,64,793,1,0,0,0,66,795,1,0,0,0,68,813,1,0,0,0,70,815,
  	1,0,0,0,72,827,1,0,0,0,74,829,1,0,0,0,76,836,1,0,0,0,78,839,1,0,0,0,80,
  	841,1,0,0,0,82,850,1,0,0,0,84,859,1,0,0,0,86,871,1,0,0,0,88,881,1,0,0,
  	0,90,906,1,0,0,0,92,908,1,0,0,0,94,916,1,0,0,0,96,936,1,0,0,0,98,944,
  	1,0,0,0,100,946,1,0,0,0,102,954,1,0,0,0,104,962,1,0,0,0,106,966,1,0,0,
  	0,108,968,1,0,0,0,110,976,1,0,0,0,112,992,1,0,0,0,114,1005,1,0,0,0,116,
  	1007,1,0,0,0,118,1015,1,0,0,0,120,1019,1,0,0,0,122,1030,1,0,0,0,124,1032,
  	1,0,0,0,126,1036,1,0,0,0,128,1056,1,0,0,0,130,1058,1,0,0,0,132,1066,1,
  	0,0,0,134,1072,1,0,0,0,136,1090,1,0,0,0,138,1098,1,0,0,0,140,1100,1,0,
  	0,0,142,1102,1,0,0,0,144,1104,1,0,0,0,146,1106,1,0,0,0,148,1108,1,0,0,
  	0,150,1110,1,0,0,0,152,1119,1,0,0,0,154,1122,1,0,0,0,156,1125,1,0,0,0,
  	158,1128,1,0,0,0,160,1131,1,0,0,0,162,1134,1,0,0,0,164,1842,1,0,0,0,166,
  	2012,1,0,0,0,168,2014,1,0,0,0,170,2031,1,0,0,0,172,2037,1,0,0,0,174,2049,
  	1,0,0,0,176,2062,1,0,0,0,178,2065,1,0,0,0,180,2069,1,0,0,0,182,2132,1,
  	0,0,0,184,2134,1,0,0,0,186,2138,1,0,0,0,188,2150,1,0,0,0,190,2155,1,0,
  	0,0,192,2162,1,0,0,0,194,2164,1,0,0,0,196,2172,1,0,0,0,198,2181,1,0,0,
  	0,200,2192,1,0,0,0,202,2207,1,0,0,0,204,2210,1,0,0,0,206,2221,1,0,0,0,
  	208,2237,1,0,0,0,210,2243,1,0,0,0,212,2245,1,0,0,0,214,2256,1,0,0,0,216,
  	2273,1,0,0,0,218,2280,1,0,0,0,220,2282,1,0,0,0,222,2288,1,0,0,0,224,2342,
  	1,0,0,0,226,2354,1,0,0,0,228,2402,1,0,0,0,230,2408,1,0,0,0,232,2438,1,
  	0,0,0,234,2440,1,0,0,0,236,2448,1,0,0,0,238,2481,1,0,0,0,240,2508,1,0,
  	0,0,242,2511,1,0,0,0,244,2523,1,0,0,0,246,2555,1,0,0,0,248,2567,1,0,0,
  	0,250,2570,1,0,0,0,252,2579,1,0,0,0,254,2596,1,0,0,0,256,2616,1,0,0,0,
  	258,2618,1,0,0,0,260,2626,1,0,0,0,262,2630,1,0,0,0,264,2633,1,0,0,0,266,
  	2636,1,0,0,0,268,2662,1,0,0,0,270,2664,1,0,0,0,272,2726,1,0,0,0,274,2741,
  	1,0,0,0,276,2743,1,0,0,0,278,2773,1,0,0,0,280,2775,1,0,0,0,282,2782,1,
  	0,0,0,284,2814,1,0,0,0,286,2816,1,0,0,0,288,2834,1,0,0,0,290,2860,1,0,
  	0,0,292,2866,1,0,0,0,294,2868,1,0,0,0,296,2899,1,0,0,0,298,2901,1,0,0,
  	0,300,2905,1,0,0,0,302,2913,1,0,0,0,304,2924,1,0,0,0,306,2928,1,0,0,0,
  	308,2939,1,0,0,0,310,2970,1,0,0,0,312,2972,1,0,0,0,314,2983,1,0,0,0,316,
  	3005,1,0,0,0,318,3056,1,0,0,0,320,3058,1,0,0,0,322,3066,1,0,0,0,324,3077,
  	1,0,0,0,326,3084,1,0,0,0,328,3088,1,0,0,0,330,3098,1,0,0,0,332,3106,1,
  	0,0,0,334,3130,1,0,0,0,336,3134,1,0,0,0,338,3136,1,0,0,0,340,3150,1,0,
  	0,0,342,3245,1,0,0,0,344,3251,1,0,0,0,346,3461,1,0,0,0,348,3488,1,0,0,
  	0,350,3498,1,0,0,0,352,3500,1,0,0,0,354,3502,1,0,0,0,356,3504,1,0,0,0,
  	358,3506,1,0,0,0,360,3508,1,0,0,0,362,3513,1,0,0,0,364,3520,1,0,0,0,366,
  	3524,1,0,0,0,368,3529,1,0,0,0,370,3539,1,0,0,0,372,3548,1,0,0,0,374,3553,
  	1,0,0,0,376,3589,1,0,0,0,378,3591,1,0,0,0,380,3599,1,0,0,0,382,3611,1,
  	0,0,0,384,3619,1,0,0,0,386,3628,1,0,0,0,388,3636,1,0,0,0,390,3646,1,0,
  	0,0,392,3651,1,0,0,0,394,3660,1,0,0,0,396,3710,1,0,0,0,398,3728,1,0,0,
  	0,400,3737,1,0,0,0,402,3739,1,0,0,0,404,3751,1,0,0,0,406,3753,1,0,0,0,
  	408,3761,1,0,0,0,410,3765,1,0,0,0,412,3771,1,0,0,0,414,3776,1,0,0,0,416,
  	3778,1,0,0,0,418,3816,1,0,0,0,420,3825,1,0,0,0,422,3827,1,0,0,0,424,3829,
  	1,0,0,0,426,3831,1,0,0,0,428,430,3,4,2,0,429,428,1,0,0,0,430,431,1,0,
  	0,0,431,429,1,0,0,0,431,432,1,0,0,0,432,433,1,0,0,0,433,434,5,0,0,1,434,
  	1,1,0,0,0,435,436,3,4,2,0,436,437,5,0,0,1,437,3,1,0,0,0,438,445,3,6,3,
  	0,439,445,3,44,22,0,440,445,3,38,19,0,441,445,3,40,20,0,442,445,3,42,
  	21,0,443,445,3,46,23,0,444,438,1,0,0,0,444,439,1,0,0,0,444,440,1,0,0,
  	0,444,441,1,0,0,0,444,442,1,0,0,0,444,443,1,0,0,0,445,5,1,0,0,0,446,448,
  	3,76,38,0,447,446,1,0,0,0,447,448,1,0,0,0,448,449,1,0,0,0,449,451,3,180,
  	90,0,450,452,3,60,30,0,451,450,1,0,0,0,451,452,1,0,0,0,452,454,1,0,0,
  	0,453,455,3,66,33,0,454,453,1,0,0,0,454,455,1,0,0,0,455,457,1,0,0,0,456,
  	458,3,64,32,0,457,456,1,0,0,0,457,458,1,0,0,0,458,7,1,0,0,0,459,474,3,
  	10,5,0,460,474,3,12,6,0,461,474,3,30,15,0,462,474,3,32,16,0,463,474,3,
  	34,17,0,464,474,3,36,18,0,465,474,3,14,7,0,466,474,3,16,8,0,467,474,3,
  	18,9,0,468,474,3,20,10,0,469,474,3,22,11,0,470,474,3,24,12,0,471,474,
  	3,26,13,0,472,474,3,28,14,0,473,459,1,0,0,0,473,460,1,0,0,0,473,461,1,
  	0,0,0,473,462,1,0,0,0,473,463,1,0,0,0,473,464,1,0,0,0,473,465,1,0,0,0,
  	473,466,1,0,0,0,473,467,1,0,0,0,473,468,1,0,0,0,473,469,1,0,0,0,473,470,
  	1,0,0,0,473,471,1,0,0,0,473,472,1,0,0,0,474,9,1,0,0,0,475,477,5,280,0,
  	0,476,478,3,68,34,0,477,476,1,0,0,0,477,478,1,0,0,0,478,480,1,0,0,0,479,
  	481,3,90,45,0,480,479,1,0,0,0,480,481,1,0,0,0,481,482,1,0,0,0,482,485,
  	3,80,40,0,483,484,5,50,0,0,484,486,3,84,42,0,485,483,1,0,0,0,485,486,
  	1,0,0,0,486,11,1,0,0,0,487,489,5,26,0,0,488,490,3,68,34,0,489,488,1,0,
  	0,0,489,490,1,0,0,0,490,492,1,0,0,0,491,493,3,90,45,0,492,491,1,0,0,0,
  	492,493,1,0,0,0,493,494,1,0,0,0,494,495,3,82,41,0,495,13,1,0,0,0,496,
  	497,5,35,0,0,497,498,5,58,0,0,498,500,5,294,0,0,499,501,3,72,36,0,500,
  	499,1,0,0,0,500,501,1,0,0,0,501,503,1,0,0,0,502,504,3,90,45,0,503,502,
  	1,0,0,0,503,504,1,0,0,0,504,505,1,0,0,0,505,507,3,54,27,0,506,508,3,50,
  	25,0,507,506,1,0,0,0,507,508,1,0,0,0,508,510,1,0,0,0,509,511,3,56,28,
  	0,510,509,1,0,0,0,510,511,1,0,0,0,511,512,1,0,0,0,512,514,3,58,29,0,513,
  	515,3,98,49,0,514,513,1,0,0,0,514,515,1,0,0,0,515,15,1,0,0,0,516,517,
  	5,231,0,0,517,518,5,85,0,0,518,521,3,108,54,0,519,520,5,141,0,0,520,522,
  	3,72,36,0,521,519,1,0,0,0,521,522,1,0,0,0,522,17,1,0,0,0,523,524,5,56,
  	0,0,524,525,5,85,0,0,525,528,3,116,58,0,526,527,5,141,0,0,527,529,3,72,
  	36,0,528,526,1,0,0,0,528,529,1,0,0,0,529,19,1,0,0,0,530,531,5,117,0,0,
  	531,532,5,85,0,0,532,535,3,100,50,0,533,534,5,151,0,0,534,536,5,124,0,
  	0,535,533,1,0,0,0,535,536,1,0,0,0,536,539,1,0,0,0,537,538,5,141,0,0,538,
  	540,3,72,36,0,539,537,1,0,0,0,539,540,1,0,0,0,540,21,1,0,0,0,541,542,
  	5,117,0,0,542,543,5,244,0,0,543,544,5,151,0,0,544,545,7,0,0,0,545,548,
  	7,1,0,0,546,547,5,198,0,0,547,549,3,100,50,0,548,546,1,0,0,0,548,549,
  	1,0,0,0,549,552,1,0,0,0,550,551,5,141,0,0,551,553,3,72,36,0,552,550,1,
  	0,0,0,552,553,1,0,0,0,553,23,1,0,0,0,554,555,5,17,0,0,555,556,7,1,0,0,
  	556,559,3,98,49,0,557,558,5,141,0,0,558,560,3,72,36,0,559,557,1,0,0,0,
  	559,560,1,0,0,0,560,25,1,0,0,0,561,563,5,47,0,0,562,564,5,233,0,0,563,
  	562,1,0,0,0,563,564,1,0,0,0,564,565,1,0,0,0,565,568,3,86,43,0,566,567,
  	5,48,0,0,567,569,5,329,0,0,568,566,1,0,0,0,568,569,1,0,0,0,569,572,1,
  	0,0,0,570,571,5,141,0,0,571,573,3,72,36,0,572,570,1,0,0,0,572,573,1,0,
  	0,0,573,27,1,0,0,0,574,577,5,18,0,0,575,576,5,329,0,0,576,578,7,2,0,0,
  	577,575,1,0,0,0,577,578,1,0,0,0,578,581,1,0,0,0,579,580,5,141,0,0,580,
  	582,3,72,36,0,581,579,1,0,0,0,581,582,1,0,0,0,582,586,1,0,0,0,583,587,
  	3,90,45,0,584,585,5,22,0,0,585,587,3,102,51,0,586,583,1,0,0,0,586,584,
  	1,0,0,0,586,587,1,0,0,0,587,590,1,0,0,0,588,589,7,1,0,0,589,591,7,3,0,
  	0,590,588,1,0,0,0,590,591,1,0,0,0,591,29,1,0,0,0,592,593,5,32,0,0,593,
  	595,3,68,34,0,594,596,3,88,44,0,595,594,1,0,0,0,595,596,1,0,0,0,596,599,
  	1,0,0,0,597,598,5,71,0,0,598,600,3,100,50,0,599,597,1,0,0,0,599,600,1,
  	0,0,0,600,603,1,0,0,0,601,602,5,22,0,0,602,604,3,102,51,0,603,601,1,0,
  	0,0,603,604,1,0,0,0,604,31,1,0,0,0,605,606,5,94,0,0,606,607,3,82,41,0,
  	607,33,1,0,0,0,608,610,5,94,0,0,609,611,5,102,0,0,610,609,1,0,0,0,610,
  	611,1,0,0,0,611,612,1,0,0,0,612,613,3,136,68,0,613,614,5,245,0,0,614,
  	615,3,116,58,0,615,35,1,0,0,0,616,618,5,177,0,0,617,619,3,56,28,0,618,
  	617,1,0,0,0,618,619,1,0,0,0,619,620,1,0,0,0,620,622,3,58,29,0,621,623,
  	3,98,49,0,622,621,1,0,0,0,622,623,1,0,0,0,623,626,1,0,0,0,624,625,5,85,
  	0,0,625,627,3,52,26,0,626,624,1,0,0,0,626,627,1,0,0,0,627,37,1,0,0,0,
  	628,630,5,27,0,0,629,631,3,68,34,0,630,629,1,0,0,0,630,631,1,0,0,0,631,
  	633,1,0,0,0,632,634,3,90,45,0,633,632,1,0,0,0,633,634,1,0,0,0,634,635,
  	1,0,0,0,635,636,5,296,0,0,636,638,3,84,42,0,637,639,3,98,49,0,638,637,
  	1,0,0,0,638,639,1,0,0,0,639,39,1,0,0,0,640,641,5,33,0,0,641,642,5,329,
  	0,0,642,645,7,2,0,0,643,644,5,141,0,0,644,646,3,68,34,0,645,643,1,0,0,
  	0,645,646,1,0,0,0,646,648,1,0,0,0,647,649,5,29,0,0,648,647,1,0,0,0,648,
  	649,1,0,0,0,649,652,1,0,0,0,650,651,5,34,0,0,651,653,5,325,0,0,652,650,
  	1,0,0,0,652,653,1,0,0,0,653,666,1,0,0,0,654,656,5,33,0,0,655,657,3,68,
  	34,0,656,655,1,0,0,0,656,657,1,0,0,0,657,659,1,0,0,0,658,660,5,29,0,0,
  	659,658,1,0,0,0,659,660,1,0,0,0,660,663,1,0,0,0,661,662,5,34,0,0,662,
  	664,5,325,0,0,663,661,1,0,0,0,663,664,1,0,0,0,664,666,1,0,0,0,665,640,
  	1,0,0,0,665,654,1,0,0,0,666,41,1,0,0,0,667,669,5,35,0,0,668,670,3,72,
  	36,0,669,668,1,0,0,0,669,670,1,0,0,0,670,672,1,0,0,0,671,673,3,90,45,
  	0,672,671,1,0,0,0,672,673,1,0,0,0,673,674,1,0,0,0,674,676,3,54,27,0,675,
  	677,3,50,25,0,676,675,1,0,0,0,676,677,1,0,0,0,677,679,1,0,0,0,678,680,
  	3,56,28,0,679,678,1,0,0,0,679,680,1,0,0,0,680,681,1,0,0,0,681,683,3,58,
  	29,0,682,684,3,98,49,0,683,682,1,0,0,0,683,684,1,0,0,0,684,43,1,0,0,0,
  	685,687,5,28,0,0,686,688,3,68,34,0,687,686,1,0,0,0,687,688,1,0,0,0,688,
  	690,1,0,0,0,689,691,3,90,45,0,690,689,1,0,0,0,690,691,1,0,0,0,691,692,
  	1,0,0,0,692,693,5,296,0,0,693,695,3,84,42,0,694,696,3,98,49,0,695,694,
  	1,0,0,0,695,696,1,0,0,0,696,699,1,0,0,0,697,698,5,50,0,0,698,700,3,84,
  	42,0,699,697,1,0,0,0,699,700,1,0,0,0,700,45,1,0,0,0,701,703,3,76,38,0,
  	702,701,1,0,0,0,702,703,1,0,0,0,703,704,1,0,0,0,704,706,5,49,0,0,705,
  	707,3,68,34,0,706,705,1,0,0,0,706,707,1,0,0,0,707,708,1,0,0,0,708,709,
  	5,296,0,0,709,711,3,84,42,0,710,712,3,98,49,0,711,710,1,0,0,0,711,712,
  	1,0,0,0,712,47,1,0,0,0,713,714,5,46,0,0,714,716,3,84,42,0,715,717,3,98,
  	49,0,716,715,1,0,0,0,716,717,1,0,0,0,717,49,1,0,0,0,718,719,5,40,0,0,
  	719,51,1,0,0,0,720,723,3,116,58,0,721,723,3,100,50,0,722,720,1,0,0,0,
  	722,721,1,0,0,0,723,53,1,0,0,0,724,725,7,4,0,0,725,55,1,0,0,0,726,727,
  	7,5,0,0,727,57,1,0,0,0,728,729,5,325,0,0,729,59,1,0,0,0,730,732,5,170,
  	0,0,731,730,1,0,0,0,731,732,1,0,0,0,732,736,1,0,0,0,733,737,5,23,0,0,
  	734,735,5,42,0,0,735,737,5,41,0,0,736,733,1,0,0,0,736,734,1,0,0,0,737,
  	739,1,0,0,0,738,740,3,98,49,0,739,738,1,0,0,0,739,740,1,0,0,0,740,775,
  	1,0,0,0,741,743,5,170,0,0,742,741,1,0,0,0,742,743,1,0,0,0,743,745,1,0,
  	0,0,744,746,5,43,0,0,745,744,1,0,0,0,745,746,1,0,0,0,746,747,1,0,0,0,
  	747,749,5,41,0,0,748,750,3,90,45,0,749,748,1,0,0,0,749,750,1,0,0,0,750,
  	752,1,0,0,0,751,753,3,50,25,0,752,751,1,0,0,0,752,753,1,0,0,0,753,755,
  	1,0,0,0,754,756,3,98,49,0,755,754,1,0,0,0,755,756,1,0,0,0,756,775,1,0,
  	0,0,757,759,5,170,0,0,758,757,1,0,0,0,758,759,1,0,0,0,759,760,1,0,0,0,
  	760,761,5,44,0,0,761,763,5,41,0,0,762,764,3,62,31,0,763,762,1,0,0,0,763,
  	764,1,0,0,0,764,766,1,0,0,0,765,767,3,90,45,0,766,765,1,0,0,0,766,767,
  	1,0,0,0,767,769,1,0,0,0,768,770,3,50,25,0,769,768,1,0,0,0,769,770,1,0,
  	0,0,770,772,1,0,0,0,771,773,3,98,49,0,772,771,1,0,0,0,772,773,1,0,0,0,
  	773,775,1,0,0,0,774,731,1,0,0,0,774,742,1,0,0,0,774,758,1,0,0,0,775,61,
  	1,0,0,0,776,777,5,325,0,0,777,63,1,0,0,0,778,779,5,45,0,0,779,782,5,52,
  	0,0,780,781,5,63,0,0,781,783,3,148,74,0,782,780,1,0,0,0,782,783,1,0,0,
  	0,783,794,1,0,0,0,784,786,5,45,0,0,785,787,5,178,0,0,786,785,1,0,0,0,
  	786,787,1,0,0,0,787,788,1,0,0,0,788,791,5,51,0,0,789,790,5,63,0,0,790,
  	792,3,148,74,0,791,789,1,0,0,0,791,792,1,0,0,0,792,794,1,0,0,0,793,778,
  	1,0,0,0,793,784,1,0,0,0,794,65,1,0,0,0,795,796,5,24,0,0,796,67,1,0,0,
  	0,797,802,3,72,36,0,798,799,5,1,0,0,799,801,3,72,36,0,800,798,1,0,0,0,
  	801,804,1,0,0,0,802,800,1,0,0,0,802,803,1,0,0,0,803,814,1,0,0,0,804,802,
  	1,0,0,0,805,810,3,70,35,0,806,807,5,1,0,0,807,809,3,70,35,0,808,806,1,
  	0,0,0,809,812,1,0,0,0,810,808,1,0,0,0,810,811,1,0,0,0,811,814,1,0,0,0,
  	812,810,1,0,0,0,813,797,1,0,0,0,813,805,1,0,0,0,814,69,1,0,0,0,815,816,
  	3,148,74,0,816,817,7,6,0,0,817,818,3,72,36,0,818,71,1,0,0,0,819,821,3,
  	148,74,0,820,822,3,74,37,0,821,820,1,0,0,0,821,822,1,0,0,0,822,828,1,
  	0,0,0,823,824,5,3,0,0,824,825,3,6,3,0,825,826,5,4,0,0,826,828,1,0,0,0,
  	827,819,1,0,0,0,827,823,1,0,0,0,828,73,1,0,0,0,829,832,5,5,0,0,830,833,
  	5,329,0,0,831,833,3,148,74,0,832,830,1,0,0,0,832,831,1,0,0,0,833,834,
  	1,0,0,0,834,835,5,6,0,0,835,75,1,0,0,0,836,837,3,148,74,0,837,838,3,78,
  	39,0,838,77,1,0,0,0,839,840,5,305,0,0,840,79,1,0,0,0,841,842,5,296,0,
  	0,842,844,3,84,42,0,843,845,3,98,49,0,844,843,1,0,0,0,844,845,1,0,0,0,
  	845,848,1,0,0,0,846,847,5,245,0,0,847,849,3,110,55,0,848,846,1,0,0,0,
  	848,849,1,0,0,0,849,81,1,0,0,0,850,851,5,296,0,0,851,853,3,84,42,0,852,
  	854,3,98,49,0,853,852,1,0,0,0,853,854,1,0,0,0,854,857,1,0,0,0,855,856,
  	5,245,0,0,856,858,3,116,58,0,857,855,1,0,0,0,857,858,1,0,0,0,858,83,1,
  	0,0,0,859,864,3,148,74,0,860,861,5,7,0,0,861,863,3,148,74,0,862,860,1,
  	0,0,0,863,866,1,0,0,0,864,862,1,0,0,0,864,865,1,0,0,0,865,85,1,0,0,0,
  	866,864,1,0,0,0,867,868,7,7,0,0,868,872,5,214,0,0,869,870,5,329,0,0,870,
  	872,5,244,0,0,871,867,1,0,0,0,871,869,1,0,0,0,872,87,1,0,0,0,873,882,
  	5,95,0,0,874,882,5,157,0,0,875,876,5,172,0,0,876,882,5,205,0,0,877,878,
  	5,237,0,0,878,882,5,205,0,0,879,880,5,142,0,0,880,882,5,205,0,0,881,873,
  	1,0,0,0,881,874,1,0,0,0,881,875,1,0,0,0,881,877,1,0,0,0,881,879,1,0,0,
  	0,882,89,1,0,0,0,883,885,3,92,46,0,884,883,1,0,0,0,884,885,1,0,0,0,885,
  	886,1,0,0,0,886,887,5,31,0,0,887,890,3,94,47,0,888,889,5,71,0,0,889,891,
  	3,100,50,0,890,888,1,0,0,0,890,891,1,0,0,0,891,894,1,0,0,0,892,893,5,
  	22,0,0,893,895,3,102,51,0,894,892,1,0,0,0,894,895,1,0,0,0,895,907,1,0,
  	0,0,896,898,3,92,46,0,897,896,1,0,0,0,897,898,1,0,0,0,898,899,1,0,0,0,
  	899,900,5,31,0,0,900,901,5,71,0,0,901,904,3,100,50,0,902,903,5,22,0,0,
  	903,905,3,102,51,0,904,902,1,0,0,0,904,905,1,0,0,0,905,907,1,0,0,0,906,
  	884,1,0,0,0,906,897,1,0,0,0,907,91,1,0,0,0,908,909,7,8,0,0,909,93,1,0,
  	0,0,910,911,6,47,-1,0,911,917,3,96,48,0,912,913,5,3,0,0,913,914,3,94,
  	47,0,914,915,5,4,0,0,915,917,1,0,0,0,916,910,1,0,0,0,916,912,1,0,0,0,
  	917,923,1,0,0,0,918,919,10,1,0,0,919,920,7,9,0,0,920,922,3,94,47,2,921,
  	918,1,0,0,0,922,925,1,0,0,0,923,921,1,0,0,0,923,924,1,0,0,0,924,95,1,
  	0,0,0,925,923,1,0,0,0,926,928,5,315,0,0,927,926,1,0,0,0,927,928,1,0,0,
  	0,928,929,1,0,0,0,929,937,5,331,0,0,930,932,5,315,0,0,931,930,1,0,0,0,
  	931,932,1,0,0,0,932,933,1,0,0,0,933,937,5,329,0,0,934,937,5,29,0,0,935,
  	937,5,30,0,0,936,927,1,0,0,0,936,931,1,0,0,0,936,934,1,0,0,0,936,935,
  	1,0,0,0,937,97,1,0,0,0,938,939,5,25,0,0,939,945,3,130,65,0,940,942,5,
  	25,0,0,941,940,1,0,0,0,941,942,1,0,0,0,942,943,1,0,0,0,943,945,3,128,
  	64,0,944,938,1,0,0,0,944,941,1,0,0,0,945,99,1,0,0,0,946,951,3,106,53,
  	0,947,948,5,1,0,0,948,950,3,106,53,0,949,947,1,0,0,0,950,953,1,0,0,0,
  	951,949,1,0,0,0,951,952,1,0,0,0,952,101,1,0,0,0,953,951,1,0,0,0,954,959,
  	3,104,52,0,955,956,5,1,0,0,956,958,3,104,52,0,957,955,1,0,0,0,958,961,
  	1,0,0,0,959,957,1,0,0,0,959,960,1,0,0,0,960,103,1,0,0,0,961,959,1,0,0,
  	0,962,964,3,106,53,0,963,965,7,10,0,0,964,963,1,0,0,0,964,965,1,0,0,0,
  	965,105,1,0,0,0,966,967,3,148,74,0,967,107,1,0,0,0,968,973,3,124,62,0,
  	969,970,5,1,0,0,970,972,3,124,62,0,971,969,1,0,0,0,972,975,1,0,0,0,973,
  	971,1,0,0,0,973,974,1,0,0,0,974,109,1,0,0,0,975,973,1,0,0,0,976,981,3,
  	112,56,0,977,978,5,1,0,0,978,980,3,112,56,0,979,977,1,0,0,0,980,983,1,
  	0,0,0,981,979,1,0,0,0,981,982,1,0,0,0,982,987,1,0,0,0,983,981,1,0,0,0,
  	984,986,3,114,57,0,985,984,1,0,0,0,986,989,1,0,0,0,987,985,1,0,0,0,987,
  	988,1,0,0,0,988,111,1,0,0,0,989,987,1,0,0,0,990,993,3,118,59,0,991,993,
  	5,316,0,0,992,990,1,0,0,0,992,991,1,0,0,0,993,113,1,0,0,0,994,995,7,11,
  	0,0,995,1000,3,120,60,0,996,997,5,1,0,0,997,999,3,120,60,0,998,996,1,
  	0,0,0,999,1002,1,0,0,0,1000,998,1,0,0,0,1000,1001,1,0,0,0,1001,1006,1,
  	0,0,0,1002,1000,1,0,0,0,1003,1004,5,314,0,0,1004,1006,3,116,58,0,1005,
  	994,1,0,0,0,1005,1003,1,0,0,0,1006,115,1,0,0,0,1007,1012,3,118,59,0,1008,
  	1009,5,1,0,0,1009,1011,3,118,59,0,1010,1008,1,0,0,0,1011,1014,1,0,0,0,
  	1012,1010,1,0,0,0,1012,1013,1,0,0,0,1013,117,1,0,0,0,1014,1012,1,0,0,
  	0,1015,1016,3,120,60,0,1016,1017,5,2,0,0,1017,1018,3,122,61,0,1018,119,
  	1,0,0,0,1019,1020,3,148,74,0,1020,121,1,0,0,0,1021,1031,3,148,74,0,1022,
  	1023,5,5,0,0,1023,1024,3,122,61,0,1024,1025,5,6,0,0,1025,1031,1,0,0,0,
  	1026,1027,5,8,0,0,1027,1028,3,116,58,0,1028,1029,5,9,0,0,1029,1031,1,
  	0,0,0,1030,1021,1,0,0,0,1030,1022,1,0,0,0,1030,1026,1,0,0,0,1031,123,
  	1,0,0,0,1032,1033,3,120,60,0,1033,1034,5,2,0,0,1034,1035,3,120,60,0,1035,
  	125,1,0,0,0,1036,1037,3,138,69,0,1037,127,1,0,0,0,1038,1039,5,8,0,0,1039,
  	1041,3,130,65,0,1040,1042,5,1,0,0,1041,1040,1,0,0,0,1041,1042,1,0,0,0,
  	1042,1043,1,0,0,0,1043,1044,5,9,0,0,1044,1057,1,0,0,0,1045,1046,5,8,0,
  	0,1046,1057,5,9,0,0,1047,1048,5,3,0,0,1048,1050,3,130,65,0,1049,1051,
  	5,1,0,0,1050,1049,1,0,0,0,1050,1051,1,0,0,0,1051,1052,1,0,0,0,1052,1053,
  	5,4,0,0,1053,1057,1,0,0,0,1054,1055,5,3,0,0,1055,1057,5,4,0,0,1056,1038,
  	1,0,0,0,1056,1045,1,0,0,0,1056,1047,1,0,0,0,1056,1054,1,0,0,0,1057,129,
  	1,0,0,0,1058,1063,3,132,66,0,1059,1060,5,1,0,0,1060,1062,3,132,66,0,1061,
  	1059,1,0,0,0,1062,1065,1,0,0,0,1063,1061,1,0,0,0,1063,1064,1,0,0,0,1064,
  	131,1,0,0,0,1065,1063,1,0,0,0,1066,1067,3,134,67,0,1067,1068,7,6,0,0,
  	1068,1069,3,138,69,0,1069,133,1,0,0,0,1070,1073,3,148,74,0,1071,1073,
  	3,142,71,0,1072,1070,1,0,0,0,1072,1071,1,0,0,0,1073,135,1,0,0,0,1074,
  	1075,5,5,0,0,1075,1080,3,138,69,0,1076,1077,5,1,0,0,1077,1079,3,138,69,
  	0,1078,1076,1,0,0,0,1079,1082,1,0,0,0,1080,1078,1,0,0,0,1080,1081,1,0,
  	0,0,1081,1084,1,0,0,0,1082,1080,1,0,0,0,1083,1085,5,1,0,0,1084,1083,1,
  	0,0,0,1084,1085,1,0,0,0,1085,1086,1,0,0,0,1086,1087,5,6,0,0,1087,1091,
  	1,0,0,0,1088,1089,5,5,0,0,1089,1091,5,6,0,0,1090,1074,1,0,0,0,1090,1088,
  	1,0,0,0,1091,137,1,0,0,0,1092,1099,3,142,71,0,1093,1099,3,140,70,0,1094,
  	1099,3,128,64,0,1095,1099,3,136,68,0,1096,1099,3,144,72,0,1097,1099,3,
  	146,73,0,1098,1092,1,0,0,0,1098,1093,1,0,0,0,1098,1094,1,0,0,0,1098,1095,
  	1,0,0,0,1098,1096,1,0,0,0,1098,1097,1,0,0,0,1099,139,1,0,0,0,1100,1101,
  	3,418,209,0,1101,141,1,0,0,0,1102,1103,5,325,0,0,1103,143,1,0,0,0,1104,
  	1105,7,12,0,0,1105,145,1,0,0,0,1106,1107,7,13,0,0,1107,147,1,0,0,0,1108,
  	1109,3,412,206,0,1109,149,1,0,0,0,1110,1114,3,164,82,0,1111,1113,5,13,
  	0,0,1112,1111,1,0,0,0,1113,1116,1,0,0,0,1114,1112,1,0,0,0,1114,1115,1,
  	0,0,0,1115,1117,1,0,0,0,1116,1114,1,0,0,0,1117,1118,5,0,0,1,1118,151,
  	1,0,0,0,1119,1120,3,328,164,0,1120,1121,5,0,0,1,1121,153,1,0,0,0,1122,
  	1123,3,324,162,0,1123,1124,5,0,0,1,1124,155,1,0,0,0,1125,1126,3,322,161,
  	0,1126,1127,5,0,0,1,1127,157,1,0,0,0,1128,1129,3,326,163,0,1129,1130,
  	5,0,0,1,1130,159,1,0,0,0,1131,1132,3,376,188,0,1132,1133,5,0,0,1,1133,
  	161,1,0,0,0,1134,1135,3,382,191,0,1135,1136,5,0,0,1,1136,163,1,0,0,0,
  	1137,1843,3,180,90,0,1138,1140,3,196,98,0,1139,1138,1,0,0,0,1139,1140,
  	1,0,0,0,1140,1141,1,0,0,0,1141,1843,3,224,112,0,1142,1144,5,294,0,0,1143,
  	1145,5,190,0,0,1144,1143,1,0,0,0,1144,1145,1,0,0,0,1145,1146,1,0,0,0,
  	1146,1843,3,322,161,0,1147,1148,5,94,0,0,1148,1152,3,190,95,0,1149,1150,
  	5,151,0,0,1150,1151,5,194,0,0,1151,1153,5,124,0,0,1152,1149,1,0,0,0,1152,
  	1153,1,0,0,0,1153,1154,1,0,0,0,1154,1162,3,322,161,0,1155,1161,3,178,
  	89,0,1156,1161,3,176,88,0,1157,1158,5,303,0,0,1158,1159,7,14,0,0,1159,
  	1161,3,204,102,0,1160,1155,1,0,0,0,1160,1156,1,0,0,0,1160,1157,1,0,0,
  	0,1161,1164,1,0,0,0,1162,1160,1,0,0,0,1162,1163,1,0,0,0,1163,1843,1,0,
  	0,0,1164,1162,1,0,0,0,1165,1166,5,56,0,0,1166,1167,3,190,95,0,1167,1168,
  	3,322,161,0,1168,1169,5,253,0,0,1169,1170,7,14,0,0,1170,1171,3,204,102,
  	0,1171,1843,1,0,0,0,1172,1173,5,56,0,0,1173,1174,3,190,95,0,1174,1175,
  	3,322,161,0,1175,1176,5,253,0,0,1176,1177,3,176,88,0,1177,1843,1,0,0,
  	0,1178,1179,5,117,0,0,1179,1182,3,190,95,0,1180,1181,5,151,0,0,1181,1183,
  	5,124,0,0,1182,1180,1,0,0,0,1182,1183,1,0,0,0,1183,1184,1,0,0,0,1184,
  	1186,3,322,161,0,1185,1187,7,15,0,0,1186,1185,1,0,0,0,1186,1187,1,0,0,
  	0,1187,1843,1,0,0,0,1188,1189,5,256,0,0,1189,1192,7,16,0,0,1190,1191,
  	7,17,0,0,1191,1193,3,322,161,0,1192,1190,1,0,0,0,1192,1193,1,0,0,0,1193,
  	1198,1,0,0,0,1194,1196,5,173,0,0,1195,1194,1,0,0,0,1195,1196,1,0,0,0,
  	1196,1197,1,0,0,0,1197,1199,5,325,0,0,1198,1195,1,0,0,0,1198,1199,1,0,
  	0,0,1199,1843,1,0,0,0,1200,1205,3,168,84,0,1201,1202,5,3,0,0,1202,1203,
  	3,382,191,0,1203,1204,5,4,0,0,1204,1206,1,0,0,0,1205,1201,1,0,0,0,1205,
  	1206,1,0,0,0,1206,1207,1,0,0,0,1207,1208,3,200,100,0,1208,1213,3,202,
  	101,0,1209,1211,5,63,0,0,1210,1209,1,0,0,0,1210,1211,1,0,0,0,1211,1212,
  	1,0,0,0,1212,1214,3,180,90,0,1213,1210,1,0,0,0,1213,1214,1,0,0,0,1214,
  	1843,1,0,0,0,1215,1220,3,168,84,0,1216,1217,5,3,0,0,1217,1218,3,382,191,
  	0,1218,1219,5,4,0,0,1219,1221,1,0,0,0,1220,1216,1,0,0,0,1220,1221,1,0,
  	0,0,1221,1243,1,0,0,0,1222,1242,3,178,89,0,1223,1224,5,212,0,0,1224,1225,
  	5,71,0,0,1225,1226,5,3,0,0,1226,1227,3,382,191,0,1227,1228,5,4,0,0,1228,
  	1233,1,0,0,0,1229,1230,5,212,0,0,1230,1231,5,71,0,0,1231,1233,3,298,149,
  	0,1232,1223,1,0,0,0,1232,1229,1,0,0,0,1233,1242,1,0,0,0,1234,1242,3,172,
  	86,0,1235,1242,3,174,87,0,1236,1242,3,318,159,0,1237,1242,3,216,108,0,
  	1238,1242,3,176,88,0,1239,1240,5,271,0,0,1240,1242,3,204,102,0,1241,1222,
  	1,0,0,0,1241,1232,1,0,0,0,1241,1234,1,0,0,0,1241,1235,1,0,0,0,1241,1236,
  	1,0,0,0,1241,1237,1,0,0,0,1241,1238,1,0,0,0,1241,1239,1,0,0,0,1242,1245,
  	1,0,0,0,1243,1241,1,0,0,0,1243,1244,1,0,0,0,1244,1250,1,0,0,0,1245,1243,
  	1,0,0,0,1246,1248,5,63,0,0,1247,1246,1,0,0,0,1247,1248,1,0,0,0,1248,1249,
  	1,0,0,0,1249,1251,3,180,90,0,1250,1247,1,0,0,0,1250,1251,1,0,0,0,1251,
  	1843,1,0,0,0,1252,1253,5,94,0,0,1253,1257,5,268,0,0,1254,1255,5,151,0,
  	0,1255,1256,5,194,0,0,1256,1258,5,124,0,0,1257,1254,1,0,0,0,1257,1258,
  	1,0,0,0,1258,1259,1,0,0,0,1259,1260,3,324,162,0,1260,1261,5,173,0,0,1261,
  	1270,3,324,162,0,1262,1269,3,200,100,0,1263,1269,3,318,159,0,1264,1269,
  	3,216,108,0,1265,1269,3,176,88,0,1266,1267,5,271,0,0,1267,1269,3,204,
  	102,0,1268,1262,1,0,0,0,1268,1263,1,0,0,0,1268,1264,1,0,0,0,1268,1265,
  	1,0,0,0,1268,1266,1,0,0,0,1269,1272,1,0,0,0,1270,1268,1,0,0,0,1270,1271,
  	1,0,0,0,1271,1843,1,0,0,0,1272,1270,1,0,0,0,1273,1278,3,170,85,0,1274,
  	1275,5,3,0,0,1275,1276,3,382,191,0,1276,1277,5,4,0,0,1277,1279,1,0,0,
  	0,1278,1274,1,0,0,0,1278,1279,1,0,0,0,1279,1280,1,0,0,0,1280,1281,3,200,
  	100,0,1281,1286,3,202,101,0,1282,1284,5,63,0,0,1283,1282,1,0,0,0,1283,
  	1284,1,0,0,0,1284,1285,1,0,0,0,1285,1287,3,180,90,0,1286,1283,1,0,0,0,
  	1286,1287,1,0,0,0,1287,1843,1,0,0,0,1288,1289,5,57,0,0,1289,1290,5,268,
  	0,0,1290,1292,3,322,161,0,1291,1293,3,186,93,0,1292,1291,1,0,0,0,1292,
  	1293,1,0,0,0,1293,1294,1,0,0,0,1294,1295,5,90,0,0,1295,1303,5,262,0,0,
  	1296,1304,3,412,206,0,1297,1298,5,137,0,0,1298,1299,5,85,0,0,1299,1304,
  	3,300,150,0,1300,1301,5,137,0,0,1301,1302,5,55,0,0,1302,1304,5,85,0,0,
  	1303,1296,1,0,0,0,1303,1297,1,0,0,0,1303,1300,1,0,0,0,1303,1304,1,0,0,
  	0,1304,1843,1,0,0,0,1305,1306,5,56,0,0,1306,1307,5,268,0,0,1307,1308,
  	3,322,161,0,1308,1309,5,53,0,0,1309,1310,7,18,0,0,1310,1311,3,378,189,
  	0,1311,1843,1,0,0,0,1312,1313,5,56,0,0,1313,1314,5,268,0,0,1314,1315,
  	3,322,161,0,1315,1316,5,53,0,0,1316,1317,7,18,0,0,1317,1318,5,3,0,0,1318,
  	1319,3,378,189,0,1319,1320,5,4,0,0,1320,1843,1,0,0,0,1321,1322,5,56,0,
  	0,1322,1323,5,268,0,0,1323,1324,3,322,161,0,1324,1325,5,231,0,0,1325,
  	1326,5,84,0,0,1326,1327,3,322,161,0,1327,1328,5,275,0,0,1328,1329,3,408,
  	204,0,1329,1843,1,0,0,0,1330,1331,5,56,0,0,1331,1332,5,268,0,0,1332,1333,
  	3,322,161,0,1333,1334,5,117,0,0,1334,1335,7,18,0,0,1335,1336,5,3,0,0,
  	1336,1337,3,320,160,0,1337,1338,5,4,0,0,1338,1843,1,0,0,0,1339,1340,5,
  	56,0,0,1340,1341,5,268,0,0,1341,1342,3,322,161,0,1342,1343,5,117,0,0,
  	1343,1344,7,18,0,0,1344,1345,3,320,160,0,1345,1843,1,0,0,0,1346,1347,
  	5,56,0,0,1347,1348,7,19,0,0,1348,1349,3,322,161,0,1349,1350,5,231,0,0,
  	1350,1351,5,275,0,0,1351,1352,3,322,161,0,1352,1843,1,0,0,0,1353,1354,
  	5,56,0,0,1354,1355,7,19,0,0,1355,1356,3,322,161,0,1356,1357,5,253,0,0,
  	1357,1358,5,271,0,0,1358,1359,3,204,102,0,1359,1843,1,0,0,0,1360,1361,
  	5,56,0,0,1361,1362,7,19,0,0,1362,1363,3,322,161,0,1363,1364,5,292,0,0,
  	1364,1367,5,271,0,0,1365,1366,5,151,0,0,1366,1368,5,124,0,0,1367,1365,
  	1,0,0,0,1367,1368,1,0,0,0,1368,1369,1,0,0,0,1369,1370,3,204,102,0,1370,
  	1843,1,0,0,0,1371,1372,5,56,0,0,1372,1373,5,268,0,0,1373,1374,3,322,161,
  	0,1374,1376,7,20,0,0,1375,1377,5,84,0,0,1376,1375,1,0,0,0,1376,1377,1,
  	0,0,0,1377,1378,1,0,0,0,1378,1380,3,322,161,0,1379,1381,3,420,210,0,1380,
  	1379,1,0,0,0,1380,1381,1,0,0,0,1381,1843,1,0,0,0,1382,1383,5,56,0,0,1383,
  	1384,5,268,0,0,1384,1386,3,322,161,0,1385,1387,3,186,93,0,1386,1385,1,
  	0,0,0,1386,1387,1,0,0,0,1387,1388,1,0,0,0,1388,1390,5,76,0,0,1389,1391,
  	5,84,0,0,1390,1389,1,0,0,0,1390,1391,1,0,0,0,1391,1392,1,0,0,0,1392,1393,
  	3,322,161,0,1393,1395,3,384,192,0,1394,1396,3,374,187,0,1395,1394,1,0,
  	0,0,1395,1396,1,0,0,0,1396,1843,1,0,0,0,1397,1398,5,56,0,0,1398,1399,
  	5,268,0,0,1399,1401,3,322,161,0,1400,1402,3,186,93,0,1401,1400,1,0,0,
  	0,1401,1402,1,0,0,0,1402,1403,1,0,0,0,1403,1404,5,233,0,0,1404,1405,5,
  	85,0,0,1405,1406,5,3,0,0,1406,1407,3,378,189,0,1407,1408,5,4,0,0,1408,
  	1843,1,0,0,0,1409,1410,5,56,0,0,1410,1411,5,268,0,0,1411,1413,3,322,161,
  	0,1412,1414,3,186,93,0,1413,1412,1,0,0,0,1413,1414,1,0,0,0,1414,1415,
  	1,0,0,0,1415,1416,5,253,0,0,1416,1417,5,250,0,0,1417,1421,5,325,0,0,1418,
  	1419,5,303,0,0,1419,1420,5,251,0,0,1420,1422,3,204,102,0,1421,1418,1,
  	0,0,0,1421,1422,1,0,0,0,1422,1843,1,0,0,0,1423,1424,5,56,0,0,1424,1425,
  	5,268,0,0,1425,1427,3,322,161,0,1426,1428,3,186,93,0,1427,1426,1,0,0,
  	0,1427,1428,1,0,0,0,1428,1429,1,0,0,0,1429,1430,5,253,0,0,1430,1431,5,
  	251,0,0,1431,1432,3,204,102,0,1432,1843,1,0,0,0,1433,1434,5,56,0,0,1434,
  	1435,7,19,0,0,1435,1436,3,322,161,0,1436,1440,5,53,0,0,1437,1438,5,151,
  	0,0,1438,1439,5,194,0,0,1439,1441,5,124,0,0,1440,1437,1,0,0,0,1440,1441,
  	1,0,0,0,1441,1443,1,0,0,0,1442,1444,3,184,92,0,1443,1442,1,0,0,0,1444,
  	1445,1,0,0,0,1445,1443,1,0,0,0,1445,1446,1,0,0,0,1446,1843,1,0,0,0,1447,
  	1448,5,56,0,0,1448,1449,5,268,0,0,1449,1450,3,322,161,0,1450,1451,3,186,
  	93,0,1451,1452,5,231,0,0,1452,1453,5,275,0,0,1453,1454,3,186,93,0,1454,
  	1843,1,0,0,0,1455,1456,5,56,0,0,1456,1457,7,19,0,0,1457,1458,3,322,161,
  	0,1458,1461,5,117,0,0,1459,1460,5,151,0,0,1460,1462,5,124,0,0,1461,1459,
  	1,0,0,0,1461,1462,1,0,0,0,1462,1463,1,0,0,0,1463,1468,3,186,93,0,1464,
  	1465,5,1,0,0,1465,1467,3,186,93,0,1466,1464,1,0,0,0,1467,1470,1,0,0,0,
  	1468,1466,1,0,0,0,1468,1469,1,0,0,0,1469,1472,1,0,0,0,1470,1468,1,0,0,
  	0,1471,1473,5,222,0,0,1472,1471,1,0,0,0,1472,1473,1,0,0,0,1473,1843,1,
  	0,0,0,1474,1475,5,56,0,0,1475,1476,5,268,0,0,1476,1478,3,322,161,0,1477,
  	1479,3,186,93,0,1478,1477,1,0,0,0,1478,1479,1,0,0,0,1479,1480,1,0,0,0,
  	1480,1481,5,253,0,0,1481,1482,3,176,88,0,1482,1843,1,0,0,0,1483,1484,
  	5,56,0,0,1484,1485,5,268,0,0,1485,1486,3,322,161,0,1486,1487,5,227,0,
  	0,1487,1488,5,213,0,0,1488,1843,1,0,0,0,1489,1490,5,117,0,0,1490,1493,
  	5,268,0,0,1491,1492,5,151,0,0,1492,1494,5,124,0,0,1493,1491,1,0,0,0,1493,
  	1494,1,0,0,0,1494,1495,1,0,0,0,1495,1497,3,322,161,0,1496,1498,5,222,
  	0,0,1497,1496,1,0,0,0,1497,1498,1,0,0,0,1498,1843,1,0,0,0,1499,1500,5,
  	117,0,0,1500,1503,5,298,0,0,1501,1502,5,151,0,0,1502,1504,5,124,0,0,1503,
  	1501,1,0,0,0,1503,1504,1,0,0,0,1504,1505,1,0,0,0,1505,1843,3,322,161,
  	0,1506,1509,5,94,0,0,1507,1508,5,202,0,0,1508,1510,5,233,0,0,1509,1507,
  	1,0,0,0,1509,1510,1,0,0,0,1510,1515,1,0,0,0,1511,1513,5,145,0,0,1512,
  	1511,1,0,0,0,1512,1513,1,0,0,0,1513,1514,1,0,0,0,1514,1516,5,272,0,0,
  	1515,1512,1,0,0,0,1515,1516,1,0,0,0,1516,1517,1,0,0,0,1517,1521,5,298,
  	0,0,1518,1519,5,151,0,0,1519,1520,5,194,0,0,1520,1522,5,124,0,0,1521,
  	1518,1,0,0,0,1521,1522,1,0,0,0,1522,1523,1,0,0,0,1523,1525,3,322,161,
  	0,1524,1526,3,306,153,0,1525,1524,1,0,0,0,1525,1526,1,0,0,0,1526,1535,
  	1,0,0,0,1527,1534,3,178,89,0,1528,1529,5,212,0,0,1529,1530,5,198,0,0,
  	1530,1534,3,298,149,0,1531,1532,5,271,0,0,1532,1534,3,204,102,0,1533,
  	1527,1,0,0,0,1533,1528,1,0,0,0,1533,1531,1,0,0,0,1534,1537,1,0,0,0,1535,
  	1533,1,0,0,0,1535,1536,1,0,0,0,1536,1538,1,0,0,0,1537,1535,1,0,0,0,1538,
  	1539,5,63,0,0,1539,1540,3,180,90,0,1540,1843,1,0,0,0,1541,1544,5,94,0,
  	0,1542,1543,5,202,0,0,1543,1545,5,233,0,0,1544,1542,1,0,0,0,1544,1545,
  	1,0,0,0,1545,1547,1,0,0,0,1546,1548,5,145,0,0,1547,1546,1,0,0,0,1547,
  	1548,1,0,0,0,1548,1549,1,0,0,0,1549,1550,5,272,0,0,1550,1551,5,298,0,
  	0,1551,1556,3,324,162,0,1552,1553,5,3,0,0,1553,1554,3,382,191,0,1554,
  	1555,5,4,0,0,1555,1557,1,0,0,0,1556,1552,1,0,0,0,1556,1557,1,0,0,0,1557,
  	1558,1,0,0,0,1558,1561,3,200,100,0,1559,1560,5,201,0,0,1560,1562,3,204,
  	102,0,1561,1559,1,0,0,0,1561,1562,1,0,0,0,1562,1843,1,0,0,0,1563,1564,
  	5,56,0,0,1564,1565,5,298,0,0,1565,1567,3,322,161,0,1566,1568,5,63,0,0,
  	1567,1566,1,0,0,0,1567,1568,1,0,0,0,1568,1569,1,0,0,0,1569,1570,3,180,
  	90,0,1570,1843,1,0,0,0,1571,1574,5,94,0,0,1572,1573,5,202,0,0,1573,1575,
  	5,233,0,0,1574,1572,1,0,0,0,1574,1575,1,0,0,0,1575,1577,1,0,0,0,1576,
  	1578,5,272,0,0,1577,1576,1,0,0,0,1577,1578,1,0,0,0,1578,1579,1,0,0,0,
  	1579,1583,5,143,0,0,1580,1581,5,151,0,0,1581,1582,5,194,0,0,1582,1584,
  	5,124,0,0,1583,1580,1,0,0,0,1583,1584,1,0,0,0,1584,1585,1,0,0,0,1585,
  	1586,3,322,161,0,1586,1587,5,63,0,0,1587,1597,5,325,0,0,1588,1589,5,296,
  	0,0,1589,1594,3,222,111,0,1590,1591,5,1,0,0,1591,1593,3,222,111,0,1592,
  	1590,1,0,0,0,1593,1596,1,0,0,0,1594,1592,1,0,0,0,1594,1595,1,0,0,0,1595,
  	1598,1,0,0,0,1596,1594,1,0,0,0,1597,1588,1,0,0,0,1597,1598,1,0,0,0,1598,
  	1843,1,0,0,0,1599,1601,5,117,0,0,1600,1602,5,272,0,0,1601,1600,1,0,0,
  	0,1601,1602,1,0,0,0,1602,1603,1,0,0,0,1603,1606,5,143,0,0,1604,1605,5,
  	151,0,0,1605,1607,5,124,0,0,1606,1604,1,0,0,0,1606,1607,1,0,0,0,1607,
  	1608,1,0,0,0,1608,1843,3,322,161,0,1609,1611,5,125,0,0,1610,1612,7,21,
  	0,0,1611,1610,1,0,0,0,1611,1612,1,0,0,0,1612,1613,1,0,0,0,1613,1843,3,
  	164,82,0,1614,1615,5,256,0,0,1615,1618,5,269,0,0,1616,1617,7,17,0,0,1617,
  	1619,3,322,161,0,1618,1616,1,0,0,0,1618,1619,1,0,0,0,1619,1624,1,0,0,
  	0,1620,1622,5,173,0,0,1621,1620,1,0,0,0,1621,1622,1,0,0,0,1622,1623,1,
  	0,0,0,1623,1625,5,325,0,0,1624,1621,1,0,0,0,1624,1625,1,0,0,0,1625,1843,
  	1,0,0,0,1626,1627,5,256,0,0,1627,1628,5,268,0,0,1628,1631,5,127,0,0,1629,
  	1630,7,17,0,0,1630,1632,3,322,161,0,1631,1629,1,0,0,0,1631,1632,1,0,0,
  	0,1632,1633,1,0,0,0,1633,1634,5,173,0,0,1634,1636,5,325,0,0,1635,1637,
  	3,186,93,0,1636,1635,1,0,0,0,1636,1637,1,0,0,0,1637,1843,1,0,0,0,1638,
  	1639,5,256,0,0,1639,1640,5,271,0,0,1640,1645,3,322,161,0,1641,1642,5,
  	3,0,0,1642,1643,3,208,104,0,1643,1644,5,4,0,0,1644,1646,1,0,0,0,1645,
  	1641,1,0,0,0,1645,1646,1,0,0,0,1646,1843,1,0,0,0,1647,1648,5,256,0,0,
  	1648,1649,5,85,0,0,1649,1650,7,17,0,0,1650,1653,3,322,161,0,1651,1652,
  	7,17,0,0,1652,1654,3,322,161,0,1653,1651,1,0,0,0,1653,1654,1,0,0,0,1654,
  	1843,1,0,0,0,1655,1656,5,256,0,0,1656,1659,5,299,0,0,1657,1658,7,17,0,
  	0,1658,1660,3,322,161,0,1659,1657,1,0,0,0,1659,1660,1,0,0,0,1660,1665,
  	1,0,0,0,1661,1663,5,173,0,0,1662,1661,1,0,0,0,1662,1663,1,0,0,0,1663,
  	1664,1,0,0,0,1664,1666,5,325,0,0,1665,1662,1,0,0,0,1665,1666,1,0,0,0,
  	1666,1843,1,0,0,0,1667,1668,5,256,0,0,1668,1669,5,213,0,0,1669,1671,3,
  	322,161,0,1670,1672,3,186,93,0,1671,1670,1,0,0,0,1671,1672,1,0,0,0,1672,
  	1843,1,0,0,0,1673,1675,5,256,0,0,1674,1676,3,412,206,0,1675,1674,1,0,
  	0,0,1675,1676,1,0,0,0,1676,1677,1,0,0,0,1677,1685,5,144,0,0,1678,1680,
  	5,173,0,0,1679,1678,1,0,0,0,1679,1680,1,0,0,0,1680,1683,1,0,0,0,1681,
  	1684,3,322,161,0,1682,1684,5,325,0,0,1683,1681,1,0,0,0,1683,1682,1,0,
  	0,0,1684,1686,1,0,0,0,1685,1679,1,0,0,0,1685,1686,1,0,0,0,1686,1843,1,
  	0,0,0,1687,1688,5,256,0,0,1688,1689,5,94,0,0,1689,1690,5,268,0,0,1690,
  	1693,3,322,161,0,1691,1692,5,63,0,0,1692,1694,5,250,0,0,1693,1691,1,0,
  	0,0,1693,1694,1,0,0,0,1694,1843,1,0,0,0,1695,1696,5,256,0,0,1696,1697,
  	5,97,0,0,1697,1843,5,190,0,0,1698,1699,7,22,0,0,1699,1701,5,143,0,0,1700,
  	1702,5,127,0,0,1701,1700,1,0,0,0,1701,1702,1,0,0,0,1702,1703,1,0,0,0,
  	1703,1843,3,192,96,0,1704,1705,7,22,0,0,1705,1707,3,190,95,0,1706,1708,
  	5,127,0,0,1707,1706,1,0,0,0,1707,1708,1,0,0,0,1708,1709,1,0,0,0,1709,
  	1710,3,322,161,0,1710,1843,1,0,0,0,1711,1713,7,22,0,0,1712,1714,5,268,
  	0,0,1713,1712,1,0,0,0,1713,1714,1,0,0,0,1714,1716,1,0,0,0,1715,1717,7,
  	23,0,0,1716,1715,1,0,0,0,1716,1717,1,0,0,0,1717,1718,1,0,0,0,1718,1720,
  	3,322,161,0,1719,1721,3,186,93,0,1720,1719,1,0,0,0,1720,1721,1,0,0,0,
  	1721,1723,1,0,0,0,1722,1724,3,194,97,0,1723,1722,1,0,0,0,1723,1724,1,
  	0,0,0,1724,1843,1,0,0,0,1725,1727,7,22,0,0,1726,1728,5,223,0,0,1727,1726,
  	1,0,0,0,1727,1728,1,0,0,0,1728,1729,1,0,0,0,1729,1843,3,180,90,0,1730,
  	1731,5,86,0,0,1731,1732,5,198,0,0,1732,1733,3,190,95,0,1733,1734,3,322,
  	161,0,1734,1735,5,164,0,0,1735,1736,7,24,0,0,1736,1843,1,0,0,0,1737,1738,
  	5,86,0,0,1738,1739,5,198,0,0,1739,1740,5,268,0,0,1740,1741,3,322,161,
  	0,1741,1742,5,164,0,0,1742,1743,7,24,0,0,1743,1843,1,0,0,0,1744,1745,
  	5,230,0,0,1745,1746,5,268,0,0,1746,1843,3,322,161,0,1747,1755,5,230,0,
  	0,1748,1756,5,325,0,0,1749,1751,9,0,0,0,1750,1749,1,0,0,0,1751,1754,1,
  	0,0,0,1752,1753,1,0,0,0,1752,1750,1,0,0,0,1753,1756,1,0,0,0,1754,1752,
  	1,0,0,0,1755,1748,1,0,0,0,1755,1752,1,0,0,0,1756,1843,1,0,0,0,1757,1759,
  	5,72,0,0,1758,1760,5,170,0,0,1759,1758,1,0,0,0,1759,1760,1,0,0,0,1760,
  	1761,1,0,0,0,1761,1762,5,268,0,0,1762,1765,3,322,161,0,1763,1764,5,201,
  	0,0,1764,1766,3,204,102,0,1765,1763,1,0,0,0,1765,1766,1,0,0,0,1766,1771,
  	1,0,0,0,1767,1769,5,63,0,0,1768,1767,1,0,0,0,1768,1769,1,0,0,0,1769,1770,
  	1,0,0,0,1770,1772,3,180,90,0,1771,1768,1,0,0,0,1771,1772,1,0,0,0,1772,
  	1843,1,0,0,0,1773,1774,5,287,0,0,1774,1777,5,268,0,0,1775,1776,5,151,
  	0,0,1776,1778,5,124,0,0,1777,1775,1,0,0,0,1777,1778,1,0,0,0,1778,1779,
  	1,0,0,0,1779,1843,3,322,161,0,1780,1781,5,78,0,0,1781,1843,5,72,0,0,1782,
  	1783,5,177,0,0,1783,1785,5,102,0,0,1784,1786,5,178,0,0,1785,1784,1,0,
  	0,0,1785,1786,1,0,0,0,1786,1787,1,0,0,0,1787,1788,5,158,0,0,1788,1790,
  	5,325,0,0,1789,1791,5,210,0,0,1790,1789,1,0,0,0,1790,1791,1,0,0,0,1791,
  	1792,1,0,0,0,1792,1793,5,163,0,0,1793,1794,5,268,0,0,1794,1796,3,322,
  	161,0,1795,1797,3,186,93,0,1796,1795,1,0,0,0,1796,1797,1,0,0,0,1797,1843,
  	1,0,0,0,1798,1799,5,283,0,0,1799,1800,5,268,0,0,1800,1802,3,322,161,0,
  	1801,1803,3,186,93,0,1802,1801,1,0,0,0,1802,1803,1,0,0,0,1803,1843,1,
  	0,0,0,1804,1805,5,189,0,0,1805,1806,5,232,0,0,1806,1807,5,268,0,0,1807,
  	1843,3,322,161,0,1808,1809,7,25,0,0,1809,1817,3,412,206,0,1810,1818,5,
  	325,0,0,1811,1813,9,0,0,0,1812,1811,1,0,0,0,1813,1816,1,0,0,0,1814,1815,
  	1,0,0,0,1814,1812,1,0,0,0,1815,1818,1,0,0,0,1816,1814,1,0,0,0,1817,1810,
  	1,0,0,0,1817,1814,1,0,0,0,1818,1843,1,0,0,0,1819,1820,5,253,0,0,1820,
  	1824,5,239,0,0,1821,1823,9,0,0,0,1822,1821,1,0,0,0,1823,1826,1,0,0,0,
  	1824,1825,1,0,0,0,1824,1822,1,0,0,0,1825,1843,1,0,0,0,1826,1824,1,0,0,
  	0,1827,1831,5,253,0,0,1828,1830,9,0,0,0,1829,1828,1,0,0,0,1830,1833,1,
  	0,0,0,1831,1832,1,0,0,0,1831,1829,1,0,0,0,1832,1843,1,0,0,0,1833,1831,
  	1,0,0,0,1834,1843,5,234,0,0,1835,1839,3,166,83,0,1836,1838,9,0,0,0,1837,
  	1836,1,0,0,0,1838,1841,1,0,0,0,1839,1840,1,0,0,0,1839,1837,1,0,0,0,1840,
  	1843,1,0,0,0,1841,1839,1,0,0,0,1842,1137,1,0,0,0,1842,1139,1,0,0,0,1842,
  	1142,1,0,0,0,1842,1147,1,0,0,0,1842,1165,1,0,0,0,1842,1172,1,0,0,0,1842,
  	1178,1,0,0,0,1842,1188,1,0,0,0,1842,1200,1,0,0,0,1842,1215,1,0,0,0,1842,
  	1252,1,0,0,0,1842,1273,1,0,0,0,1842,1288,1,0,0,0,1842,1305,1,0,0,0,1842,
  	1312,1,0,0,0,1842,1321,1,0,0,0,1842,1330,1,0,0,0,1842,1339,1,0,0,0,1842,
  	1346,1,0,0,0,1842,1353,1,0,0,0,1842,1360,1,0,0,0,1842,1371,1,0,0,0,1842,
  	1382,1,0,0,0,1842,1397,1,0,0,0,1842,1409,1,0,0,0,1842,1423,1,0,0,0,1842,
  	1433,1,0,0,0,1842,1447,1,0,0,0,1842,1455,1,0,0,0,1842,1474,1,0,0,0,1842,
  	1483,1,0,0,0,1842,1489,1,0,0,0,1842,1499,1,0,0,0,1842,1506,1,0,0,0,1842,
  	1541,1,0,0,0,1842,1563,1,0,0,0,1842,1571,1,0,0,0,1842,1599,1,0,0,0,1842,
  	1609,1,0,0,0,1842,1614,1,0,0,0,1842,1626,1,0,0,0,1842,1638,1,0,0,0,1842,
  	1647,1,0,0,0,1842,1655,1,0,0,0,1842,1667,1,0,0,0,1842,1673,1,0,0,0,1842,
  	1687,1,0,0,0,1842,1695,1,0,0,0,1842,1698,1,0,0,0,1842,1704,1,0,0,0,1842,
  	1711,1,0,0,0,1842,1725,1,0,0,0,1842,1730,1,0,0,0,1842,1737,1,0,0,0,1842,
  	1744,1,0,0,0,1842,1747,1,0,0,0,1842,1757,1,0,0,0,1842,1773,1,0,0,0,1842,
  	1780,1,0,0,0,1842,1782,1,0,0,0,1842,1798,1,0,0,0,1842,1804,1,0,0,0,1842,
  	1808,1,0,0,0,1842,1819,1,0,0,0,1842,1827,1,0,0,0,1842,1834,1,0,0,0,1842,
  	1835,1,0,0,0,1843,165,1,0,0,0,1844,1845,5,94,0,0,1845,2013,5,239,0,0,
  	1846,1847,5,117,0,0,1847,2013,5,239,0,0,1848,1850,5,146,0,0,1849,1851,
  	5,239,0,0,1850,1849,1,0,0,0,1850,1851,1,0,0,0,1851,2013,1,0,0,0,1852,
  	1854,5,236,0,0,1853,1855,5,239,0,0,1854,1853,1,0,0,0,1854,1855,1,0,0,
  	0,1855,2013,1,0,0,0,1856,1857,5,256,0,0,1857,2013,5,146,0,0,1858,1859,
  	5,256,0,0,1859,1861,5,239,0,0,1860,1862,5,146,0,0,1861,1860,1,0,0,0,1861,
  	1862,1,0,0,0,1862,2013,1,0,0,0,1863,1864,5,256,0,0,1864,2013,5,220,0,
  	0,1865,1866,5,256,0,0,1866,2013,5,240,0,0,1867,1868,5,256,0,0,1868,1869,
  	5,97,0,0,1869,2013,5,240,0,0,1870,1871,5,126,0,0,1871,2013,5,268,0,0,
  	1872,1873,5,153,0,0,1873,2013,5,268,0,0,1874,1875,5,256,0,0,1875,2013,
  	5,89,0,0,1876,1877,5,256,0,0,1877,1878,5,94,0,0,1878,2013,5,268,0,0,1879,
  	1880,5,256,0,0,1880,2013,5,279,0,0,1881,1882,5,256,0,0,1882,2013,5,156,
  	0,0,1883,1884,5,256,0,0,1884,2013,5,181,0,0,1885,1886,5,94,0,0,1886,2013,
  	5,155,0,0,1887,1888,5,117,0,0,1888,2013,5,155,0,0,1889,1890,5,56,0,0,
  	1890,2013,5,155,0,0,1891,1892,5,180,0,0,1892,2013,5,268,0,0,1893,1894,
  	5,180,0,0,1894,2013,5,103,0,0,1895,1896,5,291,0,0,1896,2013,5,268,0,0,
  	1897,1898,5,291,0,0,1898,2013,5,103,0,0,1899,1900,5,94,0,0,1900,1901,
  	5,272,0,0,1901,2013,5,183,0,0,1902,1903,5,117,0,0,1903,1904,5,272,0,0,
  	1904,2013,5,183,0,0,1905,1906,5,56,0,0,1906,1907,5,268,0,0,1907,1908,
  	3,324,162,0,1908,1909,5,194,0,0,1909,1910,5,80,0,0,1910,2013,1,0,0,0,
  	1911,1912,5,56,0,0,1912,1913,5,268,0,0,1913,1914,3,324,162,0,1914,1915,
  	5,80,0,0,1915,1916,5,71,0,0,1916,2013,1,0,0,0,1917,1918,5,56,0,0,1918,
  	1919,5,268,0,0,1919,1920,3,324,162,0,1920,1921,5,194,0,0,1921,1922,5,
  	260,0,0,1922,2013,1,0,0,0,1923,1924,5,56,0,0,1924,1925,5,268,0,0,1925,
  	1926,3,324,162,0,1926,1927,5,257,0,0,1927,1928,5,71,0,0,1928,2013,1,0,
  	0,0,1929,1930,5,56,0,0,1930,1931,5,268,0,0,1931,1932,3,324,162,0,1932,
  	1933,5,194,0,0,1933,1934,5,257,0,0,1934,2013,1,0,0,0,1935,1936,5,56,0,
  	0,1936,1937,5,268,0,0,1937,1938,3,324,162,0,1938,1939,5,194,0,0,1939,
  	1940,5,263,0,0,1940,1941,5,63,0,0,1941,1942,5,113,0,0,1942,2013,1,0,0,
  	0,1943,1944,5,56,0,0,1944,1945,5,268,0,0,1945,1946,3,324,162,0,1946,1947,
  	5,253,0,0,1947,1948,5,257,0,0,1948,1949,5,179,0,0,1949,2013,1,0,0,0,1950,
  	1951,5,56,0,0,1951,1952,5,268,0,0,1952,1953,3,324,162,0,1953,1954,5,123,
  	0,0,1954,1955,5,211,0,0,1955,2013,1,0,0,0,1956,1957,5,56,0,0,1957,1958,
  	5,268,0,0,1958,1959,3,324,162,0,1959,1960,5,61,0,0,1960,1961,5,211,0,
  	0,1961,2013,1,0,0,0,1962,1963,5,56,0,0,1963,1964,5,268,0,0,1964,1965,
  	3,324,162,0,1965,1966,5,285,0,0,1966,1967,5,211,0,0,1967,2013,1,0,0,0,
  	1968,1969,5,56,0,0,1969,1970,5,268,0,0,1970,1971,3,324,162,0,1971,1972,
  	5,276,0,0,1972,2013,1,0,0,0,1973,1974,5,56,0,0,1974,1975,5,268,0,0,1975,
  	1977,3,324,162,0,1976,1978,3,186,93,0,1977,1976,1,0,0,0,1977,1978,1,0,
  	0,0,1978,1979,1,0,0,0,1979,1980,5,88,0,0,1980,2013,1,0,0,0,1981,1982,
  	5,56,0,0,1982,1983,5,268,0,0,1983,1985,3,324,162,0,1984,1986,3,186,93,
  	0,1985,1984,1,0,0,0,1985,1986,1,0,0,0,1986,1987,1,0,0,0,1987,1988,5,91,
  	0,0,1988,2013,1,0,0,0,1989,1990,5,56,0,0,1990,1991,5,268,0,0,1991,1993,
  	3,324,162,0,1992,1994,3,186,93,0,1993,1992,1,0,0,0,1993,1994,1,0,0,0,
  	1994,1995,1,0,0,0,1995,1996,5,253,0,0,1996,1997,5,134,0,0,1997,2013,1,
  	0,0,0,1998,1999,5,56,0,0,1999,2000,5,268,0,0,2000,2002,3,324,162,0,2001,
  	2003,3,186,93,0,2002,2001,1,0,0,0,2002,2003,1,0,0,0,2003,2004,1,0,0,0,
  	2004,2005,5,233,0,0,2005,2006,5,85,0,0,2006,2013,1,0,0,0,2007,2008,5,
  	261,0,0,2008,2013,5,278,0,0,2009,2013,5,87,0,0,2010,2013,5,241,0,0,2011,
  	2013,5,112,0,0,2012,1844,1,0,0,0,2012,1846,1,0,0,0,2012,1848,1,0,0,0,
  	2012,1852,1,0,0,0,2012,1856,1,0,0,0,2012,1858,1,0,0,0,2012,1863,1,0,0,
  	0,2012,1865,1,0,0,0,2012,1867,1,0,0,0,2012,1870,1,0,0,0,2012,1872,1,0,
  	0,0,2012,1874,1,0,0,0,2012,1876,1,0,0,0,2012,1879,1,0,0,0,2012,1881,1,
  	0,0,0,2012,1883,1,0,0,0,2012,1885,1,0,0,0,2012,1887,1,0,0,0,2012,1889,
  	1,0,0,0,2012,1891,1,0,0,0,2012,1893,1,0,0,0,2012,1895,1,0,0,0,2012,1897,
  	1,0,0,0,2012,1899,1,0,0,0,2012,1902,1,0,0,0,2012,1905,1,0,0,0,2012,1911,
  	1,0,0,0,2012,1917,1,0,0,0,2012,1923,1,0,0,0,2012,1929,1,0,0,0,2012,1935,
  	1,0,0,0,2012,1943,1,0,0,0,2012,1950,1,0,0,0,2012,1956,1,0,0,0,2012,1962,
  	1,0,0,0,2012,1968,1,0,0,0,2012,1973,1,0,0,0,2012,1981,1,0,0,0,2012,1989,
  	1,0,0,0,2012,1998,1,0,0,0,2012,2007,1,0,0,0,2012,2009,1,0,0,0,2012,2010,
  	1,0,0,0,2012,2011,1,0,0,0,2013,167,1,0,0,0,2014,2016,5,94,0,0,2015,2017,
  	5,272,0,0,2016,2015,1,0,0,0,2016,2017,1,0,0,0,2017,2019,1,0,0,0,2018,
  	2020,5,128,0,0,2019,2018,1,0,0,0,2019,2020,1,0,0,0,2020,2021,1,0,0,0,
  	2021,2025,5,268,0,0,2022,2023,5,151,0,0,2023,2024,5,194,0,0,2024,2026,
  	5,124,0,0,2025,2022,1,0,0,0,2025,2026,1,0,0,0,2026,2027,1,0,0,0,2027,
  	2028,3,322,161,0,2028,169,1,0,0,0,2029,2030,5,94,0,0,2030,2032,5,202,
  	0,0,2031,2029,1,0,0,0,2031,2032,1,0,0,0,2032,2033,1,0,0,0,2033,2034,5,
  	233,0,0,2034,2035,5,268,0,0,2035,2036,3,322,161,0,2036,171,1,0,0,0,2037,
  	2038,5,80,0,0,2038,2039,5,71,0,0,2039,2043,3,298,149,0,2040,2041,5,260,
  	0,0,2041,2042,5,71,0,0,2042,2044,3,302,151,0,2043,2040,1,0,0,0,2043,2044,
  	1,0,0,0,2044,2045,1,0,0,0,2045,2046,5,163,0,0,2046,2047,5,329,0,0,2047,
  	2048,5,70,0,0,2048,173,1,0,0,0,2049,2050,5,257,0,0,2050,2051,5,71,0,0,
  	2051,2052,3,298,149,0,2052,2055,5,198,0,0,2053,2056,3,212,106,0,2054,
  	2056,3,214,107,0,2055,2053,1,0,0,0,2055,2054,1,0,0,0,2056,2060,1,0,0,
  	0,2057,2058,5,263,0,0,2058,2059,5,63,0,0,2059,2061,5,113,0,0,2060,2057,
  	1,0,0,0,2060,2061,1,0,0,0,2061,175,1,0,0,0,2062,2063,5,179,0,0,2063,2064,
  	5,325,0,0,2064,177,1,0,0,0,2065,2066,5,86,0,0,2066,2067,5,325,0,0,2067,
  	179,1,0,0,0,2068,2070,3,48,24,0,2069,2068,1,0,0,0,2069,2070,1,0,0,0,2070,
  	2072,1,0,0,0,2071,2073,3,196,98,0,2072,2071,1,0,0,0,2072,2073,1,0,0,0,
  	2073,2074,1,0,0,0,2074,2075,3,230,115,0,2075,2076,3,226,113,0,2076,181,
  	1,0,0,0,2077,2078,5,160,0,0,2078,2080,5,210,0,0,2079,2081,5,268,0,0,2080,
  	2079,1,0,0,0,2080,2081,1,0,0,0,2081,2082,1,0,0,0,2082,2089,3,322,161,
  	0,2083,2087,3,186,93,0,2084,2085,5,151,0,0,2085,2086,5,194,0,0,2086,2088,
  	5,124,0,0,2087,2084,1,0,0,0,2087,2088,1,0,0,0,2088,2090,1,0,0,0,2089,
  	2083,1,0,0,0,2089,2090,1,0,0,0,2090,2133,1,0,0,0,2091,2092,5,160,0,0,
  	2092,2094,5,163,0,0,2093,2095,5,268,0,0,2094,2093,1,0,0,0,2094,2095,1,
  	0,0,0,2095,2096,1,0,0,0,2096,2098,3,322,161,0,2097,2099,3,186,93,0,2098,
  	2097,1,0,0,0,2098,2099,1,0,0,0,2099,2103,1,0,0,0,2100,2101,5,151,0,0,
  	2101,2102,5,194,0,0,2102,2104,5,124,0,0,2103,2100,1,0,0,0,2103,2104,1,
  	0,0,0,2104,2133,1,0,0,0,2105,2106,5,160,0,0,2106,2108,5,210,0,0,2107,
  	2109,5,178,0,0,2108,2107,1,0,0,0,2108,2109,1,0,0,0,2109,2110,1,0,0,0,
  	2110,2111,5,114,0,0,2111,2113,5,325,0,0,2112,2114,3,318,159,0,2113,2112,
  	1,0,0,0,2113,2114,1,0,0,0,2114,2116,1,0,0,0,2115,2117,3,216,108,0,2116,
  	2115,1,0,0,0,2116,2117,1,0,0,0,2117,2133,1,0,0,0,2118,2119,5,160,0,0,
  	2119,2121,5,210,0,0,2120,2122,5,178,0,0,2121,2120,1,0,0,0,2121,2122,1,
  	0,0,0,2122,2123,1,0,0,0,2123,2125,5,114,0,0,2124,2126,5,325,0,0,2125,
  	2124,1,0,0,0,2125,2126,1,0,0,0,2126,2127,1,0,0,0,2127,2130,3,200,100,
  	0,2128,2129,5,201,0,0,2129,2131,3,204,102,0,2130,2128,1,0,0,0,2130,2131,
  	1,0,0,0,2131,2133,1,0,0,0,2132,2077,1,0,0,0,2132,2091,1,0,0,0,2132,2105,
  	1,0,0,0,2132,2118,1,0,0,0,2133,183,1,0,0,0,2134,2136,3,186,93,0,2135,
  	2137,3,176,88,0,2136,2135,1,0,0,0,2136,2137,1,0,0,0,2137,185,1,0,0,0,
  	2138,2139,5,211,0,0,2139,2140,5,3,0,0,2140,2145,3,188,94,0,2141,2142,
  	5,1,0,0,2142,2144,3,188,94,0,2143,2141,1,0,0,0,2144,2147,1,0,0,0,2145,
  	2143,1,0,0,0,2145,2146,1,0,0,0,2146,2148,1,0,0,0,2147,2145,1,0,0,0,2148,
  	2149,5,4,0,0,2149,187,1,0,0,0,2150,2153,3,412,206,0,2151,2152,5,305,0,
  	0,2152,2154,3,348,174,0,2153,2151,1,0,0,0,2153,2154,1,0,0,0,2154,189,
  	1,0,0,0,2155,2156,7,26,0,0,2156,191,1,0,0,0,2157,2163,3,406,203,0,2158,
  	2163,5,325,0,0,2159,2163,3,350,175,0,2160,2163,3,354,177,0,2161,2163,
  	3,356,178,0,2162,2157,1,0,0,0,2162,2158,1,0,0,0,2162,2159,1,0,0,0,2162,
  	2160,1,0,0,0,2162,2161,1,0,0,0,2163,193,1,0,0,0,2164,2169,3,412,206,0,
  	2165,2166,5,7,0,0,2166,2168,3,412,206,0,2167,2165,1,0,0,0,2168,2171,1,
  	0,0,0,2169,2167,1,0,0,0,2169,2170,1,0,0,0,2170,195,1,0,0,0,2171,2169,
  	1,0,0,0,2172,2173,5,303,0,0,2173,2178,3,198,99,0,2174,2175,5,1,0,0,2175,
  	2177,3,198,99,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,197,1,0,0,0,2180,2178,1,0,0,0,2181,2183,3,408,
  	204,0,2182,2184,3,298,149,0,2183,2182,1,0,0,0,2183,2184,1,0,0,0,2184,
  	2186,1,0,0,0,2185,2187,5,63,0,0,2186,2185,1,0,0,0,2186,2187,1,0,0,0,2187,
  	2188,1,0,0,0,2188,2189,5,3,0,0,2189,2190,3,180,90,0,2190,2191,5,4,0,0,
  	2191,199,1,0,0,0,2192,2193,5,296,0,0,2193,2194,3,322,161,0,2194,201,1,
  	0,0,0,2195,2196,5,201,0,0,2196,2206,3,204,102,0,2197,2198,5,212,0,0,2198,
  	2199,5,71,0,0,2199,2206,3,332,166,0,2200,2206,3,172,86,0,2201,2206,3,
  	176,88,0,2202,2206,3,178,89,0,2203,2204,5,271,0,0,2204,2206,3,204,102,
  	0,2205,2195,1,0,0,0,2205,2197,1,0,0,0,2205,2200,1,0,0,0,2205,2201,1,0,
  	0,0,2205,2202,1,0,0,0,2205,2203,1,0,0,0,2206,2209,1,0,0,0,2207,2205,1,
  	0,0,0,2207,2208,1,0,0,0,2208,203,1,0,0,0,2209,2207,1,0,0,0,2210,2211,
  	5,3,0,0,2211,2216,3,206,103,0,2212,2213,5,1,0,0,2213,2215,3,206,103,0,
  	2214,2212,1,0,0,0,2215,2218,1,0,0,0,2216,2214,1,0,0,0,2216,2217,1,0,0,
  	0,2217,2219,1,0,0,0,2218,2216,1,0,0,0,2219,2220,5,4,0,0,2220,205,1,0,
  	0,0,2221,2226,3,208,104,0,2222,2224,5,305,0,0,2223,2222,1,0,0,0,2223,
  	2224,1,0,0,0,2224,2225,1,0,0,0,2225,2227,3,210,105,0,2226,2223,1,0,0,
  	0,2226,2227,1,0,0,0,2227,207,1,0,0,0,2228,2233,3,412,206,0,2229,2230,
  	5,7,0,0,2230,2232,3,412,206,0,2231,2229,1,0,0,0,2232,2235,1,0,0,0,2233,
  	2231,1,0,0,0,2233,2234,1,0,0,0,2234,2238,1,0,0,0,2235,2233,1,0,0,0,2236,
  	2238,5,325,0,0,2237,2228,1,0,0,0,2237,2236,1,0,0,0,2238,209,1,0,0,0,2239,
  	2244,5,329,0,0,2240,2244,5,331,0,0,2241,2244,3,358,179,0,2242,2244,5,
  	325,0,0,2243,2239,1,0,0,0,2243,2240,1,0,0,0,2243,2241,1,0,0,0,2243,2242,
  	1,0,0,0,2244,211,1,0,0,0,2245,2246,5,3,0,0,2246,2251,3,348,174,0,2247,
  	2248,5,1,0,0,2248,2250,3,348,174,0,2249,2247,1,0,0,0,2250,2253,1,0,0,
  	0,2251,2249,1,0,0,0,2251,2252,1,0,0,0,2252,2254,1,0,0,0,2253,2251,1,0,
  	0,0,2254,2255,5,4,0,0,2255,213,1,0,0,0,2256,2257,5,3,0,0,2257,2262,3,
  	212,106,0,2258,2259,5,1,0,0,2259,2261,3,212,106,0,2260,2258,1,0,0,0,2261,
  	2264,1,0,0,0,2262,2260,1,0,0,0,2262,2263,1,0,0,0,2263,2265,1,0,0,0,2264,
  	2262,1,0,0,0,2265,2266,5,4,0,0,2266,215,1,0,0,0,2267,2268,5,263,0,0,2268,
  	2269,5,63,0,0,2269,2274,3,218,109,0,2270,2271,5,263,0,0,2271,2272,5,71,
  	0,0,2272,2274,3,220,110,0,2273,2267,1,0,0,0,2273,2270,1,0,0,0,2274,217,
  	1,0,0,0,2275,2276,5,159,0,0,2276,2277,5,325,0,0,2277,2278,5,206,0,0,2278,
  	2281,5,325,0,0,2279,2281,3,412,206,0,2280,2275,1,0,0,0,2280,2279,1,0,
  	0,0,2281,219,1,0,0,0,2282,2286,5,325,0,0,2283,2284,5,303,0,0,2284,2285,
  	5,251,0,0,2285,2287,3,204,102,0,2286,2283,1,0,0,0,2286,2287,1,0,0,0,2287,
  	221,1,0,0,0,2288,2289,3,412,206,0,2289,2290,5,325,0,0,2290,223,1,0,0,
  	0,2291,2292,3,182,91,0,2292,2293,3,230,115,0,2293,2294,3,226,113,0,2294,
  	2343,1,0,0,0,2295,2297,3,270,135,0,2296,2298,3,228,114,0,2297,2296,1,
  	0,0,0,2298,2299,1,0,0,0,2299,2297,1,0,0,0,2299,2300,1,0,0,0,2300,2343,
  	1,0,0,0,2301,2302,5,108,0,0,2302,2303,5,141,0,0,2303,2304,3,322,161,0,
  	2304,2306,3,316,158,0,2305,2307,3,262,131,0,2306,2305,1,0,0,0,2306,2307,
  	1,0,0,0,2307,2343,1,0,0,0,2308,2309,5,293,0,0,2309,2310,3,322,161,0,2310,
  	2311,3,316,158,0,2311,2313,3,248,124,0,2312,2314,3,262,131,0,2313,2312,
  	1,0,0,0,2313,2314,1,0,0,0,2314,2343,1,0,0,0,2315,2316,5,186,0,0,2316,
  	2317,5,163,0,0,2317,2318,3,322,161,0,2318,2319,3,316,158,0,2319,2325,
  	5,296,0,0,2320,2326,3,322,161,0,2321,2322,5,3,0,0,2322,2323,3,180,90,
  	0,2323,2324,5,4,0,0,2324,2326,1,0,0,0,2325,2320,1,0,0,0,2325,2321,1,0,
  	0,0,2326,2327,1,0,0,0,2327,2328,3,316,158,0,2328,2329,5,198,0,0,2329,
  	2333,3,340,170,0,2330,2332,3,250,125,0,2331,2330,1,0,0,0,2332,2335,1,
  	0,0,0,2333,2331,1,0,0,0,2333,2334,1,0,0,0,2334,2339,1,0,0,0,2335,2333,
  	1,0,0,0,2336,2338,3,252,126,0,2337,2336,1,0,0,0,2338,2341,1,0,0,0,2339,
  	2337,1,0,0,0,2339,2340,1,0,0,0,2340,2343,1,0,0,0,2341,2339,1,0,0,0,2342,
  	2291,1,0,0,0,2342,2295,1,0,0,0,2342,2301,1,0,0,0,2342,2308,1,0,0,0,2342,
  	2315,1,0,0,0,2343,225,1,0,0,0,2344,2345,5,203,0,0,2345,2346,5,71,0,0,
  	2346,2351,3,234,117,0,2347,2348,5,1,0,0,2348,2350,3,234,117,0,2349,2347,
  	1,0,0,0,2350,2353,1,0,0,0,2351,2349,1,0,0,0,2351,2352,1,0,0,0,2352,2355,
  	1,0,0,0,2353,2351,1,0,0,0,2354,2344,1,0,0,0,2354,2355,1,0,0,0,2355,2366,
  	1,0,0,0,2356,2357,5,79,0,0,2357,2358,5,71,0,0,2358,2363,3,338,169,0,2359,
  	2360,5,1,0,0,2360,2362,3,338,169,0,2361,2359,1,0,0,0,2362,2365,1,0,0,
  	0,2363,2361,1,0,0,0,2363,2364,1,0,0,0,2364,2367,1,0,0,0,2365,2363,1,0,
  	0,0,2366,2356,1,0,0,0,2366,2367,1,0,0,0,2367,2378,1,0,0,0,2368,2369,5,
  	116,0,0,2369,2370,5,71,0,0,2370,2375,3,338,169,0,2371,2372,5,1,0,0,2372,
  	2374,3,338,169,0,2373,2371,1,0,0,0,2374,2377,1,0,0,0,2375,2373,1,0,0,
  	0,2375,2376,1,0,0,0,2376,2379,1,0,0,0,2377,2375,1,0,0,0,2378,2368,1,0,
  	0,0,2378,2379,1,0,0,0,2379,2390,1,0,0,0,2380,2381,5,259,0,0,2381,2382,
  	5,71,0,0,2382,2387,3,234,117,0,2383,2384,5,1,0,0,2384,2386,3,234,117,
  	0,2385,2383,1,0,0,0,2386,2389,1,0,0,0,2387,2385,1,0,0,0,2387,2388,1,0,
  	0,0,2388,2391,1,0,0,0,2389,2387,1,0,0,0,2390,2380,1,0,0,0,2390,2391,1,
  	0,0,0,2391,2393,1,0,0,0,2392,2394,3,392,196,0,2393,2392,1,0,0,0,2393,
  	2394,1,0,0,0,2394,2400,1,0,0,0,2395,2398,5,174,0,0,2396,2399,5,55,0,0,
  	2397,2399,3,338,169,0,2398,2396,1,0,0,0,2398,2397,1,0,0,0,2399,2401,1,
  	0,0,0,2400,2395,1,0,0,0,2400,2401,1,0,0,0,2401,227,1,0,0,0,2402,2403,
  	3,182,91,0,2403,2404,3,238,119,0,2404,229,1,0,0,0,2405,2406,6,115,-1,
  	0,2406,2409,3,232,116,0,2407,2409,3,8,4,0,2408,2405,1,0,0,0,2408,2407,
  	1,0,0,0,2409,2430,1,0,0,0,2410,2411,10,3,0,0,2411,2413,7,27,0,0,2412,
  	2414,3,284,142,0,2413,2412,1,0,0,0,2413,2414,1,0,0,0,2414,2415,1,0,0,
  	0,2415,2429,3,230,115,4,2416,2417,10,2,0,0,2417,2419,5,161,0,0,2418,2420,
  	3,284,142,0,2419,2418,1,0,0,0,2419,2420,1,0,0,0,2420,2421,1,0,0,0,2421,
  	2429,3,230,115,3,2422,2423,10,1,0,0,2423,2425,7,28,0,0,2424,2426,3,284,
  	142,0,2425,2424,1,0,0,0,2425,2426,1,0,0,0,2426,2427,1,0,0,0,2427,2429,
  	3,230,115,2,2428,2410,1,0,0,0,2428,2416,1,0,0,0,2428,2422,1,0,0,0,2429,
  	2432,1,0,0,0,2430,2428,1,0,0,0,2430,2431,1,0,0,0,2431,231,1,0,0,0,2432,
  	2430,1,0,0,0,2433,2439,3,240,120,0,2434,2439,3,236,118,0,2435,2436,5,
  	268,0,0,2436,2439,3,322,161,0,2437,2439,3,312,156,0,2438,2433,1,0,0,0,
  	2438,2434,1,0,0,0,2438,2435,1,0,0,0,2438,2437,1,0,0,0,2439,233,1,0,0,
  	0,2440,2442,3,338,169,0,2441,2443,7,10,0,0,2442,2441,1,0,0,0,2442,2443,
  	1,0,0,0,2443,2446,1,0,0,0,2444,2445,5,196,0,0,2445,2447,7,3,0,0,2446,
  	2444,1,0,0,0,2446,2447,1,0,0,0,2447,235,1,0,0,0,2448,2450,3,270,135,0,
  	2449,2451,3,238,119,0,2450,2449,1,0,0,0,2451,2452,1,0,0,0,2452,2450,1,
  	0,0,0,2452,2453,1,0,0,0,2453,237,1,0,0,0,2454,2456,3,244,122,0,2455,2457,
  	3,262,131,0,2456,2455,1,0,0,0,2456,2457,1,0,0,0,2457,2458,1,0,0,0,2458,
  	2459,3,226,113,0,2459,2482,1,0,0,0,2460,2464,3,246,123,0,2461,2463,3,
  	282,141,0,2462,2461,1,0,0,0,2463,2466,1,0,0,0,2464,2462,1,0,0,0,2464,
  	2465,1,0,0,0,2465,2468,1,0,0,0,2466,2464,1,0,0,0,2467,2469,3,262,131,
  	0,2468,2467,1,0,0,0,2468,2469,1,0,0,0,2469,2471,1,0,0,0,2470,2472,3,272,
  	136,0,2471,2470,1,0,0,0,2471,2472,1,0,0,0,2472,2474,1,0,0,0,2473,2475,
  	3,264,132,0,2474,2473,1,0,0,0,2474,2475,1,0,0,0,2475,2477,1,0,0,0,2476,
  	2478,3,392,196,0,2477,2476,1,0,0,0,2477,2478,1,0,0,0,2478,2479,1,0,0,
  	0,2479,2480,3,226,113,0,2480,2482,1,0,0,0,2481,2454,1,0,0,0,2481,2460,
  	1,0,0,0,2482,239,1,0,0,0,2483,2484,3,244,122,0,2484,2486,3,242,121,0,
  	2485,2487,3,262,131,0,2486,2485,1,0,0,0,2486,2487,1,0,0,0,2487,2509,1,
  	0,0,0,2488,2489,3,246,123,0,2489,2493,3,242,121,0,2490,2492,3,282,141,
  	0,2491,2490,1,0,0,0,2492,2495,1,0,0,0,2493,2491,1,0,0,0,2493,2494,1,0,
  	0,0,2494,2497,1,0,0,0,2495,2493,1,0,0,0,2496,2498,3,262,131,0,2497,2496,
  	1,0,0,0,2497,2498,1,0,0,0,2498,2500,1,0,0,0,2499,2501,3,272,136,0,2500,
  	2499,1,0,0,0,2500,2501,1,0,0,0,2501,2503,1,0,0,0,2502,2504,3,264,132,
  	0,2503,2502,1,0,0,0,2503,2504,1,0,0,0,2504,2506,1,0,0,0,2505,2507,3,392,
  	196,0,2506,2505,1,0,0,0,2506,2507,1,0,0,0,2507,2509,1,0,0,0,2508,2483,
  	1,0,0,0,2508,2488,1,0,0,0,2509,241,1,0,0,0,2510,2512,3,270,135,0,2511,
  	2510,1,0,0,0,2511,2512,1,0,0,0,2512,243,1,0,0,0,2513,2514,5,247,0,0,2514,
  	2515,5,280,0,0,2515,2516,5,3,0,0,2516,2517,3,330,165,0,2517,2518,5,4,
  	0,0,2518,2524,1,0,0,0,2519,2520,5,184,0,0,2520,2524,3,330,165,0,2521,
  	2522,5,228,0,0,2522,2524,3,330,165,0,2523,2513,1,0,0,0,2523,2519,1,0,
  	0,0,2523,2521,1,0,0,0,2524,2526,1,0,0,0,2525,2527,3,318,159,0,2526,2525,
  	1,0,0,0,2526,2527,1,0,0,0,2527,2530,1,0,0,0,2528,2529,5,226,0,0,2529,
  	2531,5,325,0,0,2530,2528,1,0,0,0,2530,2531,1,0,0,0,2531,2532,1,0,0,0,
  	2532,2533,5,296,0,0,2533,2546,5,325,0,0,2534,2544,5,63,0,0,2535,2545,
  	3,300,150,0,2536,2545,3,382,191,0,2537,2540,5,3,0,0,2538,2541,3,300,150,
  	0,2539,2541,3,382,191,0,2540,2538,1,0,0,0,2540,2539,1,0,0,0,2541,2542,
  	1,0,0,0,2542,2543,5,4,0,0,2543,2545,1,0,0,0,2544,2535,1,0,0,0,2544,2536,
  	1,0,0,0,2544,2537,1,0,0,0,2545,2547,1,0,0,0,2546,2534,1,0,0,0,2546,2547,
  	1,0,0,0,2547,2549,1,0,0,0,2548,2550,3,318,159,0,2549,2548,1,0,0,0,2549,
  	2550,1,0,0,0,2550,2553,1,0,0,0,2551,2552,5,225,0,0,2552,2554,5,325,0,
  	0,2553,2551,1,0,0,0,2553,2554,1,0,0,0,2554,245,1,0,0,0,2555,2559,5,247,
  	0,0,2556,2558,3,266,133,0,2557,2556,1,0,0,0,2558,2561,1,0,0,0,2559,2557,
  	1,0,0,0,2559,2560,1,0,0,0,2560,2563,1,0,0,0,2561,2559,1,0,0,0,2562,2564,
  	3,284,142,0,2563,2562,1,0,0,0,2563,2564,1,0,0,0,2564,2565,1,0,0,0,2565,
  	2566,3,330,165,0,2566,247,1,0,0,0,2567,2568,5,253,0,0,2568,2569,3,258,
  	129,0,2569,249,1,0,0,0,2570,2571,5,300,0,0,2571,2574,5,185,0,0,2572,2573,
  	5,58,0,0,2573,2575,3,340,170,0,2574,2572,1,0,0,0,2574,2575,1,0,0,0,2575,
  	2576,1,0,0,0,2576,2577,5,274,0,0,2577,2578,3,254,127,0,2578,251,1,0,0,
  	0,2579,2580,5,300,0,0,2580,2581,5,194,0,0,2581,2584,5,185,0,0,2582,2583,
  	5,58,0,0,2583,2585,3,340,170,0,2584,2582,1,0,0,0,2584,2585,1,0,0,0,2585,
  	2586,1,0,0,0,2586,2587,5,274,0,0,2587,2588,3,256,128,0,2588,253,1,0,0,
  	0,2589,2597,5,108,0,0,2590,2591,5,293,0,0,2591,2592,5,253,0,0,2592,2597,
  	5,316,0,0,2593,2594,5,293,0,0,2594,2595,5,253,0,0,2595,2597,3,258,129,
  	0,2596,2589,1,0,0,0,2596,2590,1,0,0,0,2596,2593,1,0,0,0,2597,255,1,0,
  	0,0,2598,2599,5,160,0,0,2599,2617,5,316,0,0,2600,2601,5,160,0,0,2601,
  	2602,5,3,0,0,2602,2603,3,320,160,0,2603,2604,5,4,0,0,2604,2605,5,297,
  	0,0,2605,2606,5,3,0,0,2606,2611,3,338,169,0,2607,2608,5,1,0,0,2608,2610,
  	3,338,169,0,2609,2607,1,0,0,0,2610,2613,1,0,0,0,2611,2609,1,0,0,0,2611,
  	2612,1,0,0,0,2612,2614,1,0,0,0,2613,2611,1,0,0,0,2614,2615,5,4,0,0,2615,
  	2617,1,0,0,0,2616,2598,1,0,0,0,2616,2600,1,0,0,0,2617,257,1,0,0,0,2618,
  	2623,3,260,130,0,2619,2620,5,1,0,0,2620,2622,3,260,130,0,2621,2619,1,
  	0,0,0,2622,2625,1,0,0,0,2623,2621,1,0,0,0,2623,2624,1,0,0,0,2624,259,
  	1,0,0,0,2625,2623,1,0,0,0,2626,2627,3,322,161,0,2627,2628,5,305,0,0,2628,
  	2629,3,338,169,0,2629,261,1,0,0,0,2630,2631,5,301,0,0,2631,2632,3,340,
  	170,0,2632,263,1,0,0,0,2633,2634,5,149,0,0,2634,2635,3,340,170,0,2635,
  	265,1,0,0,0,2636,2637,5,14,0,0,2637,2644,3,268,134,0,2638,2640,5,1,0,
  	0,2639,2638,1,0,0,0,2639,2640,1,0,0,0,2640,2641,1,0,0,0,2641,2643,3,268,
  	134,0,2642,2639,1,0,0,0,2643,2646,1,0,0,0,2644,2642,1,0,0,0,2644,2645,
  	1,0,0,0,2645,2647,1,0,0,0,2646,2644,1,0,0,0,2647,2648,5,15,0,0,2648,267,
  	1,0,0,0,2649,2663,3,412,206,0,2650,2651,3,412,206,0,2651,2652,5,3,0,0,
  	2652,2657,3,346,173,0,2653,2654,5,1,0,0,2654,2656,3,346,173,0,2655,2653,
  	1,0,0,0,2656,2659,1,0,0,0,2657,2655,1,0,0,0,2657,2658,1,0,0,0,2658,2660,
  	1,0,0,0,2659,2657,1,0,0,0,2660,2661,5,4,0,0,2661,2663,1,0,0,0,2662,2649,
  	1,0,0,0,2662,2650,1,0,0,0,2663,269,1,0,0,0,2664,2665,5,141,0,0,2665,2670,
  	3,286,143,0,2666,2667,5,1,0,0,2667,2669,3,286,143,0,2668,2666,1,0,0,0,
  	2669,2672,1,0,0,0,2670,2668,1,0,0,0,2670,2671,1,0,0,0,2671,2676,1,0,0,
  	0,2672,2670,1,0,0,0,2673,2675,3,282,141,0,2674,2673,1,0,0,0,2675,2678,
  	1,0,0,0,2676,2674,1,0,0,0,2676,2677,1,0,0,0,2677,2680,1,0,0,0,2678,2676,
  	1,0,0,0,2679,2681,3,276,138,0,2680,2679,1,0,0,0,2680,2681,1,0,0,0,2681,
  	271,1,0,0,0,2682,2683,5,147,0,0,2683,2684,5,71,0,0,2684,2689,3,338,169,
  	0,2685,2686,5,1,0,0,2686,2688,3,338,169,0,2687,2685,1,0,0,0,2688,2691,
  	1,0,0,0,2689,2687,1,0,0,0,2689,2690,1,0,0,0,2690,2709,1,0,0,0,2691,2689,
  	1,0,0,0,2692,2693,5,303,0,0,2693,2710,5,242,0,0,2694,2695,5,303,0,0,2695,
  	2710,5,96,0,0,2696,2697,5,148,0,0,2697,2698,5,255,0,0,2698,2699,5,3,0,
  	0,2699,2704,3,274,137,0,2700,2701,5,1,0,0,2701,2703,3,274,137,0,2702,
  	2700,1,0,0,0,2703,2706,1,0,0,0,2704,2702,1,0,0,0,2704,2705,1,0,0,0,2705,
  	2707,1,0,0,0,2706,2704,1,0,0,0,2707,2708,5,4,0,0,2708,2710,1,0,0,0,2709,
  	2692,1,0,0,0,2709,2694,1,0,0,0,2709,2696,1,0,0,0,2709,2710,1,0,0,0,2710,
  	2727,1,0,0,0,2711,2712,5,147,0,0,2712,2713,5,71,0,0,2713,2714,5,148,0,
  	0,2714,2715,5,255,0,0,2715,2716,5,3,0,0,2716,2721,3,274,137,0,2717,2718,
  	5,1,0,0,2718,2720,3,274,137,0,2719,2717,1,0,0,0,2720,2723,1,0,0,0,2721,
  	2719,1,0,0,0,2721,2722,1,0,0,0,2722,2724,1,0,0,0,2723,2721,1,0,0,0,2724,
  	2725,5,4,0,0,2725,2727,1,0,0,0,2726,2682,1,0,0,0,2726,2711,1,0,0,0,2727,
  	273,1,0,0,0,2728,2737,5,3,0,0,2729,2734,3,338,169,0,2730,2731,5,1,0,0,
  	2731,2733,3,338,169,0,2732,2730,1,0,0,0,2733,2736,1,0,0,0,2734,2732,1,
  	0,0,0,2734,2735,1,0,0,0,2735,2738,1,0,0,0,2736,2734,1,0,0,0,2737,2729,
  	1,0,0,0,2737,2738,1,0,0,0,2738,2739,1,0,0,0,2739,2742,5,4,0,0,2740,2742,
  	3,338,169,0,2741,2728,1,0,0,0,2741,2740,1,0,0,0,2742,275,1,0,0,0,2743,
  	2744,5,215,0,0,2744,2745,5,3,0,0,2745,2746,3,330,165,0,2746,2747,5,137,
  	0,0,2747,2748,3,278,139,0,2748,2749,5,154,0,0,2749,2750,5,3,0,0,2750,
  	2755,3,280,140,0,2751,2752,5,1,0,0,2752,2754,3,280,140,0,2753,2751,1,
  	0,0,0,2754,2757,1,0,0,0,2755,2753,1,0,0,0,2755,2756,1,0,0,0,2756,2758,
  	1,0,0,0,2757,2755,1,0,0,0,2758,2759,5,4,0,0,2759,2760,5,4,0,0,2760,277,
  	1,0,0,0,2761,2774,3,412,206,0,2762,2763,5,3,0,0,2763,2768,3,412,206,0,
  	2764,2765,5,1,0,0,2765,2767,3,412,206,0,2766,2764,1,0,0,0,2767,2770,1,
  	0,0,0,2768,2766,1,0,0,0,2768,2769,1,0,0,0,2769,2771,1,0,0,0,2770,2768,
  	1,0,0,0,2771,2772,5,4,0,0,2772,2774,1,0,0,0,2773,2761,1,0,0,0,2773,2762,
  	1,0,0,0,2774,279,1,0,0,0,2775,2780,3,338,169,0,2776,2778,5,63,0,0,2777,
  	2776,1,0,0,0,2777,2778,1,0,0,0,2778,2779,1,0,0,0,2779,2781,3,412,206,
  	0,2780,2777,1,0,0,0,2780,2781,1,0,0,0,2781,281,1,0,0,0,2782,2783,5,169,
  	0,0,2783,2785,5,298,0,0,2784,2786,5,205,0,0,2785,2784,1,0,0,0,2785,2786,
  	1,0,0,0,2786,2787,1,0,0,0,2787,2788,3,406,203,0,2788,2797,5,3,0,0,2789,
  	2794,3,338,169,0,2790,2791,5,1,0,0,2791,2793,3,338,169,0,2792,2790,1,
  	0,0,0,2793,2796,1,0,0,0,2794,2792,1,0,0,0,2794,2795,1,0,0,0,2795,2798,
  	1,0,0,0,2796,2794,1,0,0,0,2797,2789,1,0,0,0,2797,2798,1,0,0,0,2798,2799,
  	1,0,0,0,2799,2800,5,4,0,0,2800,2812,3,412,206,0,2801,2803,5,63,0,0,2802,
  	2801,1,0,0,0,2802,2803,1,0,0,0,2803,2804,1,0,0,0,2804,2809,3,412,206,
  	0,2805,2806,5,1,0,0,2806,2808,3,412,206,0,2807,2805,1,0,0,0,2808,2811,
  	1,0,0,0,2809,2807,1,0,0,0,2809,2810,1,0,0,0,2810,2813,1,0,0,0,2811,2809,
  	1,0,0,0,2812,2802,1,0,0,0,2812,2813,1,0,0,0,2813,283,1,0,0,0,2814,2815,
  	7,29,0,0,2815,285,1,0,0,0,2816,2820,3,310,155,0,2817,2819,3,288,144,0,
  	2818,2817,1,0,0,0,2819,2822,1,0,0,0,2820,2818,1,0,0,0,2820,2821,1,0,0,
  	0,2821,287,1,0,0,0,2822,2820,1,0,0,0,2823,2824,3,290,145,0,2824,2825,
  	5,166,0,0,2825,2827,3,310,155,0,2826,2828,3,292,146,0,2827,2826,1,0,0,
  	0,2827,2828,1,0,0,0,2828,2835,1,0,0,0,2829,2830,5,192,0,0,2830,2831,3,
  	290,145,0,2831,2832,5,166,0,0,2832,2833,3,310,155,0,2833,2835,1,0,0,0,
  	2834,2823,1,0,0,0,2834,2829,1,0,0,0,2835,289,1,0,0,0,2836,2838,5,157,
  	0,0,2837,2836,1,0,0,0,2837,2838,1,0,0,0,2838,2861,1,0,0,0,2839,2861,5,
  	95,0,0,2840,2842,5,172,0,0,2841,2843,5,205,0,0,2842,2841,1,0,0,0,2842,
  	2843,1,0,0,0,2843,2861,1,0,0,0,2844,2846,5,172,0,0,2845,2844,1,0,0,0,
  	2845,2846,1,0,0,0,2846,2847,1,0,0,0,2847,2861,5,248,0,0,2848,2850,5,237,
  	0,0,2849,2851,5,205,0,0,2850,2849,1,0,0,0,2850,2851,1,0,0,0,2851,2861,
  	1,0,0,0,2852,2854,5,142,0,0,2853,2855,5,205,0,0,2854,2853,1,0,0,0,2854,
  	2855,1,0,0,0,2855,2861,1,0,0,0,2856,2858,5,172,0,0,2857,2856,1,0,0,0,
  	2857,2858,1,0,0,0,2858,2859,1,0,0,0,2859,2861,5,59,0,0,2860,2837,1,0,
  	0,0,2860,2839,1,0,0,0,2860,2840,1,0,0,0,2860,2845,1,0,0,0,2860,2848,1,
  	0,0,0,2860,2852,1,0,0,0,2860,2857,1,0,0,0,2861,291,1,0,0,0,2862,2863,
  	5,198,0,0,2863,2867,3,340,170,0,2864,2865,5,296,0,0,2865,2867,3,298,149,
  	0,2866,2862,1,0,0,0,2866,2864,1,0,0,0,2867,293,1,0,0,0,2868,2869,5,270,
  	0,0,2869,2871,5,3,0,0,2870,2872,3,296,148,0,2871,2870,1,0,0,0,2871,2872,
  	1,0,0,0,2872,2873,1,0,0,0,2873,2874,5,4,0,0,2874,295,1,0,0,0,2875,2877,
  	5,315,0,0,2876,2875,1,0,0,0,2876,2877,1,0,0,0,2877,2878,1,0,0,0,2878,
  	2879,7,7,0,0,2879,2900,5,214,0,0,2880,2881,3,338,169,0,2881,2882,5,244,
  	0,0,2882,2900,1,0,0,0,2883,2884,5,69,0,0,2884,2885,5,329,0,0,2885,2886,
  	5,204,0,0,2886,2887,5,197,0,0,2887,2896,5,329,0,0,2888,2894,5,198,0,0,
  	2889,2895,3,412,206,0,2890,2891,3,406,203,0,2891,2892,5,3,0,0,2892,2893,
  	5,4,0,0,2893,2895,1,0,0,0,2894,2889,1,0,0,0,2894,2890,1,0,0,0,2895,2897,
  	1,0,0,0,2896,2888,1,0,0,0,2896,2897,1,0,0,0,2897,2900,1,0,0,0,2898,2900,
  	3,338,169,0,2899,2876,1,0,0,0,2899,2880,1,0,0,0,2899,2883,1,0,0,0,2899,
  	2898,1,0,0,0,2900,297,1,0,0,0,2901,2902,5,3,0,0,2902,2903,3,300,150,0,
  	2903,2904,5,4,0,0,2904,299,1,0,0,0,2905,2910,3,408,204,0,2906,2907,5,
  	1,0,0,2907,2909,3,408,204,0,2908,2906,1,0,0,0,2909,2912,1,0,0,0,2910,
  	2908,1,0,0,0,2910,2911,1,0,0,0,2911,301,1,0,0,0,2912,2910,1,0,0,0,2913,
  	2914,5,3,0,0,2914,2919,3,304,152,0,2915,2916,5,1,0,0,2916,2918,3,304,
  	152,0,2917,2915,1,0,0,0,2918,2921,1,0,0,0,2919,2917,1,0,0,0,2919,2920,
  	1,0,0,0,2920,2922,1,0,0,0,2921,2919,1,0,0,0,2922,2923,5,4,0,0,2923,303,
  	1,0,0,0,2924,2926,3,408,204,0,2925,2927,7,10,0,0,2926,2925,1,0,0,0,2926,
  	2927,1,0,0,0,2927,305,1,0,0,0,2928,2929,5,3,0,0,2929,2934,3,308,154,0,
  	2930,2931,5,1,0,0,2931,2933,3,308,154,0,2932,2930,1,0,0,0,2933,2936,1,
  	0,0,0,2934,2932,1,0,0,0,2934,2935,1,0,0,0,2935,2937,1,0,0,0,2936,2934,
  	1,0,0,0,2937,2938,5,4,0,0,2938,307,1,0,0,0,2939,2941,3,412,206,0,2940,
  	2942,3,178,89,0,2941,2940,1,0,0,0,2941,2942,1,0,0,0,2942,309,1,0,0,0,
  	2943,2945,3,322,161,0,2944,2946,3,74,37,0,2945,2944,1,0,0,0,2945,2946,
  	1,0,0,0,2946,2948,1,0,0,0,2947,2949,3,294,147,0,2948,2947,1,0,0,0,2948,
  	2949,1,0,0,0,2949,2950,1,0,0,0,2950,2951,3,316,158,0,2951,2971,1,0,0,
  	0,2952,2953,5,3,0,0,2953,2954,3,180,90,0,2954,2956,5,4,0,0,2955,2957,
  	3,294,147,0,2956,2955,1,0,0,0,2956,2957,1,0,0,0,2957,2958,1,0,0,0,2958,
  	2959,3,316,158,0,2959,2971,1,0,0,0,2960,2961,5,3,0,0,2961,2962,3,286,
  	143,0,2962,2964,5,4,0,0,2963,2965,3,294,147,0,2964,2963,1,0,0,0,2964,
  	2965,1,0,0,0,2965,2966,1,0,0,0,2966,2967,3,316,158,0,2967,2971,1,0,0,
  	0,2968,2971,3,312,156,0,2969,2971,3,314,157,0,2970,2943,1,0,0,0,2970,
  	2952,1,0,0,0,2970,2960,1,0,0,0,2970,2968,1,0,0,0,2970,2969,1,0,0,0,2971,
  	311,1,0,0,0,2972,2973,5,297,0,0,2973,2978,3,338,169,0,2974,2975,5,1,0,
  	0,2975,2977,3,338,169,0,2976,2974,1,0,0,0,2977,2980,1,0,0,0,2978,2976,
  	1,0,0,0,2978,2979,1,0,0,0,2979,2981,1,0,0,0,2980,2978,1,0,0,0,2981,2982,
  	3,316,158,0,2982,313,1,0,0,0,2983,2984,3,408,204,0,2984,2993,5,3,0,0,
  	2985,2990,3,338,169,0,2986,2987,5,1,0,0,2987,2989,3,338,169,0,2988,2986,
  	1,0,0,0,2989,2992,1,0,0,0,2990,2988,1,0,0,0,2990,2991,1,0,0,0,2991,2994,
  	1,0,0,0,2992,2990,1,0,0,0,2993,2985,1,0,0,0,2993,2994,1,0,0,0,2994,2995,
  	1,0,0,0,2995,2996,5,4,0,0,2996,2997,3,316,158,0,2997,315,1,0,0,0,2998,
  	3000,5,63,0,0,2999,2998,1,0,0,0,2999,3000,1,0,0,0,3000,3001,1,0,0,0,3001,
  	3003,3,414,207,0,3002,3004,3,298,149,0,3003,3002,1,0,0,0,3003,3004,1,
  	0,0,0,3004,3006,1,0,0,0,3005,2999,1,0,0,0,3005,3006,1,0,0,0,3006,317,
  	1,0,0,0,3007,3008,5,243,0,0,3008,3009,5,139,0,0,3009,3010,5,250,0,0,3010,
  	3014,5,325,0,0,3011,3012,5,303,0,0,3012,3013,5,251,0,0,3013,3015,3,204,
  	102,0,3014,3011,1,0,0,0,3014,3015,1,0,0,0,3015,3057,1,0,0,0,3016,3017,
  	5,243,0,0,3017,3018,5,139,0,0,3018,3028,5,109,0,0,3019,3020,5,132,0,0,
  	3020,3021,5,273,0,0,3021,3022,5,71,0,0,3022,3026,5,325,0,0,3023,3024,
  	5,121,0,0,3024,3025,5,71,0,0,3025,3027,5,325,0,0,3026,3023,1,0,0,0,3026,
  	3027,1,0,0,0,3027,3029,1,0,0,0,3028,3019,1,0,0,0,3028,3029,1,0,0,0,3029,
  	3035,1,0,0,0,3030,3031,5,83,0,0,3031,3032,5,165,0,0,3032,3033,5,273,0,
  	0,3033,3034,5,71,0,0,3034,3036,5,325,0,0,3035,3030,1,0,0,0,3035,3036,
  	1,0,0,0,3036,3042,1,0,0,0,3037,3038,5,184,0,0,3038,3039,5,167,0,0,3039,
  	3040,5,273,0,0,3040,3041,5,71,0,0,3041,3043,5,325,0,0,3042,3037,1,0,0,
  	0,3042,3043,1,0,0,0,3043,3048,1,0,0,0,3044,3045,5,175,0,0,3045,3046,5,
  	273,0,0,3046,3047,5,71,0,0,3047,3049,5,325,0,0,3048,3044,1,0,0,0,3048,
  	3049,1,0,0,0,3049,3054,1,0,0,0,3050,3051,5,195,0,0,3051,3052,5,107,0,
  	0,3052,3053,5,63,0,0,3053,3055,5,325,0,0,3054,3050,1,0,0,0,3054,3055,
  	1,0,0,0,3055,3057,1,0,0,0,3056,3007,1,0,0,0,3056,3016,1,0,0,0,3057,319,
  	1,0,0,0,3058,3063,3,322,161,0,3059,3060,5,1,0,0,3060,3062,3,322,161,0,
  	3061,3059,1,0,0,0,3062,3065,1,0,0,0,3063,3061,1,0,0,0,3063,3064,1,0,0,
  	0,3064,321,1,0,0,0,3065,3063,1,0,0,0,3066,3071,3,408,204,0,3067,3068,
  	5,7,0,0,3068,3070,3,408,204,0,3069,3067,1,0,0,0,3070,3073,1,0,0,0,3071,
  	3069,1,0,0,0,3071,3072,1,0,0,0,3072,323,1,0,0,0,3073,3071,1,0,0,0,3074,
  	3075,3,408,204,0,3075,3076,5,7,0,0,3076,3078,1,0,0,0,3077,3074,1,0,0,
  	0,3077,3078,1,0,0,0,3078,3079,1,0,0,0,3079,3080,3,408,204,0,3080,325,
  	1,0,0,0,3081,3082,3,408,204,0,3082,3083,5,7,0,0,3083,3085,1,0,0,0,3084,
  	3081,1,0,0,0,3084,3085,1,0,0,0,3085,3086,1,0,0,0,3086,3087,3,408,204,
  	0,3087,327,1,0,0,0,3088,3096,3,338,169,0,3089,3091,5,63,0,0,3090,3089,
  	1,0,0,0,3090,3091,1,0,0,0,3091,3094,1,0,0,0,3092,3095,3,408,204,0,3093,
  	3095,3,298,149,0,3094,3092,1,0,0,0,3094,3093,1,0,0,0,3095,3097,1,0,0,
  	0,3096,3090,1,0,0,0,3096,3097,1,0,0,0,3097,329,1,0,0,0,3098,3103,3,328,
  	164,0,3099,3100,5,1,0,0,3100,3102,3,328,164,0,3101,3099,1,0,0,0,3102,
  	3105,1,0,0,0,3103,3101,1,0,0,0,3103,3104,1,0,0,0,3104,331,1,0,0,0,3105,
  	3103,1,0,0,0,3106,3107,5,3,0,0,3107,3112,3,334,167,0,3108,3109,5,1,0,
  	0,3109,3111,3,334,167,0,3110,3108,1,0,0,0,3111,3114,1,0,0,0,3112,3110,
  	1,0,0,0,3112,3113,1,0,0,0,3113,3115,1,0,0,0,3114,3112,1,0,0,0,3115,3116,
  	5,4,0,0,3116,333,1,0,0,0,3117,3131,3,406,203,0,3118,3119,3,412,206,0,
  	3119,3120,5,3,0,0,3120,3125,3,336,168,0,3121,3122,5,1,0,0,3122,3124,3,
  	336,168,0,3123,3121,1,0,0,0,3124,3127,1,0,0,0,3125,3123,1,0,0,0,3125,
  	3126,1,0,0,0,3126,3128,1,0,0,0,3127,3125,1,0,0,0,3128,3129,5,4,0,0,3129,
  	3131,1,0,0,0,3130,3117,1,0,0,0,3130,3118,1,0,0,0,3131,335,1,0,0,0,3132,
  	3135,3,406,203,0,3133,3135,3,348,174,0,3134,3132,1,0,0,0,3134,3133,1,
  	0,0,0,3135,337,1,0,0,0,3136,3137,3,340,170,0,3137,339,1,0,0,0,3138,3139,
  	6,170,-1,0,3139,3140,5,194,0,0,3140,3151,3,340,170,5,3141,3142,5,124,
  	0,0,3142,3143,5,3,0,0,3143,3144,3,180,90,0,3144,3145,5,4,0,0,3145,3151,
  	1,0,0,0,3146,3148,3,344,172,0,3147,3149,3,342,171,0,3148,3147,1,0,0,0,
  	3148,3149,1,0,0,0,3149,3151,1,0,0,0,3150,3138,1,0,0,0,3150,3141,1,0,0,
  	0,3150,3146,1,0,0,0,3151,3160,1,0,0,0,3152,3153,10,2,0,0,3153,3154,5,
  	58,0,0,3154,3159,3,340,170,3,3155,3156,10,1,0,0,3156,3157,5,202,0,0,3157,
  	3159,3,340,170,2,3158,3152,1,0,0,0,3158,3155,1,0,0,0,3159,3162,1,0,0,
  	0,3160,3158,1,0,0,0,3160,3161,1,0,0,0,3161,341,1,0,0,0,3162,3160,1,0,
  	0,0,3163,3165,5,194,0,0,3164,3163,1,0,0,0,3164,3165,1,0,0,0,3165,3166,
  	1,0,0,0,3166,3167,5,67,0,0,3167,3168,3,344,172,0,3168,3169,5,58,0,0,3169,
  	3170,3,344,172,0,3170,3246,1,0,0,0,3171,3173,5,194,0,0,3172,3171,1,0,
  	0,0,3172,3173,1,0,0,0,3173,3174,1,0,0,0,3174,3175,5,154,0,0,3175,3176,
  	5,3,0,0,3176,3181,3,338,169,0,3177,3178,5,1,0,0,3178,3180,3,338,169,0,
  	3179,3177,1,0,0,0,3180,3183,1,0,0,0,3181,3179,1,0,0,0,3181,3182,1,0,0,
  	0,3182,3184,1,0,0,0,3183,3181,1,0,0,0,3184,3185,5,4,0,0,3185,3246,1,0,
  	0,0,3186,3188,5,194,0,0,3187,3186,1,0,0,0,3187,3188,1,0,0,0,3188,3189,
  	1,0,0,0,3189,3190,5,154,0,0,3190,3191,5,3,0,0,3191,3192,3,180,90,0,3192,
  	3193,5,4,0,0,3193,3246,1,0,0,0,3194,3196,5,194,0,0,3195,3194,1,0,0,0,
  	3195,3196,1,0,0,0,3196,3197,1,0,0,0,3197,3198,5,238,0,0,3198,3246,3,344,
  	172,0,3199,3201,5,194,0,0,3200,3199,1,0,0,0,3200,3201,1,0,0,0,3201,3202,
  	1,0,0,0,3202,3203,5,173,0,0,3203,3217,7,30,0,0,3204,3205,5,3,0,0,3205,
  	3218,5,4,0,0,3206,3207,5,3,0,0,3207,3212,3,338,169,0,3208,3209,5,1,0,
  	0,3209,3211,3,338,169,0,3210,3208,1,0,0,0,3211,3214,1,0,0,0,3212,3210,
  	1,0,0,0,3212,3213,1,0,0,0,3213,3215,1,0,0,0,3214,3212,1,0,0,0,3215,3216,
  	5,4,0,0,3216,3218,1,0,0,0,3217,3204,1,0,0,0,3217,3206,1,0,0,0,3218,3246,
  	1,0,0,0,3219,3221,5,194,0,0,3220,3219,1,0,0,0,3220,3221,1,0,0,0,3221,
  	3222,1,0,0,0,3222,3223,5,173,0,0,3223,3226,3,344,172,0,3224,3225,5,120,
  	0,0,3225,3227,5,325,0,0,3226,3224,1,0,0,0,3226,3227,1,0,0,0,3227,3246,
  	1,0,0,0,3228,3230,5,164,0,0,3229,3231,5,194,0,0,3230,3229,1,0,0,0,3230,
  	3231,1,0,0,0,3231,3232,1,0,0,0,3232,3246,5,195,0,0,3233,3235,5,164,0,
  	0,3234,3236,5,194,0,0,3235,3234,1,0,0,0,3235,3236,1,0,0,0,3236,3237,1,
  	0,0,0,3237,3246,7,31,0,0,3238,3240,5,164,0,0,3239,3241,5,194,0,0,3240,
  	3239,1,0,0,0,3240,3241,1,0,0,0,3241,3242,1,0,0,0,3242,3243,5,115,0,0,
  	3243,3244,5,141,0,0,3244,3246,3,344,172,0,3245,3164,1,0,0,0,3245,3172,
  	1,0,0,0,3245,3187,1,0,0,0,3245,3195,1,0,0,0,3245,3200,1,0,0,0,3245,3220,
  	1,0,0,0,3245,3228,1,0,0,0,3245,3233,1,0,0,0,3245,3238,1,0,0,0,3246,343,
  	1,0,0,0,3247,3248,6,172,-1,0,3248,3252,3,346,173,0,3249,3250,7,32,0,0,
  	3250,3252,3,344,172,7,3251,3247,1,0,0,0,3251,3249,1,0,0,0,3252,3274,1,
  	0,0,0,3253,3254,10,6,0,0,3254,3255,7,33,0,0,3255,3273,3,344,172,7,3256,
  	3257,10,5,0,0,3257,3258,7,34,0,0,3258,3273,3,344,172,6,3259,3260,10,4,
  	0,0,3260,3261,5,321,0,0,3261,3273,3,344,172,5,3262,3263,10,3,0,0,3263,
  	3264,5,324,0,0,3264,3273,3,344,172,4,3265,3266,10,2,0,0,3266,3267,5,322,
  	0,0,3267,3273,3,344,172,3,3268,3269,10,1,0,0,3269,3270,3,350,175,0,3270,
  	3271,3,344,172,2,3271,3273,1,0,0,0,3272,3253,1,0,0,0,3272,3256,1,0,0,
  	0,3272,3259,1,0,0,0,3272,3262,1,0,0,0,3272,3265,1,0,0,0,3272,3268,1,0,
  	0,0,3273,3276,1,0,0,0,3274,3272,1,0,0,0,3274,3275,1,0,0,0,3275,345,1,
  	0,0,0,3276,3274,1,0,0,0,3277,3278,6,173,-1,0,3278,3462,7,35,0,0,3279,
  	3281,5,74,0,0,3280,3282,3,390,195,0,3281,3280,1,0,0,0,3282,3283,1,0,0,
  	0,3283,3281,1,0,0,0,3283,3284,1,0,0,0,3284,3287,1,0,0,0,3285,3286,5,118,
  	0,0,3286,3288,3,338,169,0,3287,3285,1,0,0,0,3287,3288,1,0,0,0,3288,3289,
  	1,0,0,0,3289,3290,5,119,0,0,3290,3462,1,0,0,0,3291,3292,5,74,0,0,3292,
  	3294,3,338,169,0,3293,3295,3,390,195,0,3294,3293,1,0,0,0,3295,3296,1,
  	0,0,0,3296,3294,1,0,0,0,3296,3297,1,0,0,0,3297,3300,1,0,0,0,3298,3299,
  	5,118,0,0,3299,3301,3,338,169,0,3300,3298,1,0,0,0,3300,3301,1,0,0,0,3301,
  	3302,1,0,0,0,3302,3303,5,119,0,0,3303,3462,1,0,0,0,3304,3305,5,75,0,0,
  	3305,3306,5,3,0,0,3306,3307,3,338,169,0,3307,3308,5,63,0,0,3308,3309,
  	3,376,188,0,3309,3310,5,4,0,0,3310,3462,1,0,0,0,3311,3312,5,265,0,0,3312,
  	3321,5,3,0,0,3313,3318,3,328,164,0,3314,3315,5,1,0,0,3315,3317,3,328,
  	164,0,3316,3314,1,0,0,0,3317,3320,1,0,0,0,3318,3316,1,0,0,0,3318,3319,
  	1,0,0,0,3319,3322,1,0,0,0,3320,3318,1,0,0,0,3321,3313,1,0,0,0,3321,3322,
  	1,0,0,0,3322,3323,1,0,0,0,3323,3462,5,4,0,0,3324,3325,5,135,0,0,3325,
  	3326,5,3,0,0,3326,3329,3,338,169,0,3327,3328,5,152,0,0,3328,3330,5,196,
  	0,0,3329,3327,1,0,0,0,3329,3330,1,0,0,0,3330,3331,1,0,0,0,3331,3332,5,
  	4,0,0,3332,3462,1,0,0,0,3333,3334,5,168,0,0,3334,3335,5,3,0,0,3335,3338,
  	3,338,169,0,3336,3337,5,152,0,0,3337,3339,5,196,0,0,3338,3336,1,0,0,0,
  	3338,3339,1,0,0,0,3339,3340,1,0,0,0,3340,3341,5,4,0,0,3341,3462,1,0,0,
  	0,3342,3343,5,217,0,0,3343,3344,5,3,0,0,3344,3345,3,344,172,0,3345,3346,
  	5,154,0,0,3346,3347,3,344,172,0,3347,3348,5,4,0,0,3348,3462,1,0,0,0,3349,
  	3462,3,348,174,0,3350,3462,5,316,0,0,3351,3352,3,406,203,0,3352,3353,
  	5,7,0,0,3353,3354,5,316,0,0,3354,3462,1,0,0,0,3355,3356,5,3,0,0,3356,
  	3359,3,328,164,0,3357,3358,5,1,0,0,3358,3360,3,328,164,0,3359,3357,1,
  	0,0,0,3360,3361,1,0,0,0,3361,3359,1,0,0,0,3361,3362,1,0,0,0,3362,3363,
  	1,0,0,0,3363,3364,5,4,0,0,3364,3462,1,0,0,0,3365,3366,5,3,0,0,3366,3367,
  	3,180,90,0,3367,3368,5,4,0,0,3368,3462,1,0,0,0,3369,3370,3,404,202,0,
  	3370,3382,5,3,0,0,3371,3373,3,284,142,0,3372,3371,1,0,0,0,3372,3373,1,
  	0,0,0,3373,3374,1,0,0,0,3374,3379,3,338,169,0,3375,3376,5,1,0,0,3376,
  	3378,3,338,169,0,3377,3375,1,0,0,0,3378,3381,1,0,0,0,3379,3377,1,0,0,
  	0,3379,3380,1,0,0,0,3380,3383,1,0,0,0,3381,3379,1,0,0,0,3382,3372,1,0,
  	0,0,3382,3383,1,0,0,0,3383,3384,1,0,0,0,3384,3391,5,4,0,0,3385,3386,5,
  	133,0,0,3386,3387,5,3,0,0,3387,3388,5,301,0,0,3388,3389,3,340,170,0,3389,
  	3390,5,4,0,0,3390,3392,1,0,0,0,3391,3385,1,0,0,0,3391,3392,1,0,0,0,3392,
  	3395,1,0,0,0,3393,3394,5,207,0,0,3394,3396,3,396,198,0,3395,3393,1,0,
  	0,0,3395,3396,1,0,0,0,3396,3462,1,0,0,0,3397,3398,3,412,206,0,3398,3399,
  	5,16,0,0,3399,3400,3,338,169,0,3400,3462,1,0,0,0,3401,3402,5,3,0,0,3402,
  	3405,3,412,206,0,3403,3404,5,1,0,0,3404,3406,3,412,206,0,3405,3403,1,
  	0,0,0,3406,3407,1,0,0,0,3407,3405,1,0,0,0,3407,3408,1,0,0,0,3408,3409,
  	1,0,0,0,3409,3410,5,4,0,0,3410,3411,5,16,0,0,3411,3412,3,338,169,0,3412,
  	3462,1,0,0,0,3413,3462,3,412,206,0,3414,3415,5,3,0,0,3415,3416,3,338,
  	169,0,3416,3417,5,4,0,0,3417,3462,1,0,0,0,3418,3419,5,129,0,0,3419,3420,
  	5,3,0,0,3420,3421,3,412,206,0,3421,3422,5,141,0,0,3422,3423,3,344,172,
  	0,3423,3424,5,4,0,0,3424,3462,1,0,0,0,3425,3426,7,36,0,0,3426,3427,5,
  	3,0,0,3427,3428,3,344,172,0,3428,3429,7,37,0,0,3429,3432,3,344,172,0,
  	3430,3431,7,38,0,0,3431,3433,3,344,172,0,3432,3430,1,0,0,0,3432,3433,
  	1,0,0,0,3433,3434,1,0,0,0,3434,3435,5,4,0,0,3435,3462,1,0,0,0,3436,3437,
  	5,281,0,0,3437,3439,5,3,0,0,3438,3440,7,39,0,0,3439,3438,1,0,0,0,3439,
  	3440,1,0,0,0,3440,3442,1,0,0,0,3441,3443,3,344,172,0,3442,3441,1,0,0,
  	0,3442,3443,1,0,0,0,3443,3444,1,0,0,0,3444,3445,5,141,0,0,3445,3446,3,
  	344,172,0,3446,3447,5,4,0,0,3447,3462,1,0,0,0,3448,3449,5,209,0,0,3449,
  	3450,5,3,0,0,3450,3451,3,344,172,0,3451,3452,5,216,0,0,3452,3453,3,344,
  	172,0,3453,3454,5,141,0,0,3454,3457,3,344,172,0,3455,3456,5,137,0,0,3456,
  	3458,3,344,172,0,3457,3455,1,0,0,0,3457,3458,1,0,0,0,3458,3459,1,0,0,
  	0,3459,3460,5,4,0,0,3460,3462,1,0,0,0,3461,3277,1,0,0,0,3461,3279,1,0,
  	0,0,3461,3291,1,0,0,0,3461,3304,1,0,0,0,3461,3311,1,0,0,0,3461,3324,1,
  	0,0,0,3461,3333,1,0,0,0,3461,3342,1,0,0,0,3461,3349,1,0,0,0,3461,3350,
  	1,0,0,0,3461,3351,1,0,0,0,3461,3355,1,0,0,0,3461,3365,1,0,0,0,3461,3369,
  	1,0,0,0,3461,3397,1,0,0,0,3461,3401,1,0,0,0,3461,3413,1,0,0,0,3461,3414,
  	1,0,0,0,3461,3418,1,0,0,0,3461,3425,1,0,0,0,3461,3436,1,0,0,0,3461,3448,
  	1,0,0,0,3462,3473,1,0,0,0,3463,3464,10,8,0,0,3464,3465,5,5,0,0,3465,3466,
  	3,344,172,0,3466,3467,5,6,0,0,3467,3472,1,0,0,0,3468,3469,10,6,0,0,3469,
  	3470,5,7,0,0,3470,3472,3,412,206,0,3471,3463,1,0,0,0,3471,3468,1,0,0,
  	0,3472,3475,1,0,0,0,3473,3471,1,0,0,0,3473,3474,1,0,0,0,3474,347,1,0,
  	0,0,3475,3473,1,0,0,0,3476,3489,5,195,0,0,3477,3489,3,360,180,0,3478,
  	3479,3,412,206,0,3479,3480,5,325,0,0,3480,3489,1,0,0,0,3481,3489,3,418,
  	209,0,3482,3489,3,358,179,0,3483,3485,5,325,0,0,3484,3483,1,0,0,0,3485,
  	3486,1,0,0,0,3486,3484,1,0,0,0,3486,3487,1,0,0,0,3487,3489,1,0,0,0,3488,
  	3476,1,0,0,0,3488,3477,1,0,0,0,3488,3478,1,0,0,0,3488,3481,1,0,0,0,3488,
  	3482,1,0,0,0,3488,3484,1,0,0,0,3489,349,1,0,0,0,3490,3499,3,352,176,0,
  	3491,3499,5,308,0,0,3492,3499,5,309,0,0,3493,3499,5,310,0,0,3494,3499,
  	5,311,0,0,3495,3499,5,312,0,0,3496,3499,5,313,0,0,3497,3499,5,307,0,0,
  	3498,3490,1,0,0,0,3498,3491,1,0,0,0,3498,3492,1,0,0,0,3498,3493,1,0,0,
  	0,3498,3494,1,0,0,0,3498,3495,1,0,0,0,3498,3496,1,0,0,0,3498,3497,1,0,
  	0,0,3499,351,1,0,0,0,3500,3501,7,40,0,0,3501,353,1,0,0,0,3502,3503,7,
  	41,0,0,3503,355,1,0,0,0,3504,3505,7,42,0,0,3505,357,1,0,0,0,3506,3507,
  	7,43,0,0,3507,359,1,0,0,0,3508,3511,5,162,0,0,3509,3512,3,362,181,0,3510,
  	3512,3,366,183,0,3511,3509,1,0,0,0,3511,3510,1,0,0,0,3511,3512,1,0,0,
  	0,3512,361,1,0,0,0,3513,3515,3,364,182,0,3514,3516,3,368,184,0,3515,3514,
  	1,0,0,0,3515,3516,1,0,0,0,3516,363,1,0,0,0,3517,3518,3,370,185,0,3518,
  	3519,3,372,186,0,3519,3521,1,0,0,0,3520,3517,1,0,0,0,3521,3522,1,0,0,
  	0,3522,3520,1,0,0,0,3522,3523,1,0,0,0,3523,365,1,0,0,0,3524,3527,3,368,
  	184,0,3525,3528,3,364,182,0,3526,3528,3,368,184,0,3527,3525,1,0,0,0,3527,
  	3526,1,0,0,0,3527,3528,1,0,0,0,3528,367,1,0,0,0,3529,3530,3,370,185,0,
  	3530,3531,3,372,186,0,3531,3532,5,275,0,0,3532,3533,3,372,186,0,3533,
  	369,1,0,0,0,3534,3536,7,44,0,0,3535,3534,1,0,0,0,3535,3536,1,0,0,0,3536,
  	3537,1,0,0,0,3537,3540,7,7,0,0,3538,3540,5,325,0,0,3539,3535,1,0,0,0,
  	3539,3538,1,0,0,0,3540,371,1,0,0,0,3541,3549,5,105,0,0,3542,3549,5,150,
  	0,0,3543,3549,5,187,0,0,3544,3549,5,188,0,0,3545,3549,5,246,0,0,3546,
  	3549,5,304,0,0,3547,3549,3,412,206,0,3548,3541,1,0,0,0,3548,3542,1,0,
  	0,0,3548,3543,1,0,0,0,3548,3544,1,0,0,0,3548,3545,1,0,0,0,3548,3546,1,
  	0,0,0,3548,3547,1,0,0,0,3549,373,1,0,0,0,3550,3554,5,135,0,0,3551,3552,
  	5,54,0,0,3552,3554,3,408,204,0,3553,3550,1,0,0,0,3553,3551,1,0,0,0,3554,
  	375,1,0,0,0,3555,3556,5,62,0,0,3556,3557,5,310,0,0,3557,3558,3,376,188,
  	0,3558,3559,5,312,0,0,3559,3590,1,0,0,0,3560,3561,5,184,0,0,3561,3562,
  	5,310,0,0,3562,3563,3,376,188,0,3563,3564,5,1,0,0,3564,3565,3,376,188,
  	0,3565,3566,5,312,0,0,3566,3590,1,0,0,0,3567,3574,5,265,0,0,3568,3570,
  	5,310,0,0,3569,3571,3,386,193,0,3570,3569,1,0,0,0,3570,3571,1,0,0,0,3571,
  	3572,1,0,0,0,3572,3575,5,312,0,0,3573,3575,5,308,0,0,3574,3568,1,0,0,
  	0,3574,3573,1,0,0,0,3575,3590,1,0,0,0,3576,3587,3,412,206,0,3577,3578,
  	5,3,0,0,3578,3583,5,329,0,0,3579,3580,5,1,0,0,3580,3582,5,329,0,0,3581,
  	3579,1,0,0,0,3582,3585,1,0,0,0,3583,3581,1,0,0,0,3583,3584,1,0,0,0,3584,
  	3586,1,0,0,0,3585,3583,1,0,0,0,3586,3588,5,4,0,0,3587,3577,1,0,0,0,3587,
  	3588,1,0,0,0,3588,3590,1,0,0,0,3589,3555,1,0,0,0,3589,3560,1,0,0,0,3589,
  	3567,1,0,0,0,3589,3576,1,0,0,0,3590,377,1,0,0,0,3591,3596,3,380,190,0,
  	3592,3593,5,1,0,0,3593,3595,3,380,190,0,3594,3592,1,0,0,0,3595,3598,1,
  	0,0,0,3596,3594,1,0,0,0,3596,3597,1,0,0,0,3597,379,1,0,0,0,3598,3596,
  	1,0,0,0,3599,3600,3,322,161,0,3600,3603,3,376,188,0,3601,3602,5,194,0,
  	0,3602,3604,5,195,0,0,3603,3601,1,0,0,0,3603,3604,1,0,0,0,3604,3606,1,
  	0,0,0,3605,3607,3,178,89,0,3606,3605,1,0,0,0,3606,3607,1,0,0,0,3607,3609,
  	1,0,0,0,3608,3610,3,374,187,0,3609,3608,1,0,0,0,3609,3610,1,0,0,0,3610,
  	381,1,0,0,0,3611,3616,3,384,192,0,3612,3613,5,1,0,0,3613,3615,3,384,192,
  	0,3614,3612,1,0,0,0,3615,3618,1,0,0,0,3616,3614,1,0,0,0,3616,3617,1,0,
  	0,0,3617,383,1,0,0,0,3618,3616,1,0,0,0,3619,3620,3,408,204,0,3620,3623,
  	3,376,188,0,3621,3622,5,194,0,0,3622,3624,5,195,0,0,3623,3621,1,0,0,0,
  	3623,3624,1,0,0,0,3624,3626,1,0,0,0,3625,3627,3,178,89,0,3626,3625,1,
  	0,0,0,3626,3627,1,0,0,0,3627,385,1,0,0,0,3628,3633,3,388,194,0,3629,3630,
  	5,1,0,0,3630,3632,3,388,194,0,3631,3629,1,0,0,0,3632,3635,1,0,0,0,3633,
  	3631,1,0,0,0,3633,3634,1,0,0,0,3634,387,1,0,0,0,3635,3633,1,0,0,0,3636,
  	3637,3,412,206,0,3637,3638,5,2,0,0,3638,3641,3,376,188,0,3639,3640,5,
  	194,0,0,3640,3642,5,195,0,0,3641,3639,1,0,0,0,3641,3642,1,0,0,0,3642,
  	3644,1,0,0,0,3643,3645,3,178,89,0,3644,3643,1,0,0,0,3644,3645,1,0,0,0,
  	3645,389,1,0,0,0,3646,3647,5,300,0,0,3647,3648,3,338,169,0,3648,3649,
  	5,274,0,0,3649,3650,3,338,169,0,3650,391,1,0,0,0,3651,3652,5,302,0,0,
  	3652,3657,3,394,197,0,3653,3654,5,1,0,0,3654,3656,3,394,197,0,3655,3653,
  	1,0,0,0,3656,3659,1,0,0,0,3657,3655,1,0,0,0,3657,3658,1,0,0,0,3658,393,
  	1,0,0,0,3659,3657,1,0,0,0,3660,3661,3,408,204,0,3661,3662,5,63,0,0,3662,
  	3663,3,396,198,0,3663,395,1,0,0,0,3664,3711,3,408,204,0,3665,3666,5,3,
  	0,0,3666,3667,3,408,204,0,3667,3668,5,4,0,0,3668,3711,1,0,0,0,3669,3704,
  	5,3,0,0,3670,3671,5,79,0,0,3671,3672,5,71,0,0,3672,3677,3,338,169,0,3673,
  	3674,5,1,0,0,3674,3676,3,338,169,0,3675,3673,1,0,0,0,3676,3679,1,0,0,
  	0,3677,3675,1,0,0,0,3677,3678,1,0,0,0,3678,3705,1,0,0,0,3679,3677,1,0,
  	0,0,3680,3681,7,45,0,0,3681,3682,5,71,0,0,3682,3687,3,338,169,0,3683,
  	3684,5,1,0,0,3684,3686,3,338,169,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,3691,1,0,0,0,3689,3687,1,0,
  	0,0,3690,3680,1,0,0,0,3690,3691,1,0,0,0,3691,3702,1,0,0,0,3692,3693,7,
  	46,0,0,3693,3694,5,71,0,0,3694,3699,3,234,117,0,3695,3696,5,1,0,0,3696,
  	3698,3,234,117,0,3697,3695,1,0,0,0,3698,3701,1,0,0,0,3699,3697,1,0,0,
  	0,3699,3700,1,0,0,0,3700,3703,1,0,0,0,3701,3699,1,0,0,0,3702,3692,1,0,
  	0,0,3702,3703,1,0,0,0,3703,3705,1,0,0,0,3704,3670,1,0,0,0,3704,3690,1,
  	0,0,0,3705,3707,1,0,0,0,3706,3708,3,398,199,0,3707,3706,1,0,0,0,3707,
  	3708,1,0,0,0,3708,3709,1,0,0,0,3709,3711,5,4,0,0,3710,3664,1,0,0,0,3710,
  	3665,1,0,0,0,3710,3669,1,0,0,0,3711,397,1,0,0,0,3712,3713,5,224,0,0,3713,
  	3729,3,400,200,0,3714,3715,5,244,0,0,3715,3729,3,400,200,0,3716,3717,
  	5,224,0,0,3717,3718,5,67,0,0,3718,3719,3,400,200,0,3719,3720,5,58,0,0,
  	3720,3721,3,400,200,0,3721,3729,1,0,0,0,3722,3723,5,244,0,0,3723,3724,
  	5,67,0,0,3724,3725,3,400,200,0,3725,3726,5,58,0,0,3726,3727,3,400,200,
  	0,3727,3729,1,0,0,0,3728,3712,1,0,0,0,3728,3714,1,0,0,0,3728,3716,1,0,
  	0,0,3728,3722,1,0,0,0,3729,399,1,0,0,0,3730,3731,5,286,0,0,3731,3738,
  	7,47,0,0,3732,3733,5,97,0,0,3733,3738,5,243,0,0,3734,3735,3,338,169,0,
  	3735,3736,7,47,0,0,3736,3738,1,0,0,0,3737,3730,1,0,0,0,3737,3732,1,0,
  	0,0,3737,3734,1,0,0,0,3738,401,1,0,0,0,3739,3744,3,406,203,0,3740,3741,
  	5,1,0,0,3741,3743,3,406,203,0,3742,3740,1,0,0,0,3743,3746,1,0,0,0,3744,
  	3742,1,0,0,0,3744,3745,1,0,0,0,3745,403,1,0,0,0,3746,3744,1,0,0,0,3747,
  	3752,3,406,203,0,3748,3752,5,133,0,0,3749,3752,5,172,0,0,3750,3752,5,
  	237,0,0,3751,3747,1,0,0,0,3751,3748,1,0,0,0,3751,3749,1,0,0,0,3751,3750,
  	1,0,0,0,3752,405,1,0,0,0,3753,3758,3,412,206,0,3754,3755,5,7,0,0,3755,
  	3757,3,412,206,0,3756,3754,1,0,0,0,3757,3760,1,0,0,0,3758,3756,1,0,0,
  	0,3758,3759,1,0,0,0,3759,407,1,0,0,0,3760,3758,1,0,0,0,3761,3762,3,412,
  	206,0,3762,409,1,0,0,0,3763,3764,5,315,0,0,3764,3766,3,412,206,0,3765,
  	3763,1,0,0,0,3766,3767,1,0,0,0,3767,3765,1,0,0,0,3767,3768,1,0,0,0,3768,
  	411,1,0,0,0,3769,3772,3,414,207,0,3770,3772,3,424,212,0,3771,3769,1,0,
  	0,0,3771,3770,1,0,0,0,3772,413,1,0,0,0,3773,3777,5,334,0,0,3774,3777,
  	3,416,208,0,3775,3777,3,426,213,0,3776,3773,1,0,0,0,3776,3774,1,0,0,0,
  	3776,3775,1,0,0,0,3777,415,1,0,0,0,3778,3779,5,335,0,0,3779,417,1,0,0,
  	0,3780,3782,5,315,0,0,3781,3780,1,0,0,0,3781,3782,1,0,0,0,3782,3783,1,
  	0,0,0,3783,3817,5,330,0,0,3784,3786,5,315,0,0,3785,3784,1,0,0,0,3785,
  	3786,1,0,0,0,3786,3787,1,0,0,0,3787,3817,5,331,0,0,3788,3790,5,315,0,
  	0,3789,3788,1,0,0,0,3789,3790,1,0,0,0,3790,3791,1,0,0,0,3791,3817,7,48,
  	0,0,3792,3794,5,315,0,0,3793,3792,1,0,0,0,3793,3794,1,0,0,0,3794,3795,
  	1,0,0,0,3795,3817,5,329,0,0,3796,3798,5,315,0,0,3797,3796,1,0,0,0,3797,
  	3798,1,0,0,0,3798,3799,1,0,0,0,3799,3817,5,326,0,0,3800,3802,5,315,0,
  	0,3801,3800,1,0,0,0,3801,3802,1,0,0,0,3802,3803,1,0,0,0,3803,3817,5,327,
  	0,0,3804,3806,5,315,0,0,3805,3804,1,0,0,0,3805,3806,1,0,0,0,3806,3807,
  	1,0,0,0,3807,3817,5,328,0,0,3808,3810,5,315,0,0,3809,3808,1,0,0,0,3809,
  	3810,1,0,0,0,3810,3811,1,0,0,0,3811,3817,5,332,0,0,3812,3814,5,315,0,
  	0,3813,3812,1,0,0,0,3813,3814,1,0,0,0,3814,3815,1,0,0,0,3815,3817,5,333,
  	0,0,3816,3781,1,0,0,0,3816,3785,1,0,0,0,3816,3789,1,0,0,0,3816,3793,1,
  	0,0,0,3816,3797,1,0,0,0,3816,3801,1,0,0,0,3816,3805,1,0,0,0,3816,3809,
  	1,0,0,0,3816,3813,1,0,0,0,3817,419,1,0,0,0,3818,3819,5,284,0,0,3819,3826,
  	3,376,188,0,3820,3826,3,178,89,0,3821,3826,3,374,187,0,3822,3823,7,49,
  	0,0,3823,3824,5,194,0,0,3824,3826,5,195,0,0,3825,3818,1,0,0,0,3825,3820,
  	1,0,0,0,3825,3821,1,0,0,0,3825,3822,1,0,0,0,3826,421,1,0,0,0,3827,3828,
  	7,50,0,0,3828,423,1,0,0,0,3829,3830,7,51,0,0,3830,425,1,0,0,0,3831,3832,
  	7,52,0,0,3832,427,1,0,0,0,518,431,444,447,451,454,457,473,477,480,485,
  	489,492,500,503,507,510,514,521,528,535,539,548,552,559,563,568,572,577,
  	581,586,590,595,599,603,610,618,622,626,630,633,638,645,648,652,656,659,
  	663,665,669,672,676,679,683,687,690,695,699,702,706,711,716,722,731,736,
  	739,742,745,749,752,755,758,763,766,769,772,774,782,786,791,793,802,810,
  	813,821,827,832,844,848,853,857,864,871,881,884,890,894,897,904,906,916,
  	923,927,931,936,941,944,951,959,964,973,981,987,992,1000,1005,1012,1030,
  	1041,1050,1056,1063,1072,1080,1084,1090,1098,1114,1139,1144,1152,1160,
  	1162,1182,1186,1192,1195,1198,1205,1210,1213,1220,1232,1241,1243,1247,
  	1250,1257,1268,1270,1278,1283,1286,1292,1303,1367,1376,1380,1386,1390,
  	1395,1401,1413,1421,1427,1440,1445,1461,1468,1472,1478,1493,1497,1503,
  	1509,1512,1515,1521,1525,1533,1535,1544,1547,1556,1561,1567,1574,1577,
  	1583,1594,1597,1601,1606,1611,1618,1621,1624,1631,1636,1645,1653,1659,
  	1662,1665,1671,1675,1679,1683,1685,1693,1701,1707,1713,1716,1720,1723,
  	1727,1752,1755,1759,1765,1768,1771,1777,1785,1790,1796,1802,1814,1817,
  	1824,1831,1839,1842,1850,1854,1861,1977,1985,1993,2002,2012,2016,2019,
  	2025,2031,2043,2055,2060,2069,2072,2080,2087,2089,2094,2098,2103,2108,
  	2113,2116,2121,2125,2130,2132,2136,2145,2153,2162,2169,2178,2183,2186,
  	2205,2207,2216,2223,2226,2233,2237,2243,2251,2262,2273,2280,2286,2299,
  	2306,2313,2325,2333,2339,2342,2351,2354,2363,2366,2375,2378,2387,2390,
  	2393,2398,2400,2408,2413,2419,2425,2428,2430,2438,2442,2446,2452,2456,
  	2464,2468,2471,2474,2477,2481,2486,2493,2497,2500,2503,2506,2508,2511,
  	2523,2526,2530,2540,2544,2546,2549,2553,2559,2563,2574,2584,2596,2611,
  	2616,2623,2639,2644,2657,2662,2670,2676,2680,2689,2704,2709,2721,2726,
  	2734,2737,2741,2755,2768,2773,2777,2780,2785,2794,2797,2802,2809,2812,
  	2820,2827,2834,2837,2842,2845,2850,2854,2857,2860,2866,2871,2876,2894,
  	2896,2899,2910,2919,2926,2934,2941,2945,2948,2956,2964,2970,2978,2990,
  	2993,2999,3003,3005,3014,3026,3028,3035,3042,3048,3054,3056,3063,3071,
  	3077,3084,3090,3094,3096,3103,3112,3125,3130,3134,3148,3150,3158,3160,
  	3164,3172,3181,3187,3195,3200,3212,3217,3220,3226,3230,3235,3240,3245,
  	3251,3272,3274,3283,3287,3296,3300,3318,3321,3329,3338,3361,3372,3379,
  	3382,3391,3395,3407,3432,3439,3442,3457,3461,3471,3473,3486,3488,3498,
  	3511,3515,3522,3527,3535,3539,3548,3553,3570,3574,3583,3587,3589,3596,
  	3603,3606,3609,3616,3623,3626,3633,3641,3644,3657,3677,3687,3690,3699,
  	3702,3704,3707,3710,3728,3737,3744,3751,3758,3767,3771,3776,3781,3785,
  	3789,3793,3797,3801,3805,3809,3813,3816,3825
  };
  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);
  }
  fugue_sqlParserStaticData = staticData.release();
}

}

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

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

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

const atn::ATN& fugue_sqlParser::getATN() const {
  return *fugue_sqlParserStaticData->atn;
}

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

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

const dfa::Vocabulary& fugue_sqlParser::getVocabulary() const {
  return fugue_sqlParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView fugue_sqlParser::getSerializedATN() const {
  return fugue_sqlParserStaticData->serializedATN;
}


//----------------- FugueLanguageContext ------------------------------------------------------------------

fugue_sqlParser::FugueLanguageContext::FugueLanguageContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueLanguageContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}

std::vector<fugue_sqlParser::FugueSingleTaskContext *> fugue_sqlParser::FugueLanguageContext::fugueSingleTask() {
  return getRuleContexts<fugue_sqlParser::FugueSingleTaskContext>();
}

fugue_sqlParser::FugueSingleTaskContext* fugue_sqlParser::FugueLanguageContext::fugueSingleTask(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueSingleTaskContext>(i);
}


size_t fugue_sqlParser::FugueLanguageContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueLanguage;
}


std::any fugue_sqlParser::FugueLanguageContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueLanguage(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueLanguageContext* fugue_sqlParser::fugueLanguage() {
  FugueLanguageContext *_localctx = _tracker.createInstance<FugueLanguageContext>(_ctx, getState());
  enterRule(_localctx, 0, fugue_sqlParser::RuleFugueLanguage);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(429); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(428);
      fugueSingleTask();
      setState(431); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (((((_la - 17) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 17)) & ((1ULL << (fugue_sqlParser::FILL - 17))
      | (1ULL << (fugue_sqlParser::TAKE - 17))
      | (1ULL << (fugue_sqlParser::PROCESS - 17))
      | (1ULL << (fugue_sqlParser::OUTPUT - 17))
      | (1ULL << (fugue_sqlParser::OUTTRANSFORM - 17))
      | (1ULL << (fugue_sqlParser::ZIP - 17))
      | (1ULL << (fugue_sqlParser::PRINT - 17))
      | (1ULL << (fugue_sqlParser::SAVE - 17))
      | (1ULL << (fugue_sqlParser::CONNECT - 17))
      | (1ULL << (fugue_sqlParser::SAMPLE - 17))
      | (1ULL << (fugue_sqlParser::SUB - 17))
      | (1ULL << (fugue_sqlParser::ADD - 17))
      | (1ULL << (fugue_sqlParser::AFTER - 17))
      | (1ULL << (fugue_sqlParser::ALL - 17))
      | (1ULL << (fugue_sqlParser::ALTER - 17))
      | (1ULL << (fugue_sqlParser::ANALYZE - 17))
      | (1ULL << (fugue_sqlParser::AND - 17))
      | (1ULL << (fugue_sqlParser::ANTI - 17))
      | (1ULL << (fugue_sqlParser::ANY - 17))
      | (1ULL << (fugue_sqlParser::ARCHIVE - 17))
      | (1ULL << (fugue_sqlParser::ARRAY - 17))
      | (1ULL << (fugue_sqlParser::AS - 17))
      | (1ULL << (fugue_sqlParser::ASC - 17))
      | (1ULL << (fugue_sqlParser::AT - 17))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 17))
      | (1ULL << (fugue_sqlParser::BETWEEN - 17))
      | (1ULL << (fugue_sqlParser::BOTH - 17))
      | (1ULL << (fugue_sqlParser::BUCKET - 17))
      | (1ULL << (fugue_sqlParser::BUCKETS - 17))
      | (1ULL << (fugue_sqlParser::BY - 17))
      | (1ULL << (fugue_sqlParser::CACHE - 17))
      | (1ULL << (fugue_sqlParser::CASCADE - 17))
      | (1ULL << (fugue_sqlParser::CASE - 17))
      | (1ULL << (fugue_sqlParser::CAST - 17))
      | (1ULL << (fugue_sqlParser::CHANGE - 17))
      | (1ULL << (fugue_sqlParser::CHECK - 17))
      | (1ULL << (fugue_sqlParser::CLEAR - 17))
      | (1ULL << (fugue_sqlParser::CLUSTER - 17))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 17)))) != 0) || ((((_la - 81) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 81)) & ((1ULL << (fugue_sqlParser::CODEGEN - 81))
      | (1ULL << (fugue_sqlParser::COLLATE - 81))
      | (1ULL << (fugue_sqlParser::COLLECTION - 81))
      | (1ULL << (fugue_sqlParser::COLUMN - 81))
      | (1ULL << (fugue_sqlParser::COLUMNS - 81))
      | (1ULL << (fugue_sqlParser::COMMENT - 81))
      | (1ULL << (fugue_sqlParser::COMMIT - 81))
      | (1ULL << (fugue_sqlParser::COMPACT - 81))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 81))
      | (1ULL << (fugue_sqlParser::COMPUTE - 81))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 81))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 81))
      | (1ULL << (fugue_sqlParser::COST - 81))
      | (1ULL << (fugue_sqlParser::CREATE - 81))
      | (1ULL << (fugue_sqlParser::CROSS - 81))
      | (1ULL << (fugue_sqlParser::CUBE - 81))
      | (1ULL << (fugue_sqlParser::CURRENT - 81))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 81))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 81))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 81))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 81))
      | (1ULL << (fugue_sqlParser::DATA - 81))
      | (1ULL << (fugue_sqlParser::DATABASE - 81))
      | (1ULL << (fugue_sqlParser::DATABASES - 81))
      | (1ULL << (fugue_sqlParser::DAY - 81))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 81))
      | (1ULL << (fugue_sqlParser::DEFINED - 81))
      | (1ULL << (fugue_sqlParser::DELETE - 81))
      | (1ULL << (fugue_sqlParser::DELIMITED - 81))
      | (1ULL << (fugue_sqlParser::DESC - 81))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 81))
      | (1ULL << (fugue_sqlParser::DFS - 81))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 81))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 81))
      | (1ULL << (fugue_sqlParser::DISTINCT - 81))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 81))
      | (1ULL << (fugue_sqlParser::DROP - 81))
      | (1ULL << (fugue_sqlParser::ELSE - 81))
      | (1ULL << (fugue_sqlParser::END - 81))
      | (1ULL << (fugue_sqlParser::ESCAPE - 81))
      | (1ULL << (fugue_sqlParser::ESCAPED - 81))
      | (1ULL << (fugue_sqlParser::EXCEPT - 81))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 81))
      | (1ULL << (fugue_sqlParser::EXISTS - 81))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 81))
      | (1ULL << (fugue_sqlParser::EXPORT - 81))
      | (1ULL << (fugue_sqlParser::EXTENDED - 81))
      | (1ULL << (fugue_sqlParser::EXTERNAL - 81))
      | (1ULL << (fugue_sqlParser::EXTRACT - 81))
      | (1ULL << (fugue_sqlParser::FALSE - 81))
      | (1ULL << (fugue_sqlParser::FETCH - 81))
      | (1ULL << (fugue_sqlParser::FIELDS - 81))
      | (1ULL << (fugue_sqlParser::FILTER - 81))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 81))
      | (1ULL << (fugue_sqlParser::FIRST - 81))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 81))
      | (1ULL << (fugue_sqlParser::FOR - 81))
      | (1ULL << (fugue_sqlParser::FOREIGN - 81))
      | (1ULL << (fugue_sqlParser::FORMAT - 81))
      | (1ULL << (fugue_sqlParser::FORMATTED - 81))
      | (1ULL << (fugue_sqlParser::FROM - 81))
      | (1ULL << (fugue_sqlParser::FULL - 81))
      | (1ULL << (fugue_sqlParser::FUNCTION - 81))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 81)))) != 0) || ((((_la - 145) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 145)) & ((1ULL << (fugue_sqlParser::GLOBAL - 145))
      | (1ULL << (fugue_sqlParser::GRANT - 145))
      | (1ULL << (fugue_sqlParser::GROUP - 145))
      | (1ULL << (fugue_sqlParser::GROUPING - 145))
      | (1ULL << (fugue_sqlParser::HAVING - 145))
      | (1ULL << (fugue_sqlParser::HOUR - 145))
      | (1ULL << (fugue_sqlParser::IF - 145))
      | (1ULL << (fugue_sqlParser::IGNORE - 145))
      | (1ULL << (fugue_sqlParser::IMPORT - 145))
      | (1ULL << (fugue_sqlParser::IN - 145))
      | (1ULL << (fugue_sqlParser::INDEX - 145))
      | (1ULL << (fugue_sqlParser::INDEXES - 145))
      | (1ULL << (fugue_sqlParser::INNER - 145))
      | (1ULL << (fugue_sqlParser::INPATH - 145))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 145))
      | (1ULL << (fugue_sqlParser::INSERT - 145))
      | (1ULL << (fugue_sqlParser::INTERSECT - 145))
      | (1ULL << (fugue_sqlParser::INTERVAL - 145))
      | (1ULL << (fugue_sqlParser::INTO - 145))
      | (1ULL << (fugue_sqlParser::IS - 145))
      | (1ULL << (fugue_sqlParser::ITEMS - 145))
      | (1ULL << (fugue_sqlParser::JOIN - 145))
      | (1ULL << (fugue_sqlParser::KEYS - 145))
      | (1ULL << (fugue_sqlParser::LAST - 145))
      | (1ULL << (fugue_sqlParser::LATERAL - 145))
      | (1ULL << (fugue_sqlParser::LAZY - 145))
      | (1ULL << (fugue_sqlParser::LEADING - 145))
      | (1ULL << (fugue_sqlParser::LEFT - 145))
      | (1ULL << (fugue_sqlParser::LIKE - 145))
      | (1ULL << (fugue_sqlParser::LIMIT - 145))
      | (1ULL << (fugue_sqlParser::LINES - 145))
      | (1ULL << (fugue_sqlParser::LIST - 145))
      | (1ULL << (fugue_sqlParser::LOAD - 145))
      | (1ULL << (fugue_sqlParser::LOCAL - 145))
      | (1ULL << (fugue_sqlParser::LOCATION - 145))
      | (1ULL << (fugue_sqlParser::LOCK - 145))
      | (1ULL << (fugue_sqlParser::LOCKS - 145))
      | (1ULL << (fugue_sqlParser::LOGICAL - 145))
      | (1ULL << (fugue_sqlParser::MACRO - 145))
      | (1ULL << (fugue_sqlParser::MAP - 145))
      | (1ULL << (fugue_sqlParser::MATCHED - 145))
      | (1ULL << (fugue_sqlParser::MERGE - 145))
      | (1ULL << (fugue_sqlParser::MINUTE - 145))
      | (1ULL << (fugue_sqlParser::MONTH - 145))
      | (1ULL << (fugue_sqlParser::MSCK - 145))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 145))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 145))
      | (1ULL << (fugue_sqlParser::NATURAL - 145))
      | (1ULL << (fugue_sqlParser::NO - 145))
      | (1ULL << (fugue_sqlParser::NOT - 145))
      | (1ULL << (fugue_sqlParser::THENULL - 145))
      | (1ULL << (fugue_sqlParser::THENULLS - 145))
      | (1ULL << (fugue_sqlParser::OF - 145))
      | (1ULL << (fugue_sqlParser::ON - 145))
      | (1ULL << (fugue_sqlParser::ONLY - 145))
      | (1ULL << (fugue_sqlParser::OPTION - 145))
      | (1ULL << (fugue_sqlParser::OPTIONS - 145))
      | (1ULL << (fugue_sqlParser::OR - 145))
      | (1ULL << (fugue_sqlParser::ORDER - 145))
      | (1ULL << (fugue_sqlParser::OUT - 145))
      | (1ULL << (fugue_sqlParser::OUTER - 145))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 145))
      | (1ULL << (fugue_sqlParser::OVER - 145))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 145)))) != 0) || ((((_la - 209) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 209)) & ((1ULL << (fugue_sqlParser::OVERLAY - 209))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 209))
      | (1ULL << (fugue_sqlParser::PARTITION - 209))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 209))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 209))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 209))
      | (1ULL << (fugue_sqlParser::PIVOT - 209))
      | (1ULL << (fugue_sqlParser::PLACING - 209))
      | (1ULL << (fugue_sqlParser::POSITION - 209))
      | (1ULL << (fugue_sqlParser::PRECEDING - 209))
      | (1ULL << (fugue_sqlParser::PRIMARY - 209))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 209))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 209))
      | (1ULL << (fugue_sqlParser::PURGE - 209))
      | (1ULL << (fugue_sqlParser::QUERY - 209))
      | (1ULL << (fugue_sqlParser::RANGE - 209))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 209))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 209))
      | (1ULL << (fugue_sqlParser::RECOVER - 209))
      | (1ULL << (fugue_sqlParser::REDUCE - 209))
      | (1ULL << (fugue_sqlParser::REFERENCES - 209))
      | (1ULL << (fugue_sqlParser::REFRESH - 209))
      | (1ULL << (fugue_sqlParser::RENAME - 209))
      | (1ULL << (fugue_sqlParser::REPAIR - 209))
      | (1ULL << (fugue_sqlParser::REPLACE - 209))
      | (1ULL << (fugue_sqlParser::RESET - 209))
      | (1ULL << (fugue_sqlParser::RESTRICT - 209))
      | (1ULL << (fugue_sqlParser::REVOKE - 209))
      | (1ULL << (fugue_sqlParser::RIGHT - 209))
      | (1ULL << (fugue_sqlParser::RLIKE - 209))
      | (1ULL << (fugue_sqlParser::ROLE - 209))
      | (1ULL << (fugue_sqlParser::ROLES - 209))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 209))
      | (1ULL << (fugue_sqlParser::ROLLUP - 209))
      | (1ULL << (fugue_sqlParser::ROW - 209))
      | (1ULL << (fugue_sqlParser::ROWS - 209))
      | (1ULL << (fugue_sqlParser::SCHEMA - 209))
      | (1ULL << (fugue_sqlParser::SECOND - 209))
      | (1ULL << (fugue_sqlParser::SELECT - 209))
      | (1ULL << (fugue_sqlParser::SEMI - 209))
      | (1ULL << (fugue_sqlParser::SEPARATED - 209))
      | (1ULL << (fugue_sqlParser::SERDE - 209))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 209))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 209))
      | (1ULL << (fugue_sqlParser::SET - 209))
      | (1ULL << (fugue_sqlParser::SETMINUS - 209))
      | (1ULL << (fugue_sqlParser::SETS - 209))
      | (1ULL << (fugue_sqlParser::SHOW - 209))
      | (1ULL << (fugue_sqlParser::SKEWED - 209))
      | (1ULL << (fugue_sqlParser::SOME - 209))
      | (1ULL << (fugue_sqlParser::SORT - 209))
      | (1ULL << (fugue_sqlParser::SORTED - 209))
      | (1ULL << (fugue_sqlParser::START - 209))
      | (1ULL << (fugue_sqlParser::STATISTICS - 209))
      | (1ULL << (fugue_sqlParser::STORED - 209))
      | (1ULL << (fugue_sqlParser::STRATIFY - 209))
      | (1ULL << (fugue_sqlParser::STRUCT - 209))
      | (1ULL << (fugue_sqlParser::SUBSTR - 209))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 209))
      | (1ULL << (fugue_sqlParser::TABLE - 209))
      | (1ULL << (fugue_sqlParser::TABLES - 209))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 209))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 209))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 209)))) != 0) || ((((_la - 273) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 273)) & ((1ULL << (fugue_sqlParser::TERMINATED - 273))
      | (1ULL << (fugue_sqlParser::THEN - 273))
      | (1ULL << (fugue_sqlParser::TO - 273))
      | (1ULL << (fugue_sqlParser::TOUCH - 273))
      | (1ULL << (fugue_sqlParser::TRAILING - 273))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 273))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 273))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 273))
      | (1ULL << (fugue_sqlParser::TRIM - 273))
      | (1ULL << (fugue_sqlParser::TRUE - 273))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 273))
      | (1ULL << (fugue_sqlParser::TYPE - 273))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 273))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 273))
      | (1ULL << (fugue_sqlParser::UNCACHE - 273))
      | (1ULL << (fugue_sqlParser::UNION - 273))
      | (1ULL << (fugue_sqlParser::UNIQUE - 273))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 273))
      | (1ULL << (fugue_sqlParser::UNLOCK - 273))
      | (1ULL << (fugue_sqlParser::UNSET - 273))
      | (1ULL << (fugue_sqlParser::UPDATE - 273))
      | (1ULL << (fugue_sqlParser::USE - 273))
      | (1ULL << (fugue_sqlParser::USER - 273))
      | (1ULL << (fugue_sqlParser::USING - 273))
      | (1ULL << (fugue_sqlParser::VALUES - 273))
      | (1ULL << (fugue_sqlParser::VIEW - 273))
      | (1ULL << (fugue_sqlParser::VIEWS - 273))
      | (1ULL << (fugue_sqlParser::WHEN - 273))
      | (1ULL << (fugue_sqlParser::WHERE - 273))
      | (1ULL << (fugue_sqlParser::WINDOW - 273))
      | (1ULL << (fugue_sqlParser::WITH - 273))
      | (1ULL << (fugue_sqlParser::YEAR - 273))
      | (1ULL << (fugue_sqlParser::DIV - 273))
      | (1ULL << (fugue_sqlParser::IDENTIFIER - 273))
      | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 273)))) != 0));
    setState(433);
    match(fugue_sqlParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSingleStatementContext ------------------------------------------------------------------

fugue_sqlParser::FugueSingleStatementContext::FugueSingleStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueSingleTaskContext* fugue_sqlParser::FugueSingleStatementContext::fugueSingleTask() {
  return getRuleContext<fugue_sqlParser::FugueSingleTaskContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueSingleStatementContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::FugueSingleStatementContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSingleStatement;
}


std::any fugue_sqlParser::FugueSingleStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSingleStatement(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSingleStatementContext* fugue_sqlParser::fugueSingleStatement() {
  FugueSingleStatementContext *_localctx = _tracker.createInstance<FugueSingleStatementContext>(_ctx, getState());
  enterRule(_localctx, 2, fugue_sqlParser::RuleFugueSingleStatement);

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

  return _localctx;
}

//----------------- FugueSingleTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueSingleTaskContext::FugueSingleTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueNestableTaskContext* fugue_sqlParser::FugueSingleTaskContext::fugueNestableTask() {
  return getRuleContext<fugue_sqlParser::FugueNestableTaskContext>(0);
}

fugue_sqlParser::FugueOutputTransformTaskContext* fugue_sqlParser::FugueSingleTaskContext::fugueOutputTransformTask() {
  return getRuleContext<fugue_sqlParser::FugueOutputTransformTaskContext>(0);
}

fugue_sqlParser::FugueOutputTaskContext* fugue_sqlParser::FugueSingleTaskContext::fugueOutputTask() {
  return getRuleContext<fugue_sqlParser::FugueOutputTaskContext>(0);
}

fugue_sqlParser::FuguePrintTaskContext* fugue_sqlParser::FugueSingleTaskContext::fuguePrintTask() {
  return getRuleContext<fugue_sqlParser::FuguePrintTaskContext>(0);
}

fugue_sqlParser::FugueSaveTaskContext* fugue_sqlParser::FugueSingleTaskContext::fugueSaveTask() {
  return getRuleContext<fugue_sqlParser::FugueSaveTaskContext>(0);
}

fugue_sqlParser::FugueModuleTaskContext* fugue_sqlParser::FugueSingleTaskContext::fugueModuleTask() {
  return getRuleContext<fugue_sqlParser::FugueModuleTaskContext>(0);
}


size_t fugue_sqlParser::FugueSingleTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSingleTask;
}


std::any fugue_sqlParser::FugueSingleTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSingleTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSingleTaskContext* fugue_sqlParser::fugueSingleTask() {
  FugueSingleTaskContext *_localctx = _tracker.createInstance<FugueSingleTaskContext>(_ctx, getState());
  enterRule(_localctx, 4, fugue_sqlParser::RuleFugueSingleTask);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(439);
      fugueOutputTransformTask();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(440);
      fugueOutputTask();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(441);
      fuguePrintTask();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(442);
      fugueSaveTask();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(443);
      fugueModuleTask();
      break;
    }

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

  return _localctx;
}

//----------------- FugueNestableTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueNestableTaskContext::FugueNestableTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::QueryContext* fugue_sqlParser::FugueNestableTaskContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::FugueAssignmentContext* fugue_sqlParser::FugueNestableTaskContext::fugueAssignment() {
  return getRuleContext<fugue_sqlParser::FugueAssignmentContext>(0);
}

fugue_sqlParser::FugueCheckpointContext* fugue_sqlParser::FugueNestableTaskContext::fugueCheckpoint() {
  return getRuleContext<fugue_sqlParser::FugueCheckpointContext>(0);
}

fugue_sqlParser::FugueBroadcastContext* fugue_sqlParser::FugueNestableTaskContext::fugueBroadcast() {
  return getRuleContext<fugue_sqlParser::FugueBroadcastContext>(0);
}

fugue_sqlParser::FugueYieldContext* fugue_sqlParser::FugueNestableTaskContext::fugueYield() {
  return getRuleContext<fugue_sqlParser::FugueYieldContext>(0);
}


size_t fugue_sqlParser::FugueNestableTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueNestableTask;
}


std::any fugue_sqlParser::FugueNestableTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueNestableTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueNestableTaskContext* fugue_sqlParser::fugueNestableTask() {
  FugueNestableTaskContext *_localctx = _tracker.createInstance<FugueNestableTaskContext>(_ctx, getState());
  enterRule(_localctx, 6, fugue_sqlParser::RuleFugueNestableTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 2, _ctx)) {
    case 1: {
      setState(446);
      antlrcpp::downCast<FugueNestableTaskContext *>(_localctx)->assign = fugueAssignment();
      break;
    }

    default:
      break;
    }
    setState(449);
    antlrcpp::downCast<FugueNestableTaskContext *>(_localctx)->q = query();
    setState(451);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 3, _ctx)) {
    case 1: {
      setState(450);
      antlrcpp::downCast<FugueNestableTaskContext *>(_localctx)->checkpoint = fugueCheckpoint();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::BROADCAST) {
      setState(453);
      antlrcpp::downCast<FugueNestableTaskContext *>(_localctx)->broadcast = fugueBroadcast();
    }
    setState(457);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::YIELD) {
      setState(456);
      antlrcpp::downCast<FugueNestableTaskContext *>(_localctx)->y = fugueYield();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueNestableTaskCollectionNoSelectContext ------------------------------------------------------------------

fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::FugueNestableTaskCollectionNoSelectContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueTransformTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueTransformTask() {
  return getRuleContext<fugue_sqlParser::FugueTransformTaskContext>(0);
}

fugue_sqlParser::FugueProcessTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueProcessTask() {
  return getRuleContext<fugue_sqlParser::FugueProcessTaskContext>(0);
}

fugue_sqlParser::FugueZipTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueZipTask() {
  return getRuleContext<fugue_sqlParser::FugueZipTaskContext>(0);
}

fugue_sqlParser::FugueCreateTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueCreateTask() {
  return getRuleContext<fugue_sqlParser::FugueCreateTaskContext>(0);
}

fugue_sqlParser::FugueCreateDataTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueCreateDataTask() {
  return getRuleContext<fugue_sqlParser::FugueCreateDataTaskContext>(0);
}

fugue_sqlParser::FugueLoadTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueLoadTask() {
  return getRuleContext<fugue_sqlParser::FugueLoadTaskContext>(0);
}

fugue_sqlParser::FugueSaveAndUseTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueSaveAndUseTask() {
  return getRuleContext<fugue_sqlParser::FugueSaveAndUseTaskContext>(0);
}

fugue_sqlParser::FugueRenameColumnsTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueRenameColumnsTask() {
  return getRuleContext<fugue_sqlParser::FugueRenameColumnsTaskContext>(0);
}

fugue_sqlParser::FugueAlterColumnsTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueAlterColumnsTask() {
  return getRuleContext<fugue_sqlParser::FugueAlterColumnsTaskContext>(0);
}

fugue_sqlParser::FugueDropColumnsTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueDropColumnsTask() {
  return getRuleContext<fugue_sqlParser::FugueDropColumnsTaskContext>(0);
}

fugue_sqlParser::FugueDropnaTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueDropnaTask() {
  return getRuleContext<fugue_sqlParser::FugueDropnaTaskContext>(0);
}

fugue_sqlParser::FugueFillnaTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueFillnaTask() {
  return getRuleContext<fugue_sqlParser::FugueFillnaTaskContext>(0);
}

fugue_sqlParser::FugueSampleTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueSampleTask() {
  return getRuleContext<fugue_sqlParser::FugueSampleTaskContext>(0);
}

fugue_sqlParser::FugueTakeTaskContext* fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::fugueTakeTask() {
  return getRuleContext<fugue_sqlParser::FugueTakeTaskContext>(0);
}


size_t fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueNestableTaskCollectionNoSelect;
}


std::any fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueNestableTaskCollectionNoSelect(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext* fugue_sqlParser::fugueNestableTaskCollectionNoSelect() {
  FugueNestableTaskCollectionNoSelectContext *_localctx = _tracker.createInstance<FugueNestableTaskCollectionNoSelectContext>(_ctx, getState());
  enterRule(_localctx, 8, fugue_sqlParser::RuleFugueNestableTaskCollectionNoSelect);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(460);
      fugueProcessTask();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(461);
      fugueZipTask();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(462);
      fugueCreateTask();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(463);
      fugueCreateDataTask();
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(464);
      fugueLoadTask();
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(465);
      fugueSaveAndUseTask();
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(466);
      fugueRenameColumnsTask();
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(467);
      fugueAlterColumnsTask();
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(468);
      fugueDropColumnsTask();
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(469);
      fugueDropnaTask();
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(470);
      fugueFillnaTask();
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(471);
      fugueSampleTask();
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(472);
      fugueTakeTask();
      break;
    }

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

  return _localctx;
}

//----------------- FugueTransformTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueTransformTaskContext::FugueTransformTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueTransformTaskContext::TRANSFORM() {
  return getToken(fugue_sqlParser::TRANSFORM, 0);
}

fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext* fugue_sqlParser::FugueTransformTaskContext::fugueSingleOutputExtensionCommonWild() {
  return getRuleContext<fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueTransformTaskContext::CALLBACK() {
  return getToken(fugue_sqlParser::CALLBACK, 0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FugueTransformTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueTransformTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueTransformTaskContext::fugueExtension() {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(0);
}


size_t fugue_sqlParser::FugueTransformTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueTransformTask;
}


std::any fugue_sqlParser::FugueTransformTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueTransformTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueTransformTaskContext* fugue_sqlParser::fugueTransformTask() {
  FugueTransformTaskContext *_localctx = _tracker.createInstance<FugueTransformTaskContext>(_ctx, getState());
  enterRule(_localctx, 10, fugue_sqlParser::RuleFugueTransformTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {
    case 1: {
      setState(476);
      antlrcpp::downCast<FugueTransformTaskContext *>(_localctx)->dfs = fugueDataFrames();
      break;
    }

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN)
      | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
      setState(479);
      antlrcpp::downCast<FugueTransformTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(482);
    antlrcpp::downCast<FugueTransformTaskContext *>(_localctx)->params = fugueSingleOutputExtensionCommonWild();
    setState(485);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
    case 1: {
      setState(483);
      match(fugue_sqlParser::CALLBACK);
      setState(484);
      antlrcpp::downCast<FugueTransformTaskContext *>(_localctx)->callback = fugueExtension();
      break;
    }

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

  return _localctx;
}

//----------------- FugueProcessTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueProcessTaskContext::FugueProcessTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueProcessTaskContext::PROCESS() {
  return getToken(fugue_sqlParser::PROCESS, 0);
}

fugue_sqlParser::FugueSingleOutputExtensionCommonContext* fugue_sqlParser::FugueProcessTaskContext::fugueSingleOutputExtensionCommon() {
  return getRuleContext<fugue_sqlParser::FugueSingleOutputExtensionCommonContext>(0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FugueProcessTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueProcessTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}


size_t fugue_sqlParser::FugueProcessTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueProcessTask;
}


std::any fugue_sqlParser::FugueProcessTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueProcessTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueProcessTaskContext* fugue_sqlParser::fugueProcessTask() {
  FugueProcessTaskContext *_localctx = _tracker.createInstance<FugueProcessTaskContext>(_ctx, getState());
  enterRule(_localctx, 12, fugue_sqlParser::RuleFugueProcessTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {
    case 1: {
      setState(488);
      antlrcpp::downCast<FugueProcessTaskContext *>(_localctx)->dfs = fugueDataFrames();
      break;
    }

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN)
      | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
      setState(491);
      antlrcpp::downCast<FugueProcessTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(494);
    antlrcpp::downCast<FugueProcessTaskContext *>(_localctx)->params = fugueSingleOutputExtensionCommon();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSaveAndUseTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueSaveAndUseTaskContext::FugueSaveAndUseTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSaveAndUseTaskContext::SAVE() {
  return getToken(fugue_sqlParser::SAVE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSaveAndUseTaskContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSaveAndUseTaskContext::USE() {
  return getToken(fugue_sqlParser::USE, 0);
}

fugue_sqlParser::FugueSaveModeContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fugueSaveMode() {
  return getRuleContext<fugue_sqlParser::FugueSaveModeContext>(0);
}

fugue_sqlParser::FuguePathContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fuguePath() {
  return getRuleContext<fugue_sqlParser::FuguePathContext>(0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueSingleFileContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fugueSingleFile() {
  return getRuleContext<fugue_sqlParser::FugueSingleFileContext>(0);
}

fugue_sqlParser::FugueFileFormatContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fugueFileFormat() {
  return getRuleContext<fugue_sqlParser::FugueFileFormatContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueSaveAndUseTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}


size_t fugue_sqlParser::FugueSaveAndUseTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSaveAndUseTask;
}


std::any fugue_sqlParser::FugueSaveAndUseTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSaveAndUseTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSaveAndUseTaskContext* fugue_sqlParser::fugueSaveAndUseTask() {
  FugueSaveAndUseTaskContext *_localctx = _tracker.createInstance<FugueSaveAndUseTaskContext>(_ctx, getState());
  enterRule(_localctx, 14, fugue_sqlParser::RuleFugueSaveAndUseTask);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(496);
    match(fugue_sqlParser::SAVE);
    setState(497);
    match(fugue_sqlParser::AND);
    setState(498);
    match(fugue_sqlParser::USE);
    setState(500);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {
    case 1: {
      setState(499);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN)
      | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
      setState(502);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(505);
    antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->m = fugueSaveMode();
    setState(507);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::SINGLE) {
      setState(506);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->single = fugueSingleFile();
    }
    setState(510);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::PARQUET)
      | (1ULL << fugue_sqlParser::CSV)
      | (1ULL << fugue_sqlParser::JSON))) != 0)) {
      setState(509);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->fmt = fugueFileFormat();
    }
    setState(512);
    antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->path = fuguePath();
    setState(514);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx)) {
    case 1: {
      setState(513);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->params = fugueParams();
      break;
    }

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

  return _localctx;
}

//----------------- FugueRenameColumnsTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueRenameColumnsTaskContext::FugueRenameColumnsTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueRenameColumnsTaskContext::RENAME() {
  return getToken(fugue_sqlParser::RENAME, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueRenameColumnsTaskContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::FugueRenameExpressionContext* fugue_sqlParser::FugueRenameColumnsTaskContext::fugueRenameExpression() {
  return getRuleContext<fugue_sqlParser::FugueRenameExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueRenameColumnsTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueRenameColumnsTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueRenameColumnsTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueRenameColumnsTask;
}


std::any fugue_sqlParser::FugueRenameColumnsTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueRenameColumnsTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueRenameColumnsTaskContext* fugue_sqlParser::fugueRenameColumnsTask() {
  FugueRenameColumnsTaskContext *_localctx = _tracker.createInstance<FugueRenameColumnsTaskContext>(_ctx, getState());
  enterRule(_localctx, 16, fugue_sqlParser::RuleFugueRenameColumnsTask);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(516);
    match(fugue_sqlParser::RENAME);
    setState(517);
    match(fugue_sqlParser::COLUMNS);
    setState(518);
    antlrcpp::downCast<FugueRenameColumnsTaskContext *>(_localctx)->cols = fugueRenameExpression();
    setState(521);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {
    case 1: {
      setState(519);
      match(fugue_sqlParser::FROM);
      setState(520);
      antlrcpp::downCast<FugueRenameColumnsTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

  return _localctx;
}

//----------------- FugueAlterColumnsTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueAlterColumnsTaskContext::FugueAlterColumnsTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueAlterColumnsTaskContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueAlterColumnsTaskContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::FugueAlterColumnsTaskContext::fugueSchema() {
  return getRuleContext<fugue_sqlParser::FugueSchemaContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueAlterColumnsTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueAlterColumnsTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueAlterColumnsTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueAlterColumnsTask;
}


std::any fugue_sqlParser::FugueAlterColumnsTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueAlterColumnsTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueAlterColumnsTaskContext* fugue_sqlParser::fugueAlterColumnsTask() {
  FugueAlterColumnsTaskContext *_localctx = _tracker.createInstance<FugueAlterColumnsTaskContext>(_ctx, getState());
  enterRule(_localctx, 18, fugue_sqlParser::RuleFugueAlterColumnsTask);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(523);
    match(fugue_sqlParser::ALTER);
    setState(524);
    match(fugue_sqlParser::COLUMNS);
    setState(525);
    antlrcpp::downCast<FugueAlterColumnsTaskContext *>(_localctx)->cols = fugueSchema();
    setState(528);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
    case 1: {
      setState(526);
      match(fugue_sqlParser::FROM);
      setState(527);
      antlrcpp::downCast<FugueAlterColumnsTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

  return _localctx;
}

//----------------- FugueDropColumnsTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueDropColumnsTaskContext::FugueDropColumnsTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueDropColumnsTaskContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropColumnsTaskContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::FugueDropColumnsTaskContext::fugueCols() {
  return getRuleContext<fugue_sqlParser::FugueColsContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropColumnsTaskContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropColumnsTaskContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropColumnsTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueDropColumnsTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueDropColumnsTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueDropColumnsTask;
}


std::any fugue_sqlParser::FugueDropColumnsTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDropColumnsTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueDropColumnsTaskContext* fugue_sqlParser::fugueDropColumnsTask() {
  FugueDropColumnsTaskContext *_localctx = _tracker.createInstance<FugueDropColumnsTaskContext>(_ctx, getState());
  enterRule(_localctx, 20, fugue_sqlParser::RuleFugueDropColumnsTask);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(530);
    match(fugue_sqlParser::DROP);
    setState(531);
    match(fugue_sqlParser::COLUMNS);
    setState(532);
    antlrcpp::downCast<FugueDropColumnsTaskContext *>(_localctx)->cols = fugueCols();
    setState(535);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {
    case 1: {
      setState(533);
      match(fugue_sqlParser::IF);
      setState(534);
      match(fugue_sqlParser::EXISTS);
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx)) {
    case 1: {
      setState(537);
      match(fugue_sqlParser::FROM);
      setState(538);
      antlrcpp::downCast<FugueDropColumnsTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

  return _localctx;
}

//----------------- FugueDropnaTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueDropnaTaskContext::FugueDropnaTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::ALL() {
  return getToken(fugue_sqlParser::ALL, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::ANY() {
  return getToken(fugue_sqlParser::ANY, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueDropnaTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::FugueDropnaTaskContext::fugueCols() {
  return getRuleContext<fugue_sqlParser::FugueColsContext>(0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueDropnaTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueDropnaTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueDropnaTask;
}


std::any fugue_sqlParser::FugueDropnaTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDropnaTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueDropnaTaskContext* fugue_sqlParser::fugueDropnaTask() {
  FugueDropnaTaskContext *_localctx = _tracker.createInstance<FugueDropnaTaskContext>(_ctx, getState());
  enterRule(_localctx, 22, fugue_sqlParser::RuleFugueDropnaTask);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(541);
    match(fugue_sqlParser::DROP);
    setState(542);
    match(fugue_sqlParser::ROWS);
    setState(543);
    match(fugue_sqlParser::IF);
    setState(544);
    antlrcpp::downCast<FugueDropnaTaskContext *>(_localctx)->how = _input->LT(1);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::ALL

    || _la == fugue_sqlParser::ANY)) {
      antlrcpp::downCast<FugueDropnaTaskContext *>(_localctx)->how = _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(545);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::THENULL

    || _la == fugue_sqlParser::THENULLS)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(548);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {
    case 1: {
      setState(546);
      match(fugue_sqlParser::ON);
      setState(547);
      antlrcpp::downCast<FugueDropnaTaskContext *>(_localctx)->cols = fugueCols();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
    case 1: {
      setState(550);
      match(fugue_sqlParser::FROM);
      setState(551);
      antlrcpp::downCast<FugueDropnaTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

  return _localctx;
}

//----------------- FugueFillnaTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueFillnaTaskContext::FugueFillnaTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueFillnaTaskContext::FILL() {
  return getToken(fugue_sqlParser::FILL, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueFillnaTaskContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueFillnaTaskContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueFillnaTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueFillnaTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueFillnaTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueFillnaTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueFillnaTask;
}


std::any fugue_sqlParser::FugueFillnaTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueFillnaTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueFillnaTaskContext* fugue_sqlParser::fugueFillnaTask() {
  FugueFillnaTaskContext *_localctx = _tracker.createInstance<FugueFillnaTaskContext>(_ctx, getState());
  enterRule(_localctx, 24, fugue_sqlParser::RuleFugueFillnaTask);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(554);
    match(fugue_sqlParser::FILL);
    setState(555);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::THENULL

    || _la == fugue_sqlParser::THENULLS)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(556);
    antlrcpp::downCast<FugueFillnaTaskContext *>(_localctx)->params = fugueParams();
    setState(559);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
    case 1: {
      setState(557);
      match(fugue_sqlParser::FROM);
      setState(558);
      antlrcpp::downCast<FugueFillnaTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

  return _localctx;
}

//----------------- FugueSampleTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueSampleTaskContext::FugueSampleTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSampleTaskContext::SAMPLE() {
  return getToken(fugue_sqlParser::SAMPLE, 0);
}

fugue_sqlParser::FugueSampleMethodContext* fugue_sqlParser::FugueSampleTaskContext::fugueSampleMethod() {
  return getRuleContext<fugue_sqlParser::FugueSampleMethodContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleTaskContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleTaskContext::SEED() {
  return getToken(fugue_sqlParser::SEED, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleTaskContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueSampleTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueSampleTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSampleTask;
}


std::any fugue_sqlParser::FugueSampleTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSampleTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSampleTaskContext* fugue_sqlParser::fugueSampleTask() {
  FugueSampleTaskContext *_localctx = _tracker.createInstance<FugueSampleTaskContext>(_ctx, getState());
  enterRule(_localctx, 26, fugue_sqlParser::RuleFugueSampleTask);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::REPLACE) {
      setState(562);
      match(fugue_sqlParser::REPLACE);
    }
    setState(565);
    antlrcpp::downCast<FugueSampleTaskContext *>(_localctx)->method = fugueSampleMethod();
    setState(568);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 25, _ctx)) {
    case 1: {
      setState(566);
      match(fugue_sqlParser::SEED);
      setState(567);
      antlrcpp::downCast<FugueSampleTaskContext *>(_localctx)->seed = match(fugue_sqlParser::INTEGER_VALUE);
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 26, _ctx)) {
    case 1: {
      setState(570);
      match(fugue_sqlParser::FROM);
      setState(571);
      antlrcpp::downCast<FugueSampleTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

  return _localctx;
}

//----------------- FugueTakeTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueTakeTaskContext::FugueTakeTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::TAKE() {
  return getToken(fugue_sqlParser::TAKE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueTakeTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::PRESORT() {
  return getToken(fugue_sqlParser::PRESORT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::FIRST() {
  return getToken(fugue_sqlParser::FIRST, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueTakeTaskContext::LAST() {
  return getToken(fugue_sqlParser::LAST, 0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueTakeTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueColsSortContext* fugue_sqlParser::FugueTakeTaskContext::fugueColsSort() {
  return getRuleContext<fugue_sqlParser::FugueColsSortContext>(0);
}


size_t fugue_sqlParser::FugueTakeTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueTakeTask;
}


std::any fugue_sqlParser::FugueTakeTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueTakeTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueTakeTaskContext* fugue_sqlParser::fugueTakeTask() {
  FugueTakeTaskContext *_localctx = _tracker.createInstance<FugueTakeTaskContext>(_ctx, getState());
  enterRule(_localctx, 28, fugue_sqlParser::RuleFugueTakeTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
    case 1: {
      setState(575);
      antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->rows = match(fugue_sqlParser::INTEGER_VALUE);
      setState(576);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ROW

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
    case 1: {
      setState(579);
      match(fugue_sqlParser::FROM);
      setState(580);
      antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 29, _ctx)) {
    case 1: {
      setState(583);
      antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->partition = fuguePrepartition();
      break;
    }

    case 2: {
      setState(584);
      match(fugue_sqlParser::PRESORT);
      setState(585);
      antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->presort = fugueColsSort();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 30, _ctx)) {
    case 1: {
      setState(588);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::THENULL

      || _la == fugue_sqlParser::THENULLS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(589);
      antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->na_position = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FIRST

      || _la == fugue_sqlParser::LAST)) {
        antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->na_position = _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;
}

//----------------- FugueZipTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueZipTaskContext::FugueZipTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueZipTaskContext::ZIP() {
  return getToken(fugue_sqlParser::ZIP, 0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FugueZipTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTaskContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTaskContext::PRESORT() {
  return getToken(fugue_sqlParser::PRESORT, 0);
}

fugue_sqlParser::FugueZipTypeContext* fugue_sqlParser::FugueZipTaskContext::fugueZipType() {
  return getRuleContext<fugue_sqlParser::FugueZipTypeContext>(0);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::FugueZipTaskContext::fugueCols() {
  return getRuleContext<fugue_sqlParser::FugueColsContext>(0);
}

fugue_sqlParser::FugueColsSortContext* fugue_sqlParser::FugueZipTaskContext::fugueColsSort() {
  return getRuleContext<fugue_sqlParser::FugueColsSortContext>(0);
}


size_t fugue_sqlParser::FugueZipTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueZipTask;
}


std::any fugue_sqlParser::FugueZipTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueZipTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueZipTaskContext* fugue_sqlParser::fugueZipTask() {
  FugueZipTaskContext *_localctx = _tracker.createInstance<FugueZipTaskContext>(_ctx, getState());
  enterRule(_localctx, 30, fugue_sqlParser::RuleFugueZipTask);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(592);
    match(fugue_sqlParser::ZIP);
    setState(593);
    antlrcpp::downCast<FugueZipTaskContext *>(_localctx)->dfs = fugueDataFrames();
    setState(595);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 31, _ctx)) {
    case 1: {
      setState(594);
      antlrcpp::downCast<FugueZipTaskContext *>(_localctx)->how = fugueZipType();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 32, _ctx)) {
    case 1: {
      setState(597);
      match(fugue_sqlParser::BY);
      setState(598);
      antlrcpp::downCast<FugueZipTaskContext *>(_localctx)->by = fugueCols();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 33, _ctx)) {
    case 1: {
      setState(601);
      match(fugue_sqlParser::PRESORT);
      setState(602);
      antlrcpp::downCast<FugueZipTaskContext *>(_localctx)->presort = fugueColsSort();
      break;
    }

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

  return _localctx;
}

//----------------- FugueCreateTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueCreateTaskContext::FugueCreateTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueCreateTaskContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

fugue_sqlParser::FugueSingleOutputExtensionCommonContext* fugue_sqlParser::FugueCreateTaskContext::fugueSingleOutputExtensionCommon() {
  return getRuleContext<fugue_sqlParser::FugueSingleOutputExtensionCommonContext>(0);
}


size_t fugue_sqlParser::FugueCreateTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueCreateTask;
}


std::any fugue_sqlParser::FugueCreateTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCreateTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueCreateTaskContext* fugue_sqlParser::fugueCreateTask() {
  FugueCreateTaskContext *_localctx = _tracker.createInstance<FugueCreateTaskContext>(_ctx, getState());
  enterRule(_localctx, 32, fugue_sqlParser::RuleFugueCreateTask);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(605);
    match(fugue_sqlParser::CREATE);
    setState(606);
    antlrcpp::downCast<FugueCreateTaskContext *>(_localctx)->params = fugueSingleOutputExtensionCommon();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueCreateDataTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueCreateDataTaskContext::FugueCreateDataTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueCreateDataTaskContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCreateDataTaskContext::SCHEMA() {
  return getToken(fugue_sqlParser::SCHEMA, 0);
}

fugue_sqlParser::FugueJsonArrayContext* fugue_sqlParser::FugueCreateDataTaskContext::fugueJsonArray() {
  return getRuleContext<fugue_sqlParser::FugueJsonArrayContext>(0);
}

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::FugueCreateDataTaskContext::fugueSchema() {
  return getRuleContext<fugue_sqlParser::FugueSchemaContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueCreateDataTaskContext::DATA() {
  return getToken(fugue_sqlParser::DATA, 0);
}


size_t fugue_sqlParser::FugueCreateDataTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueCreateDataTask;
}


std::any fugue_sqlParser::FugueCreateDataTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCreateDataTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueCreateDataTaskContext* fugue_sqlParser::fugueCreateDataTask() {
  FugueCreateDataTaskContext *_localctx = _tracker.createInstance<FugueCreateDataTaskContext>(_ctx, getState());
  enterRule(_localctx, 34, fugue_sqlParser::RuleFugueCreateDataTask);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::DATA) {
      setState(609);
      match(fugue_sqlParser::DATA);
    }
    setState(612);
    antlrcpp::downCast<FugueCreateDataTaskContext *>(_localctx)->data = fugueJsonArray();
    setState(613);
    match(fugue_sqlParser::SCHEMA);
    setState(614);
    antlrcpp::downCast<FugueCreateDataTaskContext *>(_localctx)->schema = fugueSchema();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueLoadTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueLoadTaskContext::FugueLoadTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueLoadTaskContext::LOAD() {
  return getToken(fugue_sqlParser::LOAD, 0);
}

fugue_sqlParser::FuguePathContext* fugue_sqlParser::FugueLoadTaskContext::fuguePath() {
  return getRuleContext<fugue_sqlParser::FuguePathContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueLoadTaskContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::FugueFileFormatContext* fugue_sqlParser::FugueLoadTaskContext::fugueFileFormat() {
  return getRuleContext<fugue_sqlParser::FugueFileFormatContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueLoadTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

fugue_sqlParser::FugueLoadColumnsContext* fugue_sqlParser::FugueLoadTaskContext::fugueLoadColumns() {
  return getRuleContext<fugue_sqlParser::FugueLoadColumnsContext>(0);
}


size_t fugue_sqlParser::FugueLoadTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueLoadTask;
}


std::any fugue_sqlParser::FugueLoadTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueLoadTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueLoadTaskContext* fugue_sqlParser::fugueLoadTask() {
  FugueLoadTaskContext *_localctx = _tracker.createInstance<FugueLoadTaskContext>(_ctx, getState());
  enterRule(_localctx, 36, fugue_sqlParser::RuleFugueLoadTask);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::PARQUET)
      | (1ULL << fugue_sqlParser::CSV)
      | (1ULL << fugue_sqlParser::JSON))) != 0)) {
      setState(617);
      antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->fmt = fugueFileFormat();
    }
    setState(620);
    antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->path = fuguePath();
    setState(622);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 36, _ctx)) {
    case 1: {
      setState(621);
      antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->params = fugueParams();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 37, _ctx)) {
    case 1: {
      setState(624);
      match(fugue_sqlParser::COLUMNS);
      setState(625);
      antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->columns = fugueLoadColumns();
      break;
    }

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

  return _localctx;
}

//----------------- FugueOutputTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueOutputTaskContext::FugueOutputTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueOutputTaskContext::OUTPUT() {
  return getToken(fugue_sqlParser::OUTPUT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueOutputTaskContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueOutputTaskContext::fugueExtension() {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FugueOutputTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueOutputTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueOutputTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}


size_t fugue_sqlParser::FugueOutputTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueOutputTask;
}


std::any fugue_sqlParser::FugueOutputTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueOutputTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueOutputTaskContext* fugue_sqlParser::fugueOutputTask() {
  FugueOutputTaskContext *_localctx = _tracker.createInstance<FugueOutputTaskContext>(_ctx, getState());
  enterRule(_localctx, 38, fugue_sqlParser::RuleFugueOutputTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 38, _ctx)) {
    case 1: {
      setState(629);
      antlrcpp::downCast<FugueOutputTaskContext *>(_localctx)->dfs = fugueDataFrames();
      break;
    }

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN)
      | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
      setState(632);
      antlrcpp::downCast<FugueOutputTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(635);
    match(fugue_sqlParser::USING);
    setState(636);
    antlrcpp::downCast<FugueOutputTaskContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(638);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::T__7)
      | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
      setState(637);
      antlrcpp::downCast<FugueOutputTaskContext *>(_localctx)->params = fugueParams();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FuguePrintTaskContext ------------------------------------------------------------------

fugue_sqlParser::FuguePrintTaskContext::FuguePrintTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::PRINT() {
  return getToken(fugue_sqlParser::PRINT, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::TITLE() {
  return getToken(fugue_sqlParser::TITLE, 0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FuguePrintTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::ROWCOUNT() {
  return getToken(fugue_sqlParser::ROWCOUNT, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrintTaskContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::FuguePrintTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePrintTask;
}


std::any fugue_sqlParser::FuguePrintTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFuguePrintTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FuguePrintTaskContext* fugue_sqlParser::fuguePrintTask() {
  FuguePrintTaskContext *_localctx = _tracker.createInstance<FuguePrintTaskContext>(_ctx, getState());
  enterRule(_localctx, 40, fugue_sqlParser::RuleFuguePrintTask);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(665);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 47, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(640);
      match(fugue_sqlParser::PRINT);
      setState(641);
      antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->rows = match(fugue_sqlParser::INTEGER_VALUE);
      setState(642);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ROW

      || _la == fugue_sqlParser::ROWS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(645);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 41, _ctx)) {
      case 1: {
        setState(643);
        match(fugue_sqlParser::FROM);
        setState(644);
        antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->dfs = fugueDataFrames();
        break;
      }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ROWCOUNT) {
        setState(647);
        antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->count = match(fugue_sqlParser::ROWCOUNT);
      }
      setState(652);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TITLE) {
        setState(650);
        match(fugue_sqlParser::TITLE);
        setState(651);
        antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->title = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(654);
      match(fugue_sqlParser::PRINT);
      setState(656);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 44, _ctx)) {
      case 1: {
        setState(655);
        antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->dfs = fugueDataFrames();
        break;
      }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ROWCOUNT) {
        setState(658);
        antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->count = match(fugue_sqlParser::ROWCOUNT);
      }
      setState(663);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TITLE) {
        setState(661);
        match(fugue_sqlParser::TITLE);
        setState(662);
        antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->title = match(fugue_sqlParser::STRING);
      }
      break;
    }

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

  return _localctx;
}

//----------------- FugueSaveTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueSaveTaskContext::FugueSaveTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSaveTaskContext::SAVE() {
  return getToken(fugue_sqlParser::SAVE, 0);
}

fugue_sqlParser::FugueSaveModeContext* fugue_sqlParser::FugueSaveTaskContext::fugueSaveMode() {
  return getRuleContext<fugue_sqlParser::FugueSaveModeContext>(0);
}

fugue_sqlParser::FuguePathContext* fugue_sqlParser::FugueSaveTaskContext::fuguePath() {
  return getRuleContext<fugue_sqlParser::FuguePathContext>(0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueSaveTaskContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueSaveTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueSingleFileContext* fugue_sqlParser::FugueSaveTaskContext::fugueSingleFile() {
  return getRuleContext<fugue_sqlParser::FugueSingleFileContext>(0);
}

fugue_sqlParser::FugueFileFormatContext* fugue_sqlParser::FugueSaveTaskContext::fugueFileFormat() {
  return getRuleContext<fugue_sqlParser::FugueFileFormatContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueSaveTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}


size_t fugue_sqlParser::FugueSaveTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSaveTask;
}


std::any fugue_sqlParser::FugueSaveTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSaveTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSaveTaskContext* fugue_sqlParser::fugueSaveTask() {
  FugueSaveTaskContext *_localctx = _tracker.createInstance<FugueSaveTaskContext>(_ctx, getState());
  enterRule(_localctx, 42, fugue_sqlParser::RuleFugueSaveTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 48, _ctx)) {
    case 1: {
      setState(668);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->df = fugueDataFrame();
      break;
    }

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN)
      | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
      setState(671);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(674);
    antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->m = fugueSaveMode();
    setState(676);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::SINGLE) {
      setState(675);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->single = fugueSingleFile();
    }
    setState(679);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::PARQUET)
      | (1ULL << fugue_sqlParser::CSV)
      | (1ULL << fugue_sqlParser::JSON))) != 0)) {
      setState(678);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->fmt = fugueFileFormat();
    }
    setState(681);
    antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->path = fuguePath();
    setState(683);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::T__7)
      | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
      setState(682);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->params = fugueParams();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueOutputTransformTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueOutputTransformTaskContext::FugueOutputTransformTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueOutputTransformTaskContext::OUTTRANSFORM() {
  return getToken(fugue_sqlParser::OUTTRANSFORM, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueOutputTransformTaskContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

std::vector<fugue_sqlParser::FugueExtensionContext *> fugue_sqlParser::FugueOutputTransformTaskContext::fugueExtension() {
  return getRuleContexts<fugue_sqlParser::FugueExtensionContext>();
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueOutputTransformTaskContext::fugueExtension(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::FugueOutputTransformTaskContext::CALLBACK() {
  return getToken(fugue_sqlParser::CALLBACK, 0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FugueOutputTransformTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueOutputTransformTaskContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueOutputTransformTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}


size_t fugue_sqlParser::FugueOutputTransformTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueOutputTransformTask;
}


std::any fugue_sqlParser::FugueOutputTransformTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueOutputTransformTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueOutputTransformTaskContext* fugue_sqlParser::fugueOutputTransformTask() {
  FugueOutputTransformTaskContext *_localctx = _tracker.createInstance<FugueOutputTransformTaskContext>(_ctx, getState());
  enterRule(_localctx, 44, fugue_sqlParser::RuleFugueOutputTransformTask);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 53, _ctx)) {
    case 1: {
      setState(686);
      antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->dfs = fugueDataFrames();
      break;
    }

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

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN)
      | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
      setState(689);
      antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(692);
    match(fugue_sqlParser::USING);
    setState(693);
    antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(695);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::T__7)
      | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
      setState(694);
      antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->params = fugueParams();
    }
    setState(699);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::CALLBACK) {
      setState(697);
      match(fugue_sqlParser::CALLBACK);
      setState(698);
      antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->callback = fugueExtension();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueModuleTaskContext ------------------------------------------------------------------

fugue_sqlParser::FugueModuleTaskContext::FugueModuleTaskContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueModuleTaskContext::SUB() {
  return getToken(fugue_sqlParser::SUB, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueModuleTaskContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueModuleTaskContext::fugueExtension() {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(0);
}

fugue_sqlParser::FugueAssignmentContext* fugue_sqlParser::FugueModuleTaskContext::fugueAssignment() {
  return getRuleContext<fugue_sqlParser::FugueAssignmentContext>(0);
}

fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::FugueModuleTaskContext::fugueDataFrames() {
  return getRuleContext<fugue_sqlParser::FugueDataFramesContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueModuleTaskContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}


size_t fugue_sqlParser::FugueModuleTaskContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueModuleTask;
}


std::any fugue_sqlParser::FugueModuleTaskContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueModuleTask(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueModuleTaskContext* fugue_sqlParser::fugueModuleTask() {
  FugueModuleTaskContext *_localctx = _tracker.createInstance<FugueModuleTaskContext>(_ctx, getState());
  enterRule(_localctx, 46, fugue_sqlParser::RuleFugueModuleTask);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (((((_la - 53) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 53)) & ((1ULL << (fugue_sqlParser::ADD - 53))
      | (1ULL << (fugue_sqlParser::AFTER - 53))
      | (1ULL << (fugue_sqlParser::ALL - 53))
      | (1ULL << (fugue_sqlParser::ALTER - 53))
      | (1ULL << (fugue_sqlParser::ANALYZE - 53))
      | (1ULL << (fugue_sqlParser::AND - 53))
      | (1ULL << (fugue_sqlParser::ANTI - 53))
      | (1ULL << (fugue_sqlParser::ANY - 53))
      | (1ULL << (fugue_sqlParser::ARCHIVE - 53))
      | (1ULL << (fugue_sqlParser::ARRAY - 53))
      | (1ULL << (fugue_sqlParser::AS - 53))
      | (1ULL << (fugue_sqlParser::ASC - 53))
      | (1ULL << (fugue_sqlParser::AT - 53))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 53))
      | (1ULL << (fugue_sqlParser::BETWEEN - 53))
      | (1ULL << (fugue_sqlParser::BOTH - 53))
      | (1ULL << (fugue_sqlParser::BUCKET - 53))
      | (1ULL << (fugue_sqlParser::BUCKETS - 53))
      | (1ULL << (fugue_sqlParser::BY - 53))
      | (1ULL << (fugue_sqlParser::CACHE - 53))
      | (1ULL << (fugue_sqlParser::CASCADE - 53))
      | (1ULL << (fugue_sqlParser::CASE - 53))
      | (1ULL << (fugue_sqlParser::CAST - 53))
      | (1ULL << (fugue_sqlParser::CHANGE - 53))
      | (1ULL << (fugue_sqlParser::CHECK - 53))
      | (1ULL << (fugue_sqlParser::CLEAR - 53))
      | (1ULL << (fugue_sqlParser::CLUSTER - 53))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 53))
      | (1ULL << (fugue_sqlParser::CODEGEN - 53))
      | (1ULL << (fugue_sqlParser::COLLATE - 53))
      | (1ULL << (fugue_sqlParser::COLLECTION - 53))
      | (1ULL << (fugue_sqlParser::COLUMN - 53))
      | (1ULL << (fugue_sqlParser::COLUMNS - 53))
      | (1ULL << (fugue_sqlParser::COMMENT - 53))
      | (1ULL << (fugue_sqlParser::COMMIT - 53))
      | (1ULL << (fugue_sqlParser::COMPACT - 53))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 53))
      | (1ULL << (fugue_sqlParser::COMPUTE - 53))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 53))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 53))
      | (1ULL << (fugue_sqlParser::COST - 53))
      | (1ULL << (fugue_sqlParser::CREATE - 53))
      | (1ULL << (fugue_sqlParser::CROSS - 53))
      | (1ULL << (fugue_sqlParser::CUBE - 53))
      | (1ULL << (fugue_sqlParser::CURRENT - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 53))
      | (1ULL << (fugue_sqlParser::DATA - 53))
      | (1ULL << (fugue_sqlParser::DATABASE - 53))
      | (1ULL << (fugue_sqlParser::DATABASES - 53))
      | (1ULL << (fugue_sqlParser::DAY - 53))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 53))
      | (1ULL << (fugue_sqlParser::DEFINED - 53))
      | (1ULL << (fugue_sqlParser::DELETE - 53))
      | (1ULL << (fugue_sqlParser::DELIMITED - 53))
      | (1ULL << (fugue_sqlParser::DESC - 53))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 53))
      | (1ULL << (fugue_sqlParser::DFS - 53))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 53))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 53))
      | (1ULL << (fugue_sqlParser::DISTINCT - 53))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 53)))) != 0) || ((((_la - 117) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 117)) & ((1ULL << (fugue_sqlParser::DROP - 117))
      | (1ULL << (fugue_sqlParser::ELSE - 117))
      | (1ULL << (fugue_sqlParser::END - 117))
      | (1ULL << (fugue_sqlParser::ESCAPE - 117))
      | (1ULL << (fugue_sqlParser::ESCAPED - 117))
      | (1ULL << (fugue_sqlParser::EXCEPT - 117))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 117))
      | (1ULL << (fugue_sqlParser::EXISTS - 117))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 117))
      | (1ULL << (fugue_sqlParser::EXPORT - 117))
      | (1ULL << (fugue_sqlParser::EXTENDED - 117))
      | (1ULL << (fugue_sqlParser::EXTERNAL - 117))
      | (1ULL << (fugue_sqlParser::EXTRACT - 117))
      | (1ULL << (fugue_sqlParser::FALSE - 117))
      | (1ULL << (fugue_sqlParser::FETCH - 117))
      | (1ULL << (fugue_sqlParser::FIELDS - 117))
      | (1ULL << (fugue_sqlParser::FILTER - 117))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 117))
      | (1ULL << (fugue_sqlParser::FIRST - 117))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 117))
      | (1ULL << (fugue_sqlParser::FOR - 117))
      | (1ULL << (fugue_sqlParser::FOREIGN - 117))
      | (1ULL << (fugue_sqlParser::FORMAT - 117))
      | (1ULL << (fugue_sqlParser::FORMATTED - 117))
      | (1ULL << (fugue_sqlParser::FROM - 117))
      | (1ULL << (fugue_sqlParser::FULL - 117))
      | (1ULL << (fugue_sqlParser::FUNCTION - 117))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 117))
      | (1ULL << (fugue_sqlParser::GLOBAL - 117))
      | (1ULL << (fugue_sqlParser::GRANT - 117))
      | (1ULL << (fugue_sqlParser::GROUP - 117))
      | (1ULL << (fugue_sqlParser::GROUPING - 117))
      | (1ULL << (fugue_sqlParser::HAVING - 117))
      | (1ULL << (fugue_sqlParser::HOUR - 117))
      | (1ULL << (fugue_sqlParser::IF - 117))
      | (1ULL << (fugue_sqlParser::IGNORE - 117))
      | (1ULL << (fugue_sqlParser::IMPORT - 117))
      | (1ULL << (fugue_sqlParser::IN - 117))
      | (1ULL << (fugue_sqlParser::INDEX - 117))
      | (1ULL << (fugue_sqlParser::INDEXES - 117))
      | (1ULL << (fugue_sqlParser::INNER - 117))
      | (1ULL << (fugue_sqlParser::INPATH - 117))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 117))
      | (1ULL << (fugue_sqlParser::INSERT - 117))
      | (1ULL << (fugue_sqlParser::INTERSECT - 117))
      | (1ULL << (fugue_sqlParser::INTERVAL - 117))
      | (1ULL << (fugue_sqlParser::INTO - 117))
      | (1ULL << (fugue_sqlParser::IS - 117))
      | (1ULL << (fugue_sqlParser::ITEMS - 117))
      | (1ULL << (fugue_sqlParser::JOIN - 117))
      | (1ULL << (fugue_sqlParser::KEYS - 117))
      | (1ULL << (fugue_sqlParser::LAST - 117))
      | (1ULL << (fugue_sqlParser::LATERAL - 117))
      | (1ULL << (fugue_sqlParser::LAZY - 117))
      | (1ULL << (fugue_sqlParser::LEADING - 117))
      | (1ULL << (fugue_sqlParser::LEFT - 117))
      | (1ULL << (fugue_sqlParser::LIKE - 117))
      | (1ULL << (fugue_sqlParser::LIMIT - 117))
      | (1ULL << (fugue_sqlParser::LINES - 117))
      | (1ULL << (fugue_sqlParser::LIST - 117))
      | (1ULL << (fugue_sqlParser::LOAD - 117))
      | (1ULL << (fugue_sqlParser::LOCAL - 117))
      | (1ULL << (fugue_sqlParser::LOCATION - 117))
      | (1ULL << (fugue_sqlParser::LOCK - 117)))) != 0) || ((((_la - 181) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 181)) & ((1ULL << (fugue_sqlParser::LOCKS - 181))
      | (1ULL << (fugue_sqlParser::LOGICAL - 181))
      | (1ULL << (fugue_sqlParser::MACRO - 181))
      | (1ULL << (fugue_sqlParser::MAP - 181))
      | (1ULL << (fugue_sqlParser::MATCHED - 181))
      | (1ULL << (fugue_sqlParser::MERGE - 181))
      | (1ULL << (fugue_sqlParser::MINUTE - 181))
      | (1ULL << (fugue_sqlParser::MONTH - 181))
      | (1ULL << (fugue_sqlParser::MSCK - 181))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 181))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 181))
      | (1ULL << (fugue_sqlParser::NATURAL - 181))
      | (1ULL << (fugue_sqlParser::NO - 181))
      | (1ULL << (fugue_sqlParser::NOT - 181))
      | (1ULL << (fugue_sqlParser::THENULL - 181))
      | (1ULL << (fugue_sqlParser::THENULLS - 181))
      | (1ULL << (fugue_sqlParser::OF - 181))
      | (1ULL << (fugue_sqlParser::ON - 181))
      | (1ULL << (fugue_sqlParser::ONLY - 181))
      | (1ULL << (fugue_sqlParser::OPTION - 181))
      | (1ULL << (fugue_sqlParser::OPTIONS - 181))
      | (1ULL << (fugue_sqlParser::OR - 181))
      | (1ULL << (fugue_sqlParser::ORDER - 181))
      | (1ULL << (fugue_sqlParser::OUT - 181))
      | (1ULL << (fugue_sqlParser::OUTER - 181))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 181))
      | (1ULL << (fugue_sqlParser::OVER - 181))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 181))
      | (1ULL << (fugue_sqlParser::OVERLAY - 181))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 181))
      | (1ULL << (fugue_sqlParser::PARTITION - 181))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 181))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 181))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 181))
      | (1ULL << (fugue_sqlParser::PIVOT - 181))
      | (1ULL << (fugue_sqlParser::PLACING - 181))
      | (1ULL << (fugue_sqlParser::POSITION - 181))
      | (1ULL << (fugue_sqlParser::PRECEDING - 181))
      | (1ULL << (fugue_sqlParser::PRIMARY - 181))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 181))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 181))
      | (1ULL << (fugue_sqlParser::PURGE - 181))
      | (1ULL << (fugue_sqlParser::QUERY - 181))
      | (1ULL << (fugue_sqlParser::RANGE - 181))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 181))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 181))
      | (1ULL << (fugue_sqlParser::RECOVER - 181))
      | (1ULL << (fugue_sqlParser::REDUCE - 181))
      | (1ULL << (fugue_sqlParser::REFERENCES - 181))
      | (1ULL << (fugue_sqlParser::REFRESH - 181))
      | (1ULL << (fugue_sqlParser::RENAME - 181))
      | (1ULL << (fugue_sqlParser::REPAIR - 181))
      | (1ULL << (fugue_sqlParser::REPLACE - 181))
      | (1ULL << (fugue_sqlParser::RESET - 181))
      | (1ULL << (fugue_sqlParser::RESTRICT - 181))
      | (1ULL << (fugue_sqlParser::REVOKE - 181))
      | (1ULL << (fugue_sqlParser::RIGHT - 181))
      | (1ULL << (fugue_sqlParser::RLIKE - 181))
      | (1ULL << (fugue_sqlParser::ROLE - 181))
      | (1ULL << (fugue_sqlParser::ROLES - 181))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 181))
      | (1ULL << (fugue_sqlParser::ROLLUP - 181))
      | (1ULL << (fugue_sqlParser::ROW - 181))
      | (1ULL << (fugue_sqlParser::ROWS - 181)))) != 0) || ((((_la - 245) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 245)) & ((1ULL << (fugue_sqlParser::SCHEMA - 245))
      | (1ULL << (fugue_sqlParser::SECOND - 245))
      | (1ULL << (fugue_sqlParser::SELECT - 245))
      | (1ULL << (fugue_sqlParser::SEMI - 245))
      | (1ULL << (fugue_sqlParser::SEPARATED - 245))
      | (1ULL << (fugue_sqlParser::SERDE - 245))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 245))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 245))
      | (1ULL << (fugue_sqlParser::SET - 245))
      | (1ULL << (fugue_sqlParser::SETMINUS - 245))
      | (1ULL << (fugue_sqlParser::SETS - 245))
      | (1ULL << (fugue_sqlParser::SHOW - 245))
      | (1ULL << (fugue_sqlParser::SKEWED - 245))
      | (1ULL << (fugue_sqlParser::SOME - 245))
      | (1ULL << (fugue_sqlParser::SORT - 245))
      | (1ULL << (fugue_sqlParser::SORTED - 245))
      | (1ULL << (fugue_sqlParser::START - 245))
      | (1ULL << (fugue_sqlParser::STATISTICS - 245))
      | (1ULL << (fugue_sqlParser::STORED - 245))
      | (1ULL << (fugue_sqlParser::STRATIFY - 245))
      | (1ULL << (fugue_sqlParser::STRUCT - 245))
      | (1ULL << (fugue_sqlParser::SUBSTR - 245))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 245))
      | (1ULL << (fugue_sqlParser::TABLE - 245))
      | (1ULL << (fugue_sqlParser::TABLES - 245))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 245))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 245))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 245))
      | (1ULL << (fugue_sqlParser::TERMINATED - 245))
      | (1ULL << (fugue_sqlParser::THEN - 245))
      | (1ULL << (fugue_sqlParser::TO - 245))
      | (1ULL << (fugue_sqlParser::TOUCH - 245))
      | (1ULL << (fugue_sqlParser::TRAILING - 245))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 245))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 245))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 245))
      | (1ULL << (fugue_sqlParser::TRIM - 245))
      | (1ULL << (fugue_sqlParser::TRUE - 245))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 245))
      | (1ULL << (fugue_sqlParser::TYPE - 245))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 245))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 245))
      | (1ULL << (fugue_sqlParser::UNCACHE - 245))
      | (1ULL << (fugue_sqlParser::UNION - 245))
      | (1ULL << (fugue_sqlParser::UNIQUE - 245))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 245))
      | (1ULL << (fugue_sqlParser::UNLOCK - 245))
      | (1ULL << (fugue_sqlParser::UNSET - 245))
      | (1ULL << (fugue_sqlParser::UPDATE - 245))
      | (1ULL << (fugue_sqlParser::USE - 245))
      | (1ULL << (fugue_sqlParser::USER - 245))
      | (1ULL << (fugue_sqlParser::USING - 245))
      | (1ULL << (fugue_sqlParser::VALUES - 245))
      | (1ULL << (fugue_sqlParser::VIEW - 245))
      | (1ULL << (fugue_sqlParser::VIEWS - 245))
      | (1ULL << (fugue_sqlParser::WHEN - 245))
      | (1ULL << (fugue_sqlParser::WHERE - 245))
      | (1ULL << (fugue_sqlParser::WINDOW - 245))
      | (1ULL << (fugue_sqlParser::WITH - 245))
      | (1ULL << (fugue_sqlParser::YEAR - 245)))) != 0) || ((((_la - 319) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 319)) & ((1ULL << (fugue_sqlParser::DIV - 319))
      | (1ULL << (fugue_sqlParser::IDENTIFIER - 319))
      | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 319)))) != 0)) {
      setState(701);
      antlrcpp::downCast<FugueModuleTaskContext *>(_localctx)->assign = fugueAssignment();
    }
    setState(704);
    match(fugue_sqlParser::SUB);
    setState(706);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 58, _ctx)) {
    case 1: {
      setState(705);
      antlrcpp::downCast<FugueModuleTaskContext *>(_localctx)->dfs = fugueDataFrames();
      break;
    }

    default:
      break;
    }
    setState(708);
    match(fugue_sqlParser::USING);
    setState(709);
    antlrcpp::downCast<FugueModuleTaskContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(711);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::T__7)
      | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
      setState(710);
      antlrcpp::downCast<FugueModuleTaskContext *>(_localctx)->params = fugueParams();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSqlEngineContext ------------------------------------------------------------------

fugue_sqlParser::FugueSqlEngineContext::FugueSqlEngineContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSqlEngineContext::CONNECT() {
  return getToken(fugue_sqlParser::CONNECT, 0);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueSqlEngineContext::fugueExtension() {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueSqlEngineContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}


size_t fugue_sqlParser::FugueSqlEngineContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSqlEngine;
}


std::any fugue_sqlParser::FugueSqlEngineContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSqlEngine(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSqlEngineContext* fugue_sqlParser::fugueSqlEngine() {
  FugueSqlEngineContext *_localctx = _tracker.createInstance<FugueSqlEngineContext>(_ctx, getState());
  enterRule(_localctx, 48, fugue_sqlParser::RuleFugueSqlEngine);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(713);
    match(fugue_sqlParser::CONNECT);
    setState(714);
    antlrcpp::downCast<FugueSqlEngineContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(716);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::T__7)
      | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
      setState(715);
      antlrcpp::downCast<FugueSqlEngineContext *>(_localctx)->params = fugueParams();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSingleFileContext ------------------------------------------------------------------

fugue_sqlParser::FugueSingleFileContext::FugueSingleFileContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSingleFileContext::SINGLE() {
  return getToken(fugue_sqlParser::SINGLE, 0);
}


size_t fugue_sqlParser::FugueSingleFileContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSingleFile;
}


std::any fugue_sqlParser::FugueSingleFileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSingleFile(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSingleFileContext* fugue_sqlParser::fugueSingleFile() {
  FugueSingleFileContext *_localctx = _tracker.createInstance<FugueSingleFileContext>(_ctx, getState());
  enterRule(_localctx, 50, fugue_sqlParser::RuleFugueSingleFile);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(718);
    antlrcpp::downCast<FugueSingleFileContext *>(_localctx)->single = match(fugue_sqlParser::SINGLE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueLoadColumnsContext ------------------------------------------------------------------

fugue_sqlParser::FugueLoadColumnsContext::FugueLoadColumnsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::FugueLoadColumnsContext::fugueSchema() {
  return getRuleContext<fugue_sqlParser::FugueSchemaContext>(0);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::FugueLoadColumnsContext::fugueCols() {
  return getRuleContext<fugue_sqlParser::FugueColsContext>(0);
}


size_t fugue_sqlParser::FugueLoadColumnsContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueLoadColumns;
}


std::any fugue_sqlParser::FugueLoadColumnsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueLoadColumns(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueLoadColumnsContext* fugue_sqlParser::fugueLoadColumns() {
  FugueLoadColumnsContext *_localctx = _tracker.createInstance<FugueLoadColumnsContext>(_ctx, getState());
  enterRule(_localctx, 52, fugue_sqlParser::RuleFugueLoadColumns);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(722);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 61, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(720);
      antlrcpp::downCast<FugueLoadColumnsContext *>(_localctx)->schema = fugueSchema();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(721);
      antlrcpp::downCast<FugueLoadColumnsContext *>(_localctx)->cols = fugueCols();
      break;
    }

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

  return _localctx;
}

//----------------- FugueSaveModeContext ------------------------------------------------------------------

fugue_sqlParser::FugueSaveModeContext::FugueSaveModeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSaveModeContext::TO() {
  return getToken(fugue_sqlParser::TO, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSaveModeContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSaveModeContext::APPEND() {
  return getToken(fugue_sqlParser::APPEND, 0);
}


size_t fugue_sqlParser::FugueSaveModeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSaveMode;
}


std::any fugue_sqlParser::FugueSaveModeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSaveMode(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSaveModeContext* fugue_sqlParser::fugueSaveMode() {
  FugueSaveModeContext *_localctx = _tracker.createInstance<FugueSaveModeContext>(_ctx, getState());
  enterRule(_localctx, 54, fugue_sqlParser::RuleFugueSaveMode);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(724);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::APPEND || _la == fugue_sqlParser::OVERWRITE || _la == fugue_sqlParser::TO)) {
    _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;
}

//----------------- FugueFileFormatContext ------------------------------------------------------------------

fugue_sqlParser::FugueFileFormatContext::FugueFileFormatContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueFileFormatContext::PARQUET() {
  return getToken(fugue_sqlParser::PARQUET, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueFileFormatContext::CSV() {
  return getToken(fugue_sqlParser::CSV, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueFileFormatContext::JSON() {
  return getToken(fugue_sqlParser::JSON, 0);
}


size_t fugue_sqlParser::FugueFileFormatContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueFileFormat;
}


std::any fugue_sqlParser::FugueFileFormatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueFileFormat(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueFileFormatContext* fugue_sqlParser::fugueFileFormat() {
  FugueFileFormatContext *_localctx = _tracker.createInstance<FugueFileFormatContext>(_ctx, getState());
  enterRule(_localctx, 56, fugue_sqlParser::RuleFugueFileFormat);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(726);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::PARQUET)
      | (1ULL << fugue_sqlParser::CSV)
      | (1ULL << fugue_sqlParser::JSON))) != 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;
}

//----------------- FuguePathContext ------------------------------------------------------------------

fugue_sqlParser::FuguePathContext::FuguePathContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FuguePathContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::FuguePathContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePath;
}


std::any fugue_sqlParser::FuguePathContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFuguePath(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FuguePathContext* fugue_sqlParser::fuguePath() {
  FuguePathContext *_localctx = _tracker.createInstance<FuguePathContext>(_ctx, getState());
  enterRule(_localctx, 58, fugue_sqlParser::RuleFuguePath);

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

  return _localctx;
}

//----------------- FugueCheckpointContext ------------------------------------------------------------------

fugue_sqlParser::FugueCheckpointContext::FugueCheckpointContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::FugueCheckpointContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueCheckpoint;
}

void fugue_sqlParser::FugueCheckpointContext::copyFrom(FugueCheckpointContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- FugueCheckpointDeterministicContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::FugueCheckpointDeterministicContext::DETERMINISTIC() {
  return getToken(fugue_sqlParser::DETERMINISTIC, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointDeterministicContext::CHECKPOINT() {
  return getToken(fugue_sqlParser::CHECKPOINT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointDeterministicContext::LAZY() {
  return getToken(fugue_sqlParser::LAZY, 0);
}

fugue_sqlParser::FugueCheckpointNamespaceContext* fugue_sqlParser::FugueCheckpointDeterministicContext::fugueCheckpointNamespace() {
  return getRuleContext<fugue_sqlParser::FugueCheckpointNamespaceContext>(0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueCheckpointDeterministicContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueSingleFileContext* fugue_sqlParser::FugueCheckpointDeterministicContext::fugueSingleFile() {
  return getRuleContext<fugue_sqlParser::FugueSingleFileContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueCheckpointDeterministicContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

fugue_sqlParser::FugueCheckpointDeterministicContext::FugueCheckpointDeterministicContext(FugueCheckpointContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueCheckpointDeterministicContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCheckpointDeterministic(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueCheckpointWeakContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::FugueCheckpointWeakContext::PERSIST() {
  return getToken(fugue_sqlParser::PERSIST, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointWeakContext::WEAK() {
  return getToken(fugue_sqlParser::WEAK, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointWeakContext::CHECKPOINT() {
  return getToken(fugue_sqlParser::CHECKPOINT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointWeakContext::LAZY() {
  return getToken(fugue_sqlParser::LAZY, 0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueCheckpointWeakContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

fugue_sqlParser::FugueCheckpointWeakContext::FugueCheckpointWeakContext(FugueCheckpointContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueCheckpointWeakContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCheckpointWeak(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueCheckpointStrongContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::FugueCheckpointStrongContext::CHECKPOINT() {
  return getToken(fugue_sqlParser::CHECKPOINT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointStrongContext::LAZY() {
  return getToken(fugue_sqlParser::LAZY, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointStrongContext::STRONG() {
  return getToken(fugue_sqlParser::STRONG, 0);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::FugueCheckpointStrongContext::fuguePrepartition() {
  return getRuleContext<fugue_sqlParser::FuguePrepartitionContext>(0);
}

fugue_sqlParser::FugueSingleFileContext* fugue_sqlParser::FugueCheckpointStrongContext::fugueSingleFile() {
  return getRuleContext<fugue_sqlParser::FugueSingleFileContext>(0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueCheckpointStrongContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

fugue_sqlParser::FugueCheckpointStrongContext::FugueCheckpointStrongContext(FugueCheckpointContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueCheckpointStrongContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCheckpointStrong(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::FugueCheckpointContext* fugue_sqlParser::fugueCheckpoint() {
  FugueCheckpointContext *_localctx = _tracker.createInstance<FugueCheckpointContext>(_ctx, getState());
  enterRule(_localctx, 60, fugue_sqlParser::RuleFugueCheckpoint);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(774);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 75, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueCheckpointWeakContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(731);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LAZY) {
        setState(730);
        match(fugue_sqlParser::LAZY);
      }
      setState(736);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::PERSIST: {
          setState(733);
          match(fugue_sqlParser::PERSIST);
          break;
        }

        case fugue_sqlParser::WEAK: {
          setState(734);
          match(fugue_sqlParser::WEAK);
          setState(735);
          match(fugue_sqlParser::CHECKPOINT);
          break;
        }

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

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
        | (1ULL << fugue_sqlParser::T__7)
        | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
        setState(738);
        antlrcpp::downCast<FugueCheckpointWeakContext *>(_localctx)->params = fugueParams();
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueCheckpointStrongContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(742);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LAZY) {
        setState(741);
        match(fugue_sqlParser::LAZY);
      }
      setState(745);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STRONG) {
        setState(744);
        match(fugue_sqlParser::STRONG);
      }
      setState(747);
      match(fugue_sqlParser::CHECKPOINT);
      setState(749);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
        | (1ULL << fugue_sqlParser::RAND)
        | (1ULL << fugue_sqlParser::EVEN)
        | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
        setState(748);
        antlrcpp::downCast<FugueCheckpointStrongContext *>(_localctx)->partition = fuguePrepartition();
      }
      setState(752);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::SINGLE) {
        setState(751);
        antlrcpp::downCast<FugueCheckpointStrongContext *>(_localctx)->single = fugueSingleFile();
      }
      setState(755);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
        | (1ULL << fugue_sqlParser::T__7)
        | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
        setState(754);
        antlrcpp::downCast<FugueCheckpointStrongContext *>(_localctx)->params = fugueParams();
      }
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueCheckpointDeterministicContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(758);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LAZY) {
        setState(757);
        match(fugue_sqlParser::LAZY);
      }
      setState(760);
      match(fugue_sqlParser::DETERMINISTIC);
      setState(761);
      match(fugue_sqlParser::CHECKPOINT);
      setState(763);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STRING) {
        setState(762);
        antlrcpp::downCast<FugueCheckpointDeterministicContext *>(_localctx)->ns = fugueCheckpointNamespace();
      }
      setState(766);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
        | (1ULL << fugue_sqlParser::RAND)
        | (1ULL << fugue_sqlParser::EVEN)
        | (1ULL << fugue_sqlParser::PREPARTITION))) != 0)) {
        setState(765);
        antlrcpp::downCast<FugueCheckpointDeterministicContext *>(_localctx)->partition = fuguePrepartition();
      }
      setState(769);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::SINGLE) {
        setState(768);
        antlrcpp::downCast<FugueCheckpointDeterministicContext *>(_localctx)->single = fugueSingleFile();
      }
      setState(772);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
        | (1ULL << fugue_sqlParser::T__7)
        | (1ULL << fugue_sqlParser::PARAMS))) != 0)) {
        setState(771);
        antlrcpp::downCast<FugueCheckpointDeterministicContext *>(_localctx)->params = fugueParams();
      }
      break;
    }

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

  return _localctx;
}

//----------------- FugueCheckpointNamespaceContext ------------------------------------------------------------------

fugue_sqlParser::FugueCheckpointNamespaceContext::FugueCheckpointNamespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueCheckpointNamespaceContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::FugueCheckpointNamespaceContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueCheckpointNamespace;
}


std::any fugue_sqlParser::FugueCheckpointNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCheckpointNamespace(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueCheckpointNamespaceContext* fugue_sqlParser::fugueCheckpointNamespace() {
  FugueCheckpointNamespaceContext *_localctx = _tracker.createInstance<FugueCheckpointNamespaceContext>(_ctx, getState());
  enterRule(_localctx, 62, fugue_sqlParser::RuleFugueCheckpointNamespace);

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

  return _localctx;
}

//----------------- FugueYieldContext ------------------------------------------------------------------

fugue_sqlParser::FugueYieldContext::FugueYieldContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueYieldContext::YIELD() {
  return getToken(fugue_sqlParser::YIELD, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueYieldContext::FILE() {
  return getToken(fugue_sqlParser::FILE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueYieldContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueYieldContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueYieldContext::DATAFRAME() {
  return getToken(fugue_sqlParser::DATAFRAME, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueYieldContext::LOCAL() {
  return getToken(fugue_sqlParser::LOCAL, 0);
}


size_t fugue_sqlParser::FugueYieldContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueYield;
}


std::any fugue_sqlParser::FugueYieldContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueYield(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueYieldContext* fugue_sqlParser::fugueYield() {
  FugueYieldContext *_localctx = _tracker.createInstance<FugueYieldContext>(_ctx, getState());
  enterRule(_localctx, 64, fugue_sqlParser::RuleFugueYield);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(793);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 79, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(778);
      match(fugue_sqlParser::YIELD);
      setState(779);
      match(fugue_sqlParser::FILE);
      setState(782);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 76, _ctx)) {
      case 1: {
        setState(780);
        match(fugue_sqlParser::AS);
        setState(781);
        antlrcpp::downCast<FugueYieldContext *>(_localctx)->name = fugueIdentifier();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(784);
      match(fugue_sqlParser::YIELD);
      setState(786);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(785);
        match(fugue_sqlParser::LOCAL);
      }
      setState(788);
      match(fugue_sqlParser::DATAFRAME);
      setState(791);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 78, _ctx)) {
      case 1: {
        setState(789);
        match(fugue_sqlParser::AS);
        setState(790);
        antlrcpp::downCast<FugueYieldContext *>(_localctx)->name = fugueIdentifier();
        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;
}

//----------------- FugueBroadcastContext ------------------------------------------------------------------

fugue_sqlParser::FugueBroadcastContext::FugueBroadcastContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueBroadcastContext::BROADCAST() {
  return getToken(fugue_sqlParser::BROADCAST, 0);
}


size_t fugue_sqlParser::FugueBroadcastContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueBroadcast;
}


std::any fugue_sqlParser::FugueBroadcastContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueBroadcast(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueBroadcastContext* fugue_sqlParser::fugueBroadcast() {
  FugueBroadcastContext *_localctx = _tracker.createInstance<FugueBroadcastContext>(_ctx, getState());
  enterRule(_localctx, 66, fugue_sqlParser::RuleFugueBroadcast);

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

  return _localctx;
}

//----------------- FugueDataFramesContext ------------------------------------------------------------------

fugue_sqlParser::FugueDataFramesContext::FugueDataFramesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::FugueDataFramesContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueDataFrames;
}

void fugue_sqlParser::FugueDataFramesContext::copyFrom(FugueDataFramesContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- FugueDataFramesDictContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::FugueDataFramePairContext *> fugue_sqlParser::FugueDataFramesDictContext::fugueDataFramePair() {
  return getRuleContexts<fugue_sqlParser::FugueDataFramePairContext>();
}

fugue_sqlParser::FugueDataFramePairContext* fugue_sqlParser::FugueDataFramesDictContext::fugueDataFramePair(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueDataFramePairContext>(i);
}

fugue_sqlParser::FugueDataFramesDictContext::FugueDataFramesDictContext(FugueDataFramesContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueDataFramesDictContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDataFramesDict(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueDataFramesListContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::FugueDataFrameContext *> fugue_sqlParser::FugueDataFramesListContext::fugueDataFrame() {
  return getRuleContexts<fugue_sqlParser::FugueDataFrameContext>();
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueDataFramesListContext::fugueDataFrame(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(i);
}

fugue_sqlParser::FugueDataFramesListContext::FugueDataFramesListContext(FugueDataFramesContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueDataFramesListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDataFramesList(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::FugueDataFramesContext* fugue_sqlParser::fugueDataFrames() {
  FugueDataFramesContext *_localctx = _tracker.createInstance<FugueDataFramesContext>(_ctx, getState());
  enterRule(_localctx, 68, fugue_sqlParser::RuleFugueDataFrames);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(813);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFramesListContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(797);
      fugueDataFrame();
      setState(802);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(798);
          match(fugue_sqlParser::T__0);
          setState(799);
          fugueDataFrame(); 
        }
        setState(804);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 80, _ctx);
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFramesDictContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(805);
      fugueDataFramePair();
      setState(810);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(806);
          match(fugue_sqlParser::T__0);
          setState(807);
          fugueDataFramePair(); 
        }
        setState(812);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx);
      }
      break;
    }

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

  return _localctx;
}

//----------------- FugueDataFramePairContext ------------------------------------------------------------------

fugue_sqlParser::FugueDataFramePairContext::FugueDataFramePairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueDataFramePairContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueDataFramePairContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}

fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::FugueDataFramePairContext::fugueDataFrame() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameContext>(0);
}


size_t fugue_sqlParser::FugueDataFramePairContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueDataFramePair;
}


std::any fugue_sqlParser::FugueDataFramePairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDataFramePair(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueDataFramePairContext* fugue_sqlParser::fugueDataFramePair() {
  FugueDataFramePairContext *_localctx = _tracker.createInstance<FugueDataFramePairContext>(_ctx, getState());
  enterRule(_localctx, 70, fugue_sqlParser::RuleFugueDataFramePair);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(815);
    antlrcpp::downCast<FugueDataFramePairContext *>(_localctx)->key = fugueIdentifier();
    setState(816);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::T__1 || _la == fugue_sqlParser::EQUAL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(817);
    antlrcpp::downCast<FugueDataFramePairContext *>(_localctx)->value = fugueDataFrame();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueDataFrameContext ------------------------------------------------------------------

fugue_sqlParser::FugueDataFrameContext::FugueDataFrameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::FugueDataFrameContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueDataFrame;
}

void fugue_sqlParser::FugueDataFrameContext::copyFrom(FugueDataFrameContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- FugueDataFrameSourceContext ------------------------------------------------------------------

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueDataFrameSourceContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}

fugue_sqlParser::FugueDataFrameMemberContext* fugue_sqlParser::FugueDataFrameSourceContext::fugueDataFrameMember() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameMemberContext>(0);
}

fugue_sqlParser::FugueDataFrameSourceContext::FugueDataFrameSourceContext(FugueDataFrameContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueDataFrameSourceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDataFrameSource(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueDataFrameNestedContext ------------------------------------------------------------------

fugue_sqlParser::FugueNestableTaskContext* fugue_sqlParser::FugueDataFrameNestedContext::fugueNestableTask() {
  return getRuleContext<fugue_sqlParser::FugueNestableTaskContext>(0);
}

fugue_sqlParser::FugueDataFrameNestedContext::FugueDataFrameNestedContext(FugueDataFrameContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueDataFrameNestedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDataFrameNested(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::FugueDataFrameContext* fugue_sqlParser::fugueDataFrame() {
  FugueDataFrameContext *_localctx = _tracker.createInstance<FugueDataFrameContext>(_ctx, getState());
  enterRule(_localctx, 72, fugue_sqlParser::RuleFugueDataFrame);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(827);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFrameSourceContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(819);
        fugueIdentifier();
        setState(821);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx)) {
        case 1: {
          setState(820);
          fugueDataFrameMember();
          break;
        }

        default:
          break;
        }
        break;
      }

      case fugue_sqlParser::T__2: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFrameNestedContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(823);
        match(fugue_sqlParser::T__2);
        setState(824);
        antlrcpp::downCast<FugueDataFrameNestedContext *>(_localctx)->task = fugueNestableTask();
        setState(825);
        match(fugue_sqlParser::T__3);
        break;
      }

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

  return _localctx;
}

//----------------- FugueDataFrameMemberContext ------------------------------------------------------------------

fugue_sqlParser::FugueDataFrameMemberContext::FugueDataFrameMemberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueDataFrameMemberContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueDataFrameMemberContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}


size_t fugue_sqlParser::FugueDataFrameMemberContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueDataFrameMember;
}


std::any fugue_sqlParser::FugueDataFrameMemberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueDataFrameMember(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueDataFrameMemberContext* fugue_sqlParser::fugueDataFrameMember() {
  FugueDataFrameMemberContext *_localctx = _tracker.createInstance<FugueDataFrameMemberContext>(_ctx, getState());
  enterRule(_localctx, 74, fugue_sqlParser::RuleFugueDataFrameMember);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(829);
    match(fugue_sqlParser::T__4);
    setState(832);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::INTEGER_VALUE: {
        setState(830);
        antlrcpp::downCast<FugueDataFrameMemberContext *>(_localctx)->index = match(fugue_sqlParser::INTEGER_VALUE);
        break;
      }

      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        setState(831);
        antlrcpp::downCast<FugueDataFrameMemberContext *>(_localctx)->key = fugueIdentifier();
        break;
      }

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

  return _localctx;
}

//----------------- FugueAssignmentContext ------------------------------------------------------------------

fugue_sqlParser::FugueAssignmentContext::FugueAssignmentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueAssignmentContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}

fugue_sqlParser::FugueAssignmentSignContext* fugue_sqlParser::FugueAssignmentContext::fugueAssignmentSign() {
  return getRuleContext<fugue_sqlParser::FugueAssignmentSignContext>(0);
}


size_t fugue_sqlParser::FugueAssignmentContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueAssignment;
}


std::any fugue_sqlParser::FugueAssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueAssignment(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueAssignmentContext* fugue_sqlParser::fugueAssignment() {
  FugueAssignmentContext *_localctx = _tracker.createInstance<FugueAssignmentContext>(_ctx, getState());
  enterRule(_localctx, 76, fugue_sqlParser::RuleFugueAssignment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(836);
    antlrcpp::downCast<FugueAssignmentContext *>(_localctx)->varname = fugueIdentifier();
    setState(837);
    antlrcpp::downCast<FugueAssignmentContext *>(_localctx)->sign = fugueAssignmentSign();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueAssignmentSignContext ------------------------------------------------------------------

fugue_sqlParser::FugueAssignmentSignContext::FugueAssignmentSignContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueAssignmentSignContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}


size_t fugue_sqlParser::FugueAssignmentSignContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueAssignmentSign;
}


std::any fugue_sqlParser::FugueAssignmentSignContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueAssignmentSign(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueAssignmentSignContext* fugue_sqlParser::fugueAssignmentSign() {
  FugueAssignmentSignContext *_localctx = _tracker.createInstance<FugueAssignmentSignContext>(_ctx, getState());
  enterRule(_localctx, 78, fugue_sqlParser::RuleFugueAssignmentSign);

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

  return _localctx;
}

//----------------- FugueSingleOutputExtensionCommonWildContext ------------------------------------------------------------------

fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::FugueSingleOutputExtensionCommonWildContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::fugueExtension() {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::SCHEMA() {
  return getToken(fugue_sqlParser::SCHEMA, 0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

fugue_sqlParser::FugueWildSchemaContext* fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::fugueWildSchema() {
  return getRuleContext<fugue_sqlParser::FugueWildSchemaContext>(0);
}


size_t fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSingleOutputExtensionCommonWild;
}


std::any fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSingleOutputExtensionCommonWild(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSingleOutputExtensionCommonWildContext* fugue_sqlParser::fugueSingleOutputExtensionCommonWild() {
  FugueSingleOutputExtensionCommonWildContext *_localctx = _tracker.createInstance<FugueSingleOutputExtensionCommonWildContext>(_ctx, getState());
  enterRule(_localctx, 80, fugue_sqlParser::RuleFugueSingleOutputExtensionCommonWild);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(841);
    match(fugue_sqlParser::USING);
    setState(842);
    antlrcpp::downCast<FugueSingleOutputExtensionCommonWildContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(844);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 86, _ctx)) {
    case 1: {
      setState(843);
      antlrcpp::downCast<FugueSingleOutputExtensionCommonWildContext *>(_localctx)->params = fugueParams();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 87, _ctx)) {
    case 1: {
      setState(846);
      match(fugue_sqlParser::SCHEMA);
      setState(847);
      antlrcpp::downCast<FugueSingleOutputExtensionCommonWildContext *>(_localctx)->schema = fugueWildSchema();
      break;
    }

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

  return _localctx;
}

//----------------- FugueSingleOutputExtensionCommonContext ------------------------------------------------------------------

fugue_sqlParser::FugueSingleOutputExtensionCommonContext::FugueSingleOutputExtensionCommonContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSingleOutputExtensionCommonContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::FugueSingleOutputExtensionCommonContext::fugueExtension() {
  return getRuleContext<fugue_sqlParser::FugueExtensionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueSingleOutputExtensionCommonContext::SCHEMA() {
  return getToken(fugue_sqlParser::SCHEMA, 0);
}

fugue_sqlParser::FugueParamsContext* fugue_sqlParser::FugueSingleOutputExtensionCommonContext::fugueParams() {
  return getRuleContext<fugue_sqlParser::FugueParamsContext>(0);
}

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::FugueSingleOutputExtensionCommonContext::fugueSchema() {
  return getRuleContext<fugue_sqlParser::FugueSchemaContext>(0);
}


size_t fugue_sqlParser::FugueSingleOutputExtensionCommonContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSingleOutputExtensionCommon;
}


std::any fugue_sqlParser::FugueSingleOutputExtensionCommonContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSingleOutputExtensionCommon(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSingleOutputExtensionCommonContext* fugue_sqlParser::fugueSingleOutputExtensionCommon() {
  FugueSingleOutputExtensionCommonContext *_localctx = _tracker.createInstance<FugueSingleOutputExtensionCommonContext>(_ctx, getState());
  enterRule(_localctx, 82, fugue_sqlParser::RuleFugueSingleOutputExtensionCommon);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(850);
    match(fugue_sqlParser::USING);
    setState(851);
    antlrcpp::downCast<FugueSingleOutputExtensionCommonContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(853);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 88, _ctx)) {
    case 1: {
      setState(852);
      antlrcpp::downCast<FugueSingleOutputExtensionCommonContext *>(_localctx)->params = fugueParams();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 89, _ctx)) {
    case 1: {
      setState(855);
      match(fugue_sqlParser::SCHEMA);
      setState(856);
      antlrcpp::downCast<FugueSingleOutputExtensionCommonContext *>(_localctx)->schema = fugueSchema();
      break;
    }

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

  return _localctx;
}

//----------------- FugueExtensionContext ------------------------------------------------------------------

fugue_sqlParser::FugueExtensionContext::FugueExtensionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueIdentifierContext *> fugue_sqlParser::FugueExtensionContext::fugueIdentifier() {
  return getRuleContexts<fugue_sqlParser::FugueIdentifierContext>();
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueExtensionContext::fugueIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(i);
}


size_t fugue_sqlParser::FugueExtensionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueExtension;
}


std::any fugue_sqlParser::FugueExtensionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueExtension(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueExtensionContext* fugue_sqlParser::fugueExtension() {
  FugueExtensionContext *_localctx = _tracker.createInstance<FugueExtensionContext>(_ctx, getState());
  enterRule(_localctx, 84, fugue_sqlParser::RuleFugueExtension);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(859);
    fugueIdentifier();
    setState(864);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(860);
        match(fugue_sqlParser::T__6);
        setState(861);
        fugueIdentifier(); 
      }
      setState(866);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSampleMethodContext ------------------------------------------------------------------

fugue_sqlParser::FugueSampleMethodContext::FugueSampleMethodContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueSampleMethodContext::PERCENTLIT() {
  return getToken(fugue_sqlParser::PERCENTLIT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleMethodContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleMethodContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleMethodContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}


size_t fugue_sqlParser::FugueSampleMethodContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSampleMethod;
}


std::any fugue_sqlParser::FugueSampleMethodContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSampleMethod(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSampleMethodContext* fugue_sqlParser::fugueSampleMethod() {
  FugueSampleMethodContext *_localctx = _tracker.createInstance<FugueSampleMethodContext>(_ctx, getState());
  enterRule(_localctx, 86, fugue_sqlParser::RuleFugueSampleMethod);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(871);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 91, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(867);
      antlrcpp::downCast<FugueSampleMethodContext *>(_localctx)->percentage = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::INTEGER_VALUE

      || _la == fugue_sqlParser::DECIMAL_VALUE)) {
        antlrcpp::downCast<FugueSampleMethodContext *>(_localctx)->percentage = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(868);
      match(fugue_sqlParser::PERCENTLIT);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(869);
      antlrcpp::downCast<FugueSampleMethodContext *>(_localctx)->rows = match(fugue_sqlParser::INTEGER_VALUE);
      setState(870);
      match(fugue_sqlParser::ROWS);
      break;
    }

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

  return _localctx;
}

//----------------- FugueZipTypeContext ------------------------------------------------------------------

fugue_sqlParser::FugueZipTypeContext::FugueZipTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueZipTypeContext::CROSS() {
  return getToken(fugue_sqlParser::CROSS, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTypeContext::INNER() {
  return getToken(fugue_sqlParser::INNER, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTypeContext::LEFT() {
  return getToken(fugue_sqlParser::LEFT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTypeContext::OUTER() {
  return getToken(fugue_sqlParser::OUTER, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTypeContext::RIGHT() {
  return getToken(fugue_sqlParser::RIGHT, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueZipTypeContext::FULL() {
  return getToken(fugue_sqlParser::FULL, 0);
}


size_t fugue_sqlParser::FugueZipTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueZipType;
}


std::any fugue_sqlParser::FugueZipTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueZipType(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueZipTypeContext* fugue_sqlParser::fugueZipType() {
  FugueZipTypeContext *_localctx = _tracker.createInstance<FugueZipTypeContext>(_ctx, getState());
  enterRule(_localctx, 88, fugue_sqlParser::RuleFugueZipType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(881);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::CROSS: {
        enterOuterAlt(_localctx, 1);
        setState(873);
        match(fugue_sqlParser::CROSS);
        break;
      }

      case fugue_sqlParser::INNER: {
        enterOuterAlt(_localctx, 2);
        setState(874);
        match(fugue_sqlParser::INNER);
        break;
      }

      case fugue_sqlParser::LEFT: {
        enterOuterAlt(_localctx, 3);
        setState(875);
        match(fugue_sqlParser::LEFT);
        setState(876);
        match(fugue_sqlParser::OUTER);
        break;
      }

      case fugue_sqlParser::RIGHT: {
        enterOuterAlt(_localctx, 4);
        setState(877);
        match(fugue_sqlParser::RIGHT);
        setState(878);
        match(fugue_sqlParser::OUTER);
        break;
      }

      case fugue_sqlParser::FULL: {
        enterOuterAlt(_localctx, 5);
        setState(879);
        match(fugue_sqlParser::FULL);
        setState(880);
        match(fugue_sqlParser::OUTER);
        break;
      }

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

  return _localctx;
}

//----------------- FuguePrepartitionContext ------------------------------------------------------------------

fugue_sqlParser::FuguePrepartitionContext::FuguePrepartitionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FuguePrepartitionContext::PREPARTITION() {
  return getToken(fugue_sqlParser::PREPARTITION, 0);
}

fugue_sqlParser::FuguePartitionNumContext* fugue_sqlParser::FuguePrepartitionContext::fuguePartitionNum() {
  return getRuleContext<fugue_sqlParser::FuguePartitionNumContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrepartitionContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePrepartitionContext::PRESORT() {
  return getToken(fugue_sqlParser::PRESORT, 0);
}

fugue_sqlParser::FuguePartitionAlgoContext* fugue_sqlParser::FuguePrepartitionContext::fuguePartitionAlgo() {
  return getRuleContext<fugue_sqlParser::FuguePartitionAlgoContext>(0);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::FuguePrepartitionContext::fugueCols() {
  return getRuleContext<fugue_sqlParser::FugueColsContext>(0);
}

fugue_sqlParser::FugueColsSortContext* fugue_sqlParser::FuguePrepartitionContext::fugueColsSort() {
  return getRuleContext<fugue_sqlParser::FugueColsSortContext>(0);
}


size_t fugue_sqlParser::FuguePrepartitionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePrepartition;
}


std::any fugue_sqlParser::FuguePrepartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFuguePrepartition(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FuguePrepartitionContext* fugue_sqlParser::fuguePrepartition() {
  FuguePrepartitionContext *_localctx = _tracker.createInstance<FuguePrepartitionContext>(_ctx, getState());
  enterRule(_localctx, 90, fugue_sqlParser::RuleFuguePrepartition);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
        | (1ULL << fugue_sqlParser::RAND)
        | (1ULL << fugue_sqlParser::EVEN))) != 0)) {
        setState(883);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->algo = fuguePartitionAlgo();
      }
      setState(886);
      match(fugue_sqlParser::PREPARTITION);
      setState(887);
      antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->num = fuguePartitionNum(0);
      setState(890);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx)) {
      case 1: {
        setState(888);
        match(fugue_sqlParser::BY);
        setState(889);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->by = fugueCols();
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 95, _ctx)) {
      case 1: {
        setState(892);
        match(fugue_sqlParser::PRESORT);
        setState(893);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->presort = fugueColsSort();
        break;
      }

      default:
        break;
      }
      break;
    }

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

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
        | (1ULL << fugue_sqlParser::RAND)
        | (1ULL << fugue_sqlParser::EVEN))) != 0)) {
        setState(896);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->algo = fuguePartitionAlgo();
      }
      setState(899);
      match(fugue_sqlParser::PREPARTITION);
      setState(900);
      match(fugue_sqlParser::BY);
      setState(901);
      antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->by = fugueCols();
      setState(904);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 97, _ctx)) {
      case 1: {
        setState(902);
        match(fugue_sqlParser::PRESORT);
        setState(903);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->presort = fugueColsSort();
        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;
}

//----------------- FuguePartitionAlgoContext ------------------------------------------------------------------

fugue_sqlParser::FuguePartitionAlgoContext::FuguePartitionAlgoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionAlgoContext::HASH() {
  return getToken(fugue_sqlParser::HASH, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionAlgoContext::RAND() {
  return getToken(fugue_sqlParser::RAND, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionAlgoContext::EVEN() {
  return getToken(fugue_sqlParser::EVEN, 0);
}


size_t fugue_sqlParser::FuguePartitionAlgoContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePartitionAlgo;
}


std::any fugue_sqlParser::FuguePartitionAlgoContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFuguePartitionAlgo(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FuguePartitionAlgoContext* fugue_sqlParser::fuguePartitionAlgo() {
  FuguePartitionAlgoContext *_localctx = _tracker.createInstance<FuguePartitionAlgoContext>(_ctx, getState());
  enterRule(_localctx, 92, fugue_sqlParser::RuleFuguePartitionAlgo);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(908);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::HASH)
      | (1ULL << fugue_sqlParser::RAND)
      | (1ULL << fugue_sqlParser::EVEN))) != 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;
}

//----------------- FuguePartitionNumContext ------------------------------------------------------------------

fugue_sqlParser::FuguePartitionNumContext::FuguePartitionNumContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FuguePartitionNumberContext* fugue_sqlParser::FuguePartitionNumContext::fuguePartitionNumber() {
  return getRuleContext<fugue_sqlParser::FuguePartitionNumberContext>(0);
}

std::vector<fugue_sqlParser::FuguePartitionNumContext *> fugue_sqlParser::FuguePartitionNumContext::fuguePartitionNum() {
  return getRuleContexts<fugue_sqlParser::FuguePartitionNumContext>();
}

fugue_sqlParser::FuguePartitionNumContext* fugue_sqlParser::FuguePartitionNumContext::fuguePartitionNum(size_t i) {
  return getRuleContext<fugue_sqlParser::FuguePartitionNumContext>(i);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumContext::PLUS() {
  return getToken(fugue_sqlParser::PLUS, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumContext::SLASH() {
  return getToken(fugue_sqlParser::SLASH, 0);
}


size_t fugue_sqlParser::FuguePartitionNumContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePartitionNum;
}


std::any fugue_sqlParser::FuguePartitionNumContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFuguePartitionNum(this);
  else
    return visitor->visitChildren(this);
}


fugue_sqlParser::FuguePartitionNumContext* fugue_sqlParser::fuguePartitionNum() {
   return fuguePartitionNum(0);
}

fugue_sqlParser::FuguePartitionNumContext* fugue_sqlParser::fuguePartitionNum(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  fugue_sqlParser::FuguePartitionNumContext *_localctx = _tracker.createInstance<FuguePartitionNumContext>(_ctx, parentState);
  fugue_sqlParser::FuguePartitionNumContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 94;
  enterRecursionRule(_localctx, 94, fugue_sqlParser::RuleFuguePartitionNum, 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(916);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ROWCOUNT:
      case fugue_sqlParser::CONCURRENCY:
      case fugue_sqlParser::MINUS:
      case fugue_sqlParser::INTEGER_VALUE:
      case fugue_sqlParser::DECIMAL_VALUE: {
        setState(911);
        fuguePartitionNumber();
        break;
      }

      case fugue_sqlParser::T__2: {
        setState(912);
        match(fugue_sqlParser::T__2);
        setState(913);
        fuguePartitionNum(0);
        setState(914);
        match(fugue_sqlParser::T__3);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(923);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 100, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<FuguePartitionNumContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleFuguePartitionNum);
        setState(918);

        if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
        setState(919);
        _la = _input->LA(1);
        if (!(((((_la - 314) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 314)) & ((1ULL << (fugue_sqlParser::PLUS - 314))
          | (1ULL << (fugue_sqlParser::MINUS - 314))
          | (1ULL << (fugue_sqlParser::ASTERISK - 314))
          | (1ULL << (fugue_sqlParser::SLASH - 314)))) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(920);
        fuguePartitionNum(2); 
      }
      setState(925);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 100, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- FuguePartitionNumberContext ------------------------------------------------------------------

fugue_sqlParser::FuguePartitionNumberContext::FuguePartitionNumberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumberContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumberContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumberContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumberContext::ROWCOUNT() {
  return getToken(fugue_sqlParser::ROWCOUNT, 0);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionNumberContext::CONCURRENCY() {
  return getToken(fugue_sqlParser::CONCURRENCY, 0);
}


size_t fugue_sqlParser::FuguePartitionNumberContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePartitionNumber;
}


std::any fugue_sqlParser::FuguePartitionNumberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFuguePartitionNumber(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FuguePartitionNumberContext* fugue_sqlParser::fuguePartitionNumber() {
  FuguePartitionNumberContext *_localctx = _tracker.createInstance<FuguePartitionNumberContext>(_ctx, getState());
  enterRule(_localctx, 96, fugue_sqlParser::RuleFuguePartitionNumber);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(926);
        match(fugue_sqlParser::MINUS);
      }
      setState(929);
      match(fugue_sqlParser::DECIMAL_VALUE);
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(930);
        match(fugue_sqlParser::MINUS);
      }
      setState(933);
      match(fugue_sqlParser::INTEGER_VALUE);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(934);
      match(fugue_sqlParser::ROWCOUNT);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(935);
      match(fugue_sqlParser::CONCURRENCY);
      break;
    }

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

  return _localctx;
}

//----------------- FugueParamsContext ------------------------------------------------------------------

fugue_sqlParser::FugueParamsContext::FugueParamsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::FugueParamsContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueParams;
}

void fugue_sqlParser::FugueParamsContext::copyFrom(FugueParamsContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- FugueParamsPairsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::FugueParamsPairsContext::PARAMS() {
  return getToken(fugue_sqlParser::PARAMS, 0);
}

fugue_sqlParser::FugueJsonPairsContext* fugue_sqlParser::FugueParamsPairsContext::fugueJsonPairs() {
  return getRuleContext<fugue_sqlParser::FugueJsonPairsContext>(0);
}

fugue_sqlParser::FugueParamsPairsContext::FugueParamsPairsContext(FugueParamsContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueParamsPairsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueParamsPairs(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueParamsObjContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonObjContext* fugue_sqlParser::FugueParamsObjContext::fugueJsonObj() {
  return getRuleContext<fugue_sqlParser::FugueJsonObjContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueParamsObjContext::PARAMS() {
  return getToken(fugue_sqlParser::PARAMS, 0);
}

fugue_sqlParser::FugueParamsObjContext::FugueParamsObjContext(FugueParamsContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueParamsObjContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueParamsObj(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::FugueParamsContext* fugue_sqlParser::fugueParams() {
  FugueParamsContext *_localctx = _tracker.createInstance<FugueParamsContext>(_ctx, getState());
  enterRule(_localctx, 98, fugue_sqlParser::RuleFugueParams);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(944);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueParamsPairsContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(938);
      match(fugue_sqlParser::PARAMS);
      setState(939);
      antlrcpp::downCast<FugueParamsPairsContext *>(_localctx)->pairs = fugueJsonPairs();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueParamsObjContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(941);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARAMS) {
        setState(940);
        match(fugue_sqlParser::PARAMS);
      }
      setState(943);
      antlrcpp::downCast<FugueParamsObjContext *>(_localctx)->obj = fugueJsonObj();
      break;
    }

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

  return _localctx;
}

//----------------- FugueColsContext ------------------------------------------------------------------

fugue_sqlParser::FugueColsContext::FugueColsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueColumnIdentifierContext *> fugue_sqlParser::FugueColsContext::fugueColumnIdentifier() {
  return getRuleContexts<fugue_sqlParser::FugueColumnIdentifierContext>();
}

fugue_sqlParser::FugueColumnIdentifierContext* fugue_sqlParser::FugueColsContext::fugueColumnIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueColumnIdentifierContext>(i);
}


size_t fugue_sqlParser::FugueColsContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueCols;
}


std::any fugue_sqlParser::FugueColsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueCols(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::fugueCols() {
  FugueColsContext *_localctx = _tracker.createInstance<FugueColsContext>(_ctx, getState());
  enterRule(_localctx, 100, fugue_sqlParser::RuleFugueCols);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(946);
    fugueColumnIdentifier();
    setState(951);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 106, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(947);
        match(fugue_sqlParser::T__0);
        setState(948);
        fugueColumnIdentifier(); 
      }
      setState(953);
      _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;
}

//----------------- FugueColsSortContext ------------------------------------------------------------------

fugue_sqlParser::FugueColsSortContext::FugueColsSortContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueColSortContext *> fugue_sqlParser::FugueColsSortContext::fugueColSort() {
  return getRuleContexts<fugue_sqlParser::FugueColSortContext>();
}

fugue_sqlParser::FugueColSortContext* fugue_sqlParser::FugueColsSortContext::fugueColSort(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueColSortContext>(i);
}


size_t fugue_sqlParser::FugueColsSortContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueColsSort;
}


std::any fugue_sqlParser::FugueColsSortContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueColsSort(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueColsSortContext* fugue_sqlParser::fugueColsSort() {
  FugueColsSortContext *_localctx = _tracker.createInstance<FugueColsSortContext>(_ctx, getState());
  enterRule(_localctx, 102, fugue_sqlParser::RuleFugueColsSort);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(954);
    fugueColSort();
    setState(959);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(955);
        match(fugue_sqlParser::T__0);
        setState(956);
        fugueColSort(); 
      }
      setState(961);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 107, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueColSortContext ------------------------------------------------------------------

fugue_sqlParser::FugueColSortContext::FugueColSortContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueColumnIdentifierContext* fugue_sqlParser::FugueColSortContext::fugueColumnIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueColumnIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueColSortContext::ASC() {
  return getToken(fugue_sqlParser::ASC, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueColSortContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}


size_t fugue_sqlParser::FugueColSortContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueColSort;
}


std::any fugue_sqlParser::FugueColSortContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueColSort(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueColSortContext* fugue_sqlParser::fugueColSort() {
  FugueColSortContext *_localctx = _tracker.createInstance<FugueColSortContext>(_ctx, getState());
  enterRule(_localctx, 104, fugue_sqlParser::RuleFugueColSort);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 108, _ctx)) {
    case 1: {
      setState(963);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ASC

      || _la == fugue_sqlParser::DESC)) {
      _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;
}

//----------------- FugueColumnIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::FugueColumnIdentifierContext::FugueColumnIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueColumnIdentifierContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}


size_t fugue_sqlParser::FugueColumnIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueColumnIdentifier;
}


std::any fugue_sqlParser::FugueColumnIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueColumnIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueColumnIdentifierContext* fugue_sqlParser::fugueColumnIdentifier() {
  FugueColumnIdentifierContext *_localctx = _tracker.createInstance<FugueColumnIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 106, fugue_sqlParser::RuleFugueColumnIdentifier);

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

  return _localctx;
}

//----------------- FugueRenameExpressionContext ------------------------------------------------------------------

fugue_sqlParser::FugueRenameExpressionContext::FugueRenameExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueRenamePairContext *> fugue_sqlParser::FugueRenameExpressionContext::fugueRenamePair() {
  return getRuleContexts<fugue_sqlParser::FugueRenamePairContext>();
}

fugue_sqlParser::FugueRenamePairContext* fugue_sqlParser::FugueRenameExpressionContext::fugueRenamePair(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueRenamePairContext>(i);
}


size_t fugue_sqlParser::FugueRenameExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueRenameExpression;
}


std::any fugue_sqlParser::FugueRenameExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueRenameExpression(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueRenameExpressionContext* fugue_sqlParser::fugueRenameExpression() {
  FugueRenameExpressionContext *_localctx = _tracker.createInstance<FugueRenameExpressionContext>(_ctx, getState());
  enterRule(_localctx, 108, fugue_sqlParser::RuleFugueRenameExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(968);
    fugueRenamePair();
    setState(973);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(969);
        match(fugue_sqlParser::T__0);
        setState(970);
        fugueRenamePair(); 
      }
      setState(975);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 109, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueWildSchemaContext ------------------------------------------------------------------

fugue_sqlParser::FugueWildSchemaContext::FugueWildSchemaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueWildSchemaPairContext *> fugue_sqlParser::FugueWildSchemaContext::fugueWildSchemaPair() {
  return getRuleContexts<fugue_sqlParser::FugueWildSchemaPairContext>();
}

fugue_sqlParser::FugueWildSchemaPairContext* fugue_sqlParser::FugueWildSchemaContext::fugueWildSchemaPair(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueWildSchemaPairContext>(i);
}

std::vector<fugue_sqlParser::FugueSchemaOpContext *> fugue_sqlParser::FugueWildSchemaContext::fugueSchemaOp() {
  return getRuleContexts<fugue_sqlParser::FugueSchemaOpContext>();
}

fugue_sqlParser::FugueSchemaOpContext* fugue_sqlParser::FugueWildSchemaContext::fugueSchemaOp(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueSchemaOpContext>(i);
}


size_t fugue_sqlParser::FugueWildSchemaContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueWildSchema;
}


std::any fugue_sqlParser::FugueWildSchemaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueWildSchema(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueWildSchemaContext* fugue_sqlParser::fugueWildSchema() {
  FugueWildSchemaContext *_localctx = _tracker.createInstance<FugueWildSchemaContext>(_ctx, getState());
  enterRule(_localctx, 110, fugue_sqlParser::RuleFugueWildSchema);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(976);
    fugueWildSchemaPair();
    setState(981);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(977);
        match(fugue_sqlParser::T__0);
        setState(978);
        fugueWildSchemaPair(); 
      }
      setState(983);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 110, _ctx);
    }
    setState(987);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(984);
        fugueSchemaOp(); 
      }
      setState(989);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueWildSchemaPairContext ------------------------------------------------------------------

fugue_sqlParser::FugueWildSchemaPairContext::FugueWildSchemaPairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueSchemaPairContext* fugue_sqlParser::FugueWildSchemaPairContext::fugueSchemaPair() {
  return getRuleContext<fugue_sqlParser::FugueSchemaPairContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueWildSchemaPairContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}


size_t fugue_sqlParser::FugueWildSchemaPairContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueWildSchemaPair;
}


std::any fugue_sqlParser::FugueWildSchemaPairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueWildSchemaPair(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueWildSchemaPairContext* fugue_sqlParser::fugueWildSchemaPair() {
  FugueWildSchemaPairContext *_localctx = _tracker.createInstance<FugueWildSchemaPairContext>(_ctx, getState());
  enterRule(_localctx, 112, fugue_sqlParser::RuleFugueWildSchemaPair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(992);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        enterOuterAlt(_localctx, 1);
        setState(990);
        antlrcpp::downCast<FugueWildSchemaPairContext *>(_localctx)->pair = fugueSchemaPair();
        break;
      }

      case fugue_sqlParser::ASTERISK: {
        enterOuterAlt(_localctx, 2);
        setState(991);
        match(fugue_sqlParser::ASTERISK);
        break;
      }

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

  return _localctx;
}

//----------------- FugueSchemaOpContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaOpContext::FugueSchemaOpContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueSchemaKeyContext *> fugue_sqlParser::FugueSchemaOpContext::fugueSchemaKey() {
  return getRuleContexts<fugue_sqlParser::FugueSchemaKeyContext>();
}

fugue_sqlParser::FugueSchemaKeyContext* fugue_sqlParser::FugueSchemaOpContext::fugueSchemaKey(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueSchemaKeyContext>(i);
}

tree::TerminalNode* fugue_sqlParser::FugueSchemaOpContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSchemaOpContext::TILDE() {
  return getToken(fugue_sqlParser::TILDE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSchemaOpContext::PLUS() {
  return getToken(fugue_sqlParser::PLUS, 0);
}

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::FugueSchemaOpContext::fugueSchema() {
  return getRuleContext<fugue_sqlParser::FugueSchemaContext>(0);
}


size_t fugue_sqlParser::FugueSchemaOpContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSchemaOp;
}


std::any fugue_sqlParser::FugueSchemaOpContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaOp(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSchemaOpContext* fugue_sqlParser::fugueSchemaOp() {
  FugueSchemaOpContext *_localctx = _tracker.createInstance<FugueSchemaOpContext>(_ctx, getState());
  enterRule(_localctx, 114, fugue_sqlParser::RuleFugueSchemaOp);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1005);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::MINUS:
      case fugue_sqlParser::TILDE: {
        enterOuterAlt(_localctx, 1);
        setState(994);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::MINUS

        || _la == fugue_sqlParser::TILDE)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(995);
        fugueSchemaKey();
        setState(1000);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(996);
            match(fugue_sqlParser::T__0);
            setState(997);
            fugueSchemaKey(); 
          }
          setState(1002);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx);
        }
        break;
      }

      case fugue_sqlParser::PLUS: {
        enterOuterAlt(_localctx, 2);
        setState(1003);
        match(fugue_sqlParser::PLUS);
        setState(1004);
        fugueSchema();
        break;
      }

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

  return _localctx;
}

//----------------- FugueSchemaContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaContext::FugueSchemaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueSchemaPairContext *> fugue_sqlParser::FugueSchemaContext::fugueSchemaPair() {
  return getRuleContexts<fugue_sqlParser::FugueSchemaPairContext>();
}

fugue_sqlParser::FugueSchemaPairContext* fugue_sqlParser::FugueSchemaContext::fugueSchemaPair(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueSchemaPairContext>(i);
}


size_t fugue_sqlParser::FugueSchemaContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSchema;
}


std::any fugue_sqlParser::FugueSchemaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchema(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::fugueSchema() {
  FugueSchemaContext *_localctx = _tracker.createInstance<FugueSchemaContext>(_ctx, getState());
  enterRule(_localctx, 116, fugue_sqlParser::RuleFugueSchema);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1007);
    fugueSchemaPair();
    setState(1012);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1008);
        match(fugue_sqlParser::T__0);
        setState(1009);
        fugueSchemaPair(); 
      }
      setState(1014);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSchemaPairContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaPairContext::FugueSchemaPairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueSchemaKeyContext* fugue_sqlParser::FugueSchemaPairContext::fugueSchemaKey() {
  return getRuleContext<fugue_sqlParser::FugueSchemaKeyContext>(0);
}

fugue_sqlParser::FugueSchemaTypeContext* fugue_sqlParser::FugueSchemaPairContext::fugueSchemaType() {
  return getRuleContext<fugue_sqlParser::FugueSchemaTypeContext>(0);
}


size_t fugue_sqlParser::FugueSchemaPairContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSchemaPair;
}


std::any fugue_sqlParser::FugueSchemaPairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaPair(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSchemaPairContext* fugue_sqlParser::fugueSchemaPair() {
  FugueSchemaPairContext *_localctx = _tracker.createInstance<FugueSchemaPairContext>(_ctx, getState());
  enterRule(_localctx, 118, fugue_sqlParser::RuleFugueSchemaPair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1015);
    antlrcpp::downCast<FugueSchemaPairContext *>(_localctx)->key = fugueSchemaKey();
    setState(1016);
    match(fugue_sqlParser::T__1);
    setState(1017);
    antlrcpp::downCast<FugueSchemaPairContext *>(_localctx)->value = fugueSchemaType();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueSchemaKeyContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaKeyContext::FugueSchemaKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueSchemaKeyContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}


size_t fugue_sqlParser::FugueSchemaKeyContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSchemaKey;
}


std::any fugue_sqlParser::FugueSchemaKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaKey(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueSchemaKeyContext* fugue_sqlParser::fugueSchemaKey() {
  FugueSchemaKeyContext *_localctx = _tracker.createInstance<FugueSchemaKeyContext>(_ctx, getState());
  enterRule(_localctx, 120, fugue_sqlParser::RuleFugueSchemaKey);

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

  return _localctx;
}

//----------------- FugueSchemaTypeContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaTypeContext::FugueSchemaTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::FugueSchemaTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueSchemaType;
}

void fugue_sqlParser::FugueSchemaTypeContext::copyFrom(FugueSchemaTypeContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- FugueSchemaSimpleTypeContext ------------------------------------------------------------------

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueSchemaSimpleTypeContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}

fugue_sqlParser::FugueSchemaSimpleTypeContext::FugueSchemaSimpleTypeContext(FugueSchemaTypeContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueSchemaSimpleTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaSimpleType(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueSchemaStructTypeContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaContext* fugue_sqlParser::FugueSchemaStructTypeContext::fugueSchema() {
  return getRuleContext<fugue_sqlParser::FugueSchemaContext>(0);
}

fugue_sqlParser::FugueSchemaStructTypeContext::FugueSchemaStructTypeContext(FugueSchemaTypeContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueSchemaStructTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaStructType(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueSchemaListTypeContext ------------------------------------------------------------------

fugue_sqlParser::FugueSchemaTypeContext* fugue_sqlParser::FugueSchemaListTypeContext::fugueSchemaType() {
  return getRuleContext<fugue_sqlParser::FugueSchemaTypeContext>(0);
}

fugue_sqlParser::FugueSchemaListTypeContext::FugueSchemaListTypeContext(FugueSchemaTypeContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueSchemaListTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaListType(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::FugueSchemaTypeContext* fugue_sqlParser::fugueSchemaType() {
  FugueSchemaTypeContext *_localctx = _tracker.createInstance<FugueSchemaTypeContext>(_ctx, getState());
  enterRule(_localctx, 122, fugue_sqlParser::RuleFugueSchemaType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1030);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueSchemaSimpleTypeContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(1021);
        fugueIdentifier();
        break;
      }

      case fugue_sqlParser::T__4: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueSchemaListTypeContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(1022);
        match(fugue_sqlParser::T__4);
        setState(1023);
        fugueSchemaType();
        setState(1024);
        match(fugue_sqlParser::T__5);
        break;
      }

      case fugue_sqlParser::T__7: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueSchemaStructTypeContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(1026);
        match(fugue_sqlParser::T__7);
        setState(1027);
        fugueSchema();
        setState(1028);
        match(fugue_sqlParser::T__8);
        break;
      }

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

  return _localctx;
}

//----------------- FugueRenamePairContext ------------------------------------------------------------------

fugue_sqlParser::FugueRenamePairContext::FugueRenamePairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueSchemaKeyContext *> fugue_sqlParser::FugueRenamePairContext::fugueSchemaKey() {
  return getRuleContexts<fugue_sqlParser::FugueSchemaKeyContext>();
}

fugue_sqlParser::FugueSchemaKeyContext* fugue_sqlParser::FugueRenamePairContext::fugueSchemaKey(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueSchemaKeyContext>(i);
}


size_t fugue_sqlParser::FugueRenamePairContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueRenamePair;
}


std::any fugue_sqlParser::FugueRenamePairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueRenamePair(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueRenamePairContext* fugue_sqlParser::fugueRenamePair() {
  FugueRenamePairContext *_localctx = _tracker.createInstance<FugueRenamePairContext>(_ctx, getState());
  enterRule(_localctx, 124, fugue_sqlParser::RuleFugueRenamePair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1032);
    antlrcpp::downCast<FugueRenamePairContext *>(_localctx)->key = fugueSchemaKey();
    setState(1033);
    match(fugue_sqlParser::T__1);
    setState(1034);
    antlrcpp::downCast<FugueRenamePairContext *>(_localctx)->value = fugueSchemaKey();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueJsonContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonContext::FugueJsonContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueJsonValueContext* fugue_sqlParser::FugueJsonContext::fugueJsonValue() {
  return getRuleContext<fugue_sqlParser::FugueJsonValueContext>(0);
}


size_t fugue_sqlParser::FugueJsonContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJson;
}


std::any fugue_sqlParser::FugueJsonContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJson(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonContext* fugue_sqlParser::fugueJson() {
  FugueJsonContext *_localctx = _tracker.createInstance<FugueJsonContext>(_ctx, getState());
  enterRule(_localctx, 126, fugue_sqlParser::RuleFugueJson);

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

  return _localctx;
}

//----------------- FugueJsonObjContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonObjContext::FugueJsonObjContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueJsonPairsContext* fugue_sqlParser::FugueJsonObjContext::fugueJsonPairs() {
  return getRuleContext<fugue_sqlParser::FugueJsonPairsContext>(0);
}


size_t fugue_sqlParser::FugueJsonObjContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonObj;
}


std::any fugue_sqlParser::FugueJsonObjContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonObj(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonObjContext* fugue_sqlParser::fugueJsonObj() {
  FugueJsonObjContext *_localctx = _tracker.createInstance<FugueJsonObjContext>(_ctx, getState());
  enterRule(_localctx, 128, fugue_sqlParser::RuleFugueJsonObj);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1056);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 119, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1038);
      match(fugue_sqlParser::T__7);
      setState(1039);
      fugueJsonPairs();
      setState(1041);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__0) {
        setState(1040);
        match(fugue_sqlParser::T__0);
      }
      setState(1043);
      match(fugue_sqlParser::T__8);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1045);
      match(fugue_sqlParser::T__7);
      setState(1046);
      match(fugue_sqlParser::T__8);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1047);
      match(fugue_sqlParser::T__2);
      setState(1048);
      fugueJsonPairs();
      setState(1050);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__0) {
        setState(1049);
        match(fugue_sqlParser::T__0);
      }
      setState(1052);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1054);
      match(fugue_sqlParser::T__2);
      setState(1055);
      match(fugue_sqlParser::T__3);
      break;
    }

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

  return _localctx;
}

//----------------- FugueJsonPairsContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonPairsContext::FugueJsonPairsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueJsonPairContext *> fugue_sqlParser::FugueJsonPairsContext::fugueJsonPair() {
  return getRuleContexts<fugue_sqlParser::FugueJsonPairContext>();
}

fugue_sqlParser::FugueJsonPairContext* fugue_sqlParser::FugueJsonPairsContext::fugueJsonPair(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueJsonPairContext>(i);
}


size_t fugue_sqlParser::FugueJsonPairsContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonPairs;
}


std::any fugue_sqlParser::FugueJsonPairsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonPairs(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonPairsContext* fugue_sqlParser::fugueJsonPairs() {
  FugueJsonPairsContext *_localctx = _tracker.createInstance<FugueJsonPairsContext>(_ctx, getState());
  enterRule(_localctx, 130, fugue_sqlParser::RuleFugueJsonPairs);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1058);
    fugueJsonPair();
    setState(1063);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1059);
        match(fugue_sqlParser::T__0);
        setState(1060);
        fugueJsonPair(); 
      }
      setState(1065);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueJsonPairContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonPairContext::FugueJsonPairContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueJsonKeyContext* fugue_sqlParser::FugueJsonPairContext::fugueJsonKey() {
  return getRuleContext<fugue_sqlParser::FugueJsonKeyContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FugueJsonPairContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}

fugue_sqlParser::FugueJsonValueContext* fugue_sqlParser::FugueJsonPairContext::fugueJsonValue() {
  return getRuleContext<fugue_sqlParser::FugueJsonValueContext>(0);
}


size_t fugue_sqlParser::FugueJsonPairContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonPair;
}


std::any fugue_sqlParser::FugueJsonPairContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonPair(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonPairContext* fugue_sqlParser::fugueJsonPair() {
  FugueJsonPairContext *_localctx = _tracker.createInstance<FugueJsonPairContext>(_ctx, getState());
  enterRule(_localctx, 132, fugue_sqlParser::RuleFugueJsonPair);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1066);
    antlrcpp::downCast<FugueJsonPairContext *>(_localctx)->key = fugueJsonKey();
    setState(1067);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::T__1 || _la == fugue_sqlParser::EQUAL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1068);
    antlrcpp::downCast<FugueJsonPairContext *>(_localctx)->value = fugueJsonValue();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FugueJsonKeyContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonKeyContext::FugueJsonKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::FugueJsonKeyContext::fugueIdentifier() {
  return getRuleContext<fugue_sqlParser::FugueIdentifierContext>(0);
}

fugue_sqlParser::FugueJsonStringContext* fugue_sqlParser::FugueJsonKeyContext::fugueJsonString() {
  return getRuleContext<fugue_sqlParser::FugueJsonStringContext>(0);
}


size_t fugue_sqlParser::FugueJsonKeyContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonKey;
}


std::any fugue_sqlParser::FugueJsonKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonKey(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonKeyContext* fugue_sqlParser::fugueJsonKey() {
  FugueJsonKeyContext *_localctx = _tracker.createInstance<FugueJsonKeyContext>(_ctx, getState());
  enterRule(_localctx, 134, fugue_sqlParser::RuleFugueJsonKey);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1072);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        enterOuterAlt(_localctx, 1);
        setState(1070);
        fugueIdentifier();
        break;
      }

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 2);
        setState(1071);
        fugueJsonString();
        break;
      }

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

  return _localctx;
}

//----------------- FugueJsonArrayContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonArrayContext::FugueJsonArrayContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::FugueJsonValueContext *> fugue_sqlParser::FugueJsonArrayContext::fugueJsonValue() {
  return getRuleContexts<fugue_sqlParser::FugueJsonValueContext>();
}

fugue_sqlParser::FugueJsonValueContext* fugue_sqlParser::FugueJsonArrayContext::fugueJsonValue(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueJsonValueContext>(i);
}


size_t fugue_sqlParser::FugueJsonArrayContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonArray;
}


std::any fugue_sqlParser::FugueJsonArrayContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonArray(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonArrayContext* fugue_sqlParser::fugueJsonArray() {
  FugueJsonArrayContext *_localctx = _tracker.createInstance<FugueJsonArrayContext>(_ctx, getState());
  enterRule(_localctx, 136, fugue_sqlParser::RuleFugueJsonArray);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1090);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1074);
      match(fugue_sqlParser::T__4);
      setState(1075);
      fugueJsonValue();
      setState(1080);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 122, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1076);
          match(fugue_sqlParser::T__0);
          setState(1077);
          fugueJsonValue(); 
        }
        setState(1082);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 122, _ctx);
      }
      setState(1084);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__0) {
        setState(1083);
        match(fugue_sqlParser::T__0);
      }
      setState(1086);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1088);
      match(fugue_sqlParser::T__4);
      setState(1089);
      match(fugue_sqlParser::T__5);
      break;
    }

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

  return _localctx;
}

//----------------- FugueJsonValueContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonValueContext::FugueJsonValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FugueJsonStringContext* fugue_sqlParser::FugueJsonValueContext::fugueJsonString() {
  return getRuleContext<fugue_sqlParser::FugueJsonStringContext>(0);
}

fugue_sqlParser::FugueJsonNumberContext* fugue_sqlParser::FugueJsonValueContext::fugueJsonNumber() {
  return getRuleContext<fugue_sqlParser::FugueJsonNumberContext>(0);
}

fugue_sqlParser::FugueJsonObjContext* fugue_sqlParser::FugueJsonValueContext::fugueJsonObj() {
  return getRuleContext<fugue_sqlParser::FugueJsonObjContext>(0);
}

fugue_sqlParser::FugueJsonArrayContext* fugue_sqlParser::FugueJsonValueContext::fugueJsonArray() {
  return getRuleContext<fugue_sqlParser::FugueJsonArrayContext>(0);
}

fugue_sqlParser::FugueJsonBoolContext* fugue_sqlParser::FugueJsonValueContext::fugueJsonBool() {
  return getRuleContext<fugue_sqlParser::FugueJsonBoolContext>(0);
}

fugue_sqlParser::FugueJsonNullContext* fugue_sqlParser::FugueJsonValueContext::fugueJsonNull() {
  return getRuleContext<fugue_sqlParser::FugueJsonNullContext>(0);
}


size_t fugue_sqlParser::FugueJsonValueContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonValue;
}


std::any fugue_sqlParser::FugueJsonValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonValue(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonValueContext* fugue_sqlParser::fugueJsonValue() {
  FugueJsonValueContext *_localctx = _tracker.createInstance<FugueJsonValueContext>(_ctx, getState());
  enterRule(_localctx, 138, fugue_sqlParser::RuleFugueJsonValue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1098);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 1);
        setState(1092);
        fugueJsonString();
        break;
      }

      case fugue_sqlParser::MINUS:
      case fugue_sqlParser::BIGINT_LITERAL:
      case fugue_sqlParser::SMALLINT_LITERAL:
      case fugue_sqlParser::TINYINT_LITERAL:
      case fugue_sqlParser::INTEGER_VALUE:
      case fugue_sqlParser::EXPONENT_VALUE:
      case fugue_sqlParser::DECIMAL_VALUE:
      case fugue_sqlParser::DOUBLE_LITERAL:
      case fugue_sqlParser::BIGDECIMAL_LITERAL: {
        enterOuterAlt(_localctx, 2);
        setState(1093);
        fugueJsonNumber();
        break;
      }

      case fugue_sqlParser::T__2:
      case fugue_sqlParser::T__7: {
        enterOuterAlt(_localctx, 3);
        setState(1094);
        fugueJsonObj();
        break;
      }

      case fugue_sqlParser::T__4: {
        enterOuterAlt(_localctx, 4);
        setState(1095);
        fugueJsonArray();
        break;
      }

      case fugue_sqlParser::T__9:
      case fugue_sqlParser::T__10:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::TRUE: {
        enterOuterAlt(_localctx, 5);
        setState(1096);
        fugueJsonBool();
        break;
      }

      case fugue_sqlParser::T__11:
      case fugue_sqlParser::THENULL: {
        enterOuterAlt(_localctx, 6);
        setState(1097);
        fugueJsonNull();
        break;
      }

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

  return _localctx;
}

//----------------- FugueJsonNumberContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonNumberContext::FugueJsonNumberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::NumberContext* fugue_sqlParser::FugueJsonNumberContext::number() {
  return getRuleContext<fugue_sqlParser::NumberContext>(0);
}


size_t fugue_sqlParser::FugueJsonNumberContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonNumber;
}


std::any fugue_sqlParser::FugueJsonNumberContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonNumber(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonNumberContext* fugue_sqlParser::fugueJsonNumber() {
  FugueJsonNumberContext *_localctx = _tracker.createInstance<FugueJsonNumberContext>(_ctx, getState());
  enterRule(_localctx, 140, fugue_sqlParser::RuleFugueJsonNumber);

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

  return _localctx;
}

//----------------- FugueJsonStringContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonStringContext::FugueJsonStringContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueJsonStringContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::FugueJsonStringContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonString;
}


std::any fugue_sqlParser::FugueJsonStringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonString(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonStringContext* fugue_sqlParser::fugueJsonString() {
  FugueJsonStringContext *_localctx = _tracker.createInstance<FugueJsonStringContext>(_ctx, getState());
  enterRule(_localctx, 142, fugue_sqlParser::RuleFugueJsonString);

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

  return _localctx;
}

//----------------- FugueJsonBoolContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonBoolContext::FugueJsonBoolContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueJsonBoolContext::TRUE() {
  return getToken(fugue_sqlParser::TRUE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueJsonBoolContext::FALSE() {
  return getToken(fugue_sqlParser::FALSE, 0);
}


size_t fugue_sqlParser::FugueJsonBoolContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonBool;
}


std::any fugue_sqlParser::FugueJsonBoolContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonBool(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonBoolContext* fugue_sqlParser::fugueJsonBool() {
  FugueJsonBoolContext *_localctx = _tracker.createInstance<FugueJsonBoolContext>(_ctx, getState());
  enterRule(_localctx, 144, fugue_sqlParser::RuleFugueJsonBool);
  size_t _la = 0;

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

    || _la == fugue_sqlParser::T__10 || _la == fugue_sqlParser::FALSE || _la == fugue_sqlParser::TRUE)) {
    _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;
}

//----------------- FugueJsonNullContext ------------------------------------------------------------------

fugue_sqlParser::FugueJsonNullContext::FugueJsonNullContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FugueJsonNullContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}


size_t fugue_sqlParser::FugueJsonNullContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueJsonNull;
}


std::any fugue_sqlParser::FugueJsonNullContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueJsonNull(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueJsonNullContext* fugue_sqlParser::fugueJsonNull() {
  FugueJsonNullContext *_localctx = _tracker.createInstance<FugueJsonNullContext>(_ctx, getState());
  enterRule(_localctx, 146, fugue_sqlParser::RuleFugueJsonNull);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1106);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::T__11 || _la == fugue_sqlParser::THENULL)) {
    _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;
}

//----------------- FugueIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::FugueIdentifierContext::FugueIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::FugueIdentifierContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}


size_t fugue_sqlParser::FugueIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFugueIdentifier;
}


std::any fugue_sqlParser::FugueIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FugueIdentifierContext* fugue_sqlParser::fugueIdentifier() {
  FugueIdentifierContext *_localctx = _tracker.createInstance<FugueIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 148, fugue_sqlParser::RuleFugueIdentifier);

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

  return _localctx;
}

//----------------- SingleStatementContext ------------------------------------------------------------------

fugue_sqlParser::SingleStatementContext::SingleStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::StatementContext* fugue_sqlParser::SingleStatementContext::statement() {
  return getRuleContext<fugue_sqlParser::StatementContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleStatementContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleStatementContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleStatement;
}


std::any fugue_sqlParser::SingleStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleStatement(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleStatementContext* fugue_sqlParser::singleStatement() {
  SingleStatementContext *_localctx = _tracker.createInstance<SingleStatementContext>(_ctx, getState());
  enterRule(_localctx, 150, fugue_sqlParser::RuleSingleStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1110);
    statement();
    setState(1114);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__12) {
      setState(1111);
      match(fugue_sqlParser::T__12);
      setState(1116);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1117);
    match(fugue_sqlParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SingleExpressionContext ------------------------------------------------------------------

fugue_sqlParser::SingleExpressionContext::SingleExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::NamedExpressionContext* fugue_sqlParser::SingleExpressionContext::namedExpression() {
  return getRuleContext<fugue_sqlParser::NamedExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleExpressionContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleExpression;
}


std::any fugue_sqlParser::SingleExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleExpression(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleExpressionContext* fugue_sqlParser::singleExpression() {
  SingleExpressionContext *_localctx = _tracker.createInstance<SingleExpressionContext>(_ctx, getState());
  enterRule(_localctx, 152, fugue_sqlParser::RuleSingleExpression);

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

  return _localctx;
}

//----------------- SingleTableIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::SingleTableIdentifierContext::SingleTableIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::TableIdentifierContext* fugue_sqlParser::SingleTableIdentifierContext::tableIdentifier() {
  return getRuleContext<fugue_sqlParser::TableIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleTableIdentifierContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleTableIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleTableIdentifier;
}


std::any fugue_sqlParser::SingleTableIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleTableIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleTableIdentifierContext* fugue_sqlParser::singleTableIdentifier() {
  SingleTableIdentifierContext *_localctx = _tracker.createInstance<SingleTableIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 154, fugue_sqlParser::RuleSingleTableIdentifier);

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

  return _localctx;
}

//----------------- SingleMultipartIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::SingleMultipartIdentifierContext::SingleMultipartIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::SingleMultipartIdentifierContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleMultipartIdentifierContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleMultipartIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleMultipartIdentifier;
}


std::any fugue_sqlParser::SingleMultipartIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleMultipartIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleMultipartIdentifierContext* fugue_sqlParser::singleMultipartIdentifier() {
  SingleMultipartIdentifierContext *_localctx = _tracker.createInstance<SingleMultipartIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 156, fugue_sqlParser::RuleSingleMultipartIdentifier);

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

  return _localctx;
}

//----------------- SingleFunctionIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::SingleFunctionIdentifierContext::SingleFunctionIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FunctionIdentifierContext* fugue_sqlParser::SingleFunctionIdentifierContext::functionIdentifier() {
  return getRuleContext<fugue_sqlParser::FunctionIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleFunctionIdentifierContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleFunctionIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleFunctionIdentifier;
}


std::any fugue_sqlParser::SingleFunctionIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleFunctionIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleFunctionIdentifierContext* fugue_sqlParser::singleFunctionIdentifier() {
  SingleFunctionIdentifierContext *_localctx = _tracker.createInstance<SingleFunctionIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 158, fugue_sqlParser::RuleSingleFunctionIdentifier);

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

  return _localctx;
}

//----------------- SingleDataTypeContext ------------------------------------------------------------------

fugue_sqlParser::SingleDataTypeContext::SingleDataTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::SingleDataTypeContext::dataType() {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleDataTypeContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleDataTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleDataType;
}


std::any fugue_sqlParser::SingleDataTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleDataType(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleDataTypeContext* fugue_sqlParser::singleDataType() {
  SingleDataTypeContext *_localctx = _tracker.createInstance<SingleDataTypeContext>(_ctx, getState());
  enterRule(_localctx, 160, fugue_sqlParser::RuleSingleDataType);

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

  return _localctx;
}

//----------------- SingleTableSchemaContext ------------------------------------------------------------------

fugue_sqlParser::SingleTableSchemaContext::SingleTableSchemaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::SingleTableSchemaContext::colTypeList() {
  return getRuleContext<fugue_sqlParser::ColTypeListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SingleTableSchemaContext::EOF() {
  return getToken(fugue_sqlParser::EOF, 0);
}


size_t fugue_sqlParser::SingleTableSchemaContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSingleTableSchema;
}


std::any fugue_sqlParser::SingleTableSchemaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleTableSchema(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SingleTableSchemaContext* fugue_sqlParser::singleTableSchema() {
  SingleTableSchemaContext *_localctx = _tracker.createInstance<SingleTableSchemaContext>(_ctx, getState());
  enterRule(_localctx, 162, fugue_sqlParser::RuleSingleTableSchema);

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

  return _localctx;
}

//----------------- StatementContext ------------------------------------------------------------------

fugue_sqlParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::StatementContext::getRuleIndex() const {
  return fugue_sqlParser::RuleStatement;
}

void fugue_sqlParser::StatementContext::copyFrom(StatementContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- ExplainContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ExplainContext::EXPLAIN() {
  return getToken(fugue_sqlParser::EXPLAIN, 0);
}

fugue_sqlParser::StatementContext* fugue_sqlParser::ExplainContext::statement() {
  return getRuleContext<fugue_sqlParser::StatementContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ExplainContext::LOGICAL() {
  return getToken(fugue_sqlParser::LOGICAL, 0);
}

tree::TerminalNode* fugue_sqlParser::ExplainContext::FORMATTED() {
  return getToken(fugue_sqlParser::FORMATTED, 0);
}

tree::TerminalNode* fugue_sqlParser::ExplainContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

tree::TerminalNode* fugue_sqlParser::ExplainContext::CODEGEN() {
  return getToken(fugue_sqlParser::CODEGEN, 0);
}

tree::TerminalNode* fugue_sqlParser::ExplainContext::COST() {
  return getToken(fugue_sqlParser::COST, 0);
}

fugue_sqlParser::ExplainContext::ExplainContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ExplainContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitExplain(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ResetConfigurationContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ResetConfigurationContext::RESET() {
  return getToken(fugue_sqlParser::RESET, 0);
}

fugue_sqlParser::ResetConfigurationContext::ResetConfigurationContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ResetConfigurationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitResetConfiguration(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AlterViewQueryContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::AlterViewQueryContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::AlterViewQueryContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::AlterViewQueryContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::AlterViewQueryContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AlterViewQueryContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::AlterViewQueryContext::AlterViewQueryContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AlterViewQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAlterViewQuery(this);
  else
    return visitor->visitChildren(this);
}
//----------------- UseContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::UseContext::USE() {
  return getToken(fugue_sqlParser::USE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::UseContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::UseContext::NAMESPACE() {
  return getToken(fugue_sqlParser::NAMESPACE, 0);
}

fugue_sqlParser::UseContext::UseContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::UseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUse(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DropNamespaceContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DropNamespaceContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::DropNamespaceContext::theNamespace() {
  return getRuleContext<fugue_sqlParser::TheNamespaceContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DropNamespaceContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DropNamespaceContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::DropNamespaceContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::DropNamespaceContext::RESTRICT() {
  return getToken(fugue_sqlParser::RESTRICT, 0);
}

tree::TerminalNode* fugue_sqlParser::DropNamespaceContext::CASCADE() {
  return getToken(fugue_sqlParser::CASCADE, 0);
}

fugue_sqlParser::DropNamespaceContext::DropNamespaceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DropNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDropNamespace(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateTempViewUsingContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

fugue_sqlParser::TableIdentifierContext* fugue_sqlParser::CreateTempViewUsingContext::tableIdentifier() {
  return getRuleContext<fugue_sqlParser::TableIdentifierContext>(0);
}

fugue_sqlParser::TableProviderContext* fugue_sqlParser::CreateTempViewUsingContext::tableProvider() {
  return getRuleContext<fugue_sqlParser::TableProviderContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::GLOBAL() {
  return getToken(fugue_sqlParser::GLOBAL, 0);
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::CreateTempViewUsingContext::colTypeList() {
  return getRuleContext<fugue_sqlParser::ColTypeListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateTempViewUsingContext::OPTIONS() {
  return getToken(fugue_sqlParser::OPTIONS, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CreateTempViewUsingContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

fugue_sqlParser::CreateTempViewUsingContext::CreateTempViewUsingContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateTempViewUsingContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateTempViewUsing(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RenameTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RenameTableContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableContext::RENAME() {
  return getToken(fugue_sqlParser::RENAME, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableContext::TO() {
  return getToken(fugue_sqlParser::TO, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::RenameTableContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::RenameTableContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}

fugue_sqlParser::RenameTableContext::RenameTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RenameTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRenameTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FailNativeCommandContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::FailNativeCommandContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::FailNativeCommandContext::ROLE() {
  return getToken(fugue_sqlParser::ROLE, 0);
}

fugue_sqlParser::UnsupportedHiveNativeCommandsContext* fugue_sqlParser::FailNativeCommandContext::unsupportedHiveNativeCommands() {
  return getRuleContext<fugue_sqlParser::UnsupportedHiveNativeCommandsContext>(0);
}

fugue_sqlParser::FailNativeCommandContext::FailNativeCommandContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FailNativeCommandContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFailNativeCommand(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ClearCacheContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ClearCacheContext::CLEAR() {
  return getToken(fugue_sqlParser::CLEAR, 0);
}

tree::TerminalNode* fugue_sqlParser::ClearCacheContext::CACHE() {
  return getToken(fugue_sqlParser::CACHE, 0);
}

fugue_sqlParser::ClearCacheContext::ClearCacheContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ClearCacheContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitClearCache(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DropViewContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DropViewContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::DropViewContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DropViewContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DropViewContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::DropViewContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::DropViewContext::DropViewContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DropViewContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDropView(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowTablesContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowTablesContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTablesContext::TABLES() {
  return getToken(fugue_sqlParser::TABLES, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowTablesContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ShowTablesContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTablesContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTablesContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTablesContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

fugue_sqlParser::ShowTablesContext::ShowTablesContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowTablesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowTables(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RecoverPartitionsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RecoverPartitionsContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::RecoverPartitionsContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::RecoverPartitionsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::RecoverPartitionsContext::RECOVER() {
  return getToken(fugue_sqlParser::RECOVER, 0);
}

tree::TerminalNode* fugue_sqlParser::RecoverPartitionsContext::PARTITIONS() {
  return getToken(fugue_sqlParser::PARTITIONS, 0);
}

fugue_sqlParser::RecoverPartitionsContext::RecoverPartitionsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RecoverPartitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRecoverPartitions(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowCurrentNamespaceContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowCurrentNamespaceContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowCurrentNamespaceContext::CURRENT() {
  return getToken(fugue_sqlParser::CURRENT, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowCurrentNamespaceContext::NAMESPACE() {
  return getToken(fugue_sqlParser::NAMESPACE, 0);
}

fugue_sqlParser::ShowCurrentNamespaceContext::ShowCurrentNamespaceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowCurrentNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowCurrentNamespace(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RenameTablePartitionContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RenameTablePartitionContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTablePartitionContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::RenameTablePartitionContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::RenameTablePartitionContext::RENAME() {
  return getToken(fugue_sqlParser::RENAME, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTablePartitionContext::TO() {
  return getToken(fugue_sqlParser::TO, 0);
}

std::vector<fugue_sqlParser::PartitionSpecContext *> fugue_sqlParser::RenameTablePartitionContext::partitionSpec() {
  return getRuleContexts<fugue_sqlParser::PartitionSpecContext>();
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::RenameTablePartitionContext::partitionSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(i);
}

fugue_sqlParser::RenameTablePartitionContext::RenameTablePartitionContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RenameTablePartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRenameTablePartition(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RepairTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RepairTableContext::MSCK() {
  return getToken(fugue_sqlParser::MSCK, 0);
}

tree::TerminalNode* fugue_sqlParser::RepairTableContext::REPAIR() {
  return getToken(fugue_sqlParser::REPAIR, 0);
}

tree::TerminalNode* fugue_sqlParser::RepairTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::RepairTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::RepairTableContext::RepairTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RepairTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRepairTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RefreshResourceContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RefreshResourceContext::REFRESH() {
  return getToken(fugue_sqlParser::REFRESH, 0);
}

tree::TerminalNode* fugue_sqlParser::RefreshResourceContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::RefreshResourceContext::RefreshResourceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RefreshResourceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRefreshResource(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowCreateTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowCreateTableContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowCreateTableContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowCreateTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowCreateTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ShowCreateTableContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowCreateTableContext::SERDE() {
  return getToken(fugue_sqlParser::SERDE, 0);
}

fugue_sqlParser::ShowCreateTableContext::ShowCreateTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowCreateTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowCreateTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowNamespacesContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::DATABASES() {
  return getToken(fugue_sqlParser::DATABASES, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::NAMESPACES() {
  return getToken(fugue_sqlParser::NAMESPACES, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowNamespacesContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowNamespacesContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

fugue_sqlParser::ShowNamespacesContext::ShowNamespacesContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowNamespacesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowNamespaces(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowColumnsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowColumnsContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowColumnsContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::ShowColumnsContext::FROM() {
  return getTokens(fugue_sqlParser::FROM);
}

tree::TerminalNode* fugue_sqlParser::ShowColumnsContext::FROM(size_t i) {
  return getToken(fugue_sqlParser::FROM, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::ShowColumnsContext::IN() {
  return getTokens(fugue_sqlParser::IN);
}

tree::TerminalNode* fugue_sqlParser::ShowColumnsContext::IN(size_t i) {
  return getToken(fugue_sqlParser::IN, i);
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::ShowColumnsContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowColumnsContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}

fugue_sqlParser::ShowColumnsContext::ShowColumnsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowColumnsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowColumns(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ReplaceTableContext ------------------------------------------------------------------

fugue_sqlParser::ReplaceTableHeaderContext* fugue_sqlParser::ReplaceTableContext::replaceTableHeader() {
  return getRuleContext<fugue_sqlParser::ReplaceTableHeaderContext>(0);
}

fugue_sqlParser::TableProviderContext* fugue_sqlParser::ReplaceTableContext::tableProvider() {
  return getRuleContext<fugue_sqlParser::TableProviderContext>(0);
}

fugue_sqlParser::CreateTableClausesContext* fugue_sqlParser::ReplaceTableContext::createTableClauses() {
  return getRuleContext<fugue_sqlParser::CreateTableClausesContext>(0);
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::ReplaceTableContext::colTypeList() {
  return getRuleContext<fugue_sqlParser::ColTypeListContext>(0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::ReplaceTableContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ReplaceTableContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::ReplaceTableContext::ReplaceTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ReplaceTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitReplaceTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AddTablePartitionContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::AddTablePartitionContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::ADD() {
  return getToken(fugue_sqlParser::ADD, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTablePartitionContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

std::vector<fugue_sqlParser::PartitionSpecLocationContext *> fugue_sqlParser::AddTablePartitionContext::partitionSpecLocation() {
  return getRuleContexts<fugue_sqlParser::PartitionSpecLocationContext>();
}

fugue_sqlParser::PartitionSpecLocationContext* fugue_sqlParser::AddTablePartitionContext::partitionSpecLocation(size_t i) {
  return getRuleContext<fugue_sqlParser::PartitionSpecLocationContext>(i);
}

fugue_sqlParser::AddTablePartitionContext::AddTablePartitionContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AddTablePartitionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAddTablePartition(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetNamespaceLocationContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SetNamespaceLocationContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::SetNamespaceLocationContext::theNamespace() {
  return getRuleContext<fugue_sqlParser::TheNamespaceContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::SetNamespaceLocationContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetNamespaceLocationContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::SetNamespaceLocationContext::locationSpec() {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(0);
}

fugue_sqlParser::SetNamespaceLocationContext::SetNamespaceLocationContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetNamespaceLocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetNamespaceLocation(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RefreshTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RefreshTableContext::REFRESH() {
  return getToken(fugue_sqlParser::REFRESH, 0);
}

tree::TerminalNode* fugue_sqlParser::RefreshTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::RefreshTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::RefreshTableContext::RefreshTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RefreshTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRefreshTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetNamespacePropertiesContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SetNamespacePropertiesContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::SetNamespacePropertiesContext::theNamespace() {
  return getRuleContext<fugue_sqlParser::TheNamespaceContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::SetNamespacePropertiesContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetNamespacePropertiesContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::SetNamespacePropertiesContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetNamespacePropertiesContext::DBPROPERTIES() {
  return getToken(fugue_sqlParser::DBPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::SetNamespacePropertiesContext::PROPERTIES() {
  return getToken(fugue_sqlParser::PROPERTIES, 0);
}

fugue_sqlParser::SetNamespacePropertiesContext::SetNamespacePropertiesContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetNamespacePropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetNamespaceProperties(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ManageResourceContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ManageResourceContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ManageResourceContext::ADD() {
  return getToken(fugue_sqlParser::ADD, 0);
}

tree::TerminalNode* fugue_sqlParser::ManageResourceContext::LIST() {
  return getToken(fugue_sqlParser::LIST, 0);
}

tree::TerminalNode* fugue_sqlParser::ManageResourceContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::ManageResourceContext::ManageResourceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ManageResourceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitManageResource(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AnalyzeContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::ANALYZE() {
  return getToken(fugue_sqlParser::ANALYZE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::AnalyzeContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::COMPUTE() {
  return getToken(fugue_sqlParser::COMPUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::STATISTICS() {
  return getToken(fugue_sqlParser::STATISTICS, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::AnalyzeContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::AnalyzeContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::FOR() {
  return getToken(fugue_sqlParser::FOR, 0);
}

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::IdentifierSeqContext* fugue_sqlParser::AnalyzeContext::identifierSeq() {
  return getRuleContext<fugue_sqlParser::IdentifierSeqContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AnalyzeContext::ALL() {
  return getToken(fugue_sqlParser::ALL, 0);
}

fugue_sqlParser::AnalyzeContext::AnalyzeContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AnalyzeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAnalyze(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateHiveTableContext ------------------------------------------------------------------

fugue_sqlParser::CreateTableHeaderContext* fugue_sqlParser::CreateHiveTableContext::createTableHeader() {
  return getRuleContext<fugue_sqlParser::CreateTableHeaderContext>(0);
}

std::vector<fugue_sqlParser::CommentSpecContext *> fugue_sqlParser::CreateHiveTableContext::commentSpec() {
  return getRuleContexts<fugue_sqlParser::CommentSpecContext>();
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::CreateHiveTableContext::commentSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(i);
}

std::vector<fugue_sqlParser::BucketSpecContext *> fugue_sqlParser::CreateHiveTableContext::bucketSpec() {
  return getRuleContexts<fugue_sqlParser::BucketSpecContext>();
}

fugue_sqlParser::BucketSpecContext* fugue_sqlParser::CreateHiveTableContext::bucketSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::BucketSpecContext>(i);
}

std::vector<fugue_sqlParser::SkewSpecContext *> fugue_sqlParser::CreateHiveTableContext::skewSpec() {
  return getRuleContexts<fugue_sqlParser::SkewSpecContext>();
}

fugue_sqlParser::SkewSpecContext* fugue_sqlParser::CreateHiveTableContext::skewSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::SkewSpecContext>(i);
}

std::vector<fugue_sqlParser::RowFormatContext *> fugue_sqlParser::CreateHiveTableContext::rowFormat() {
  return getRuleContexts<fugue_sqlParser::RowFormatContext>();
}

fugue_sqlParser::RowFormatContext* fugue_sqlParser::CreateHiveTableContext::rowFormat(size_t i) {
  return getRuleContext<fugue_sqlParser::RowFormatContext>(i);
}

std::vector<fugue_sqlParser::CreateFileFormatContext *> fugue_sqlParser::CreateHiveTableContext::createFileFormat() {
  return getRuleContexts<fugue_sqlParser::CreateFileFormatContext>();
}

fugue_sqlParser::CreateFileFormatContext* fugue_sqlParser::CreateHiveTableContext::createFileFormat(size_t i) {
  return getRuleContext<fugue_sqlParser::CreateFileFormatContext>(i);
}

std::vector<fugue_sqlParser::LocationSpecContext *> fugue_sqlParser::CreateHiveTableContext::locationSpec() {
  return getRuleContexts<fugue_sqlParser::LocationSpecContext>();
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::CreateHiveTableContext::locationSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(i);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::CreateHiveTableContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

std::vector<fugue_sqlParser::ColTypeListContext *> fugue_sqlParser::CreateHiveTableContext::colTypeList() {
  return getRuleContexts<fugue_sqlParser::ColTypeListContext>();
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::CreateHiveTableContext::colTypeList(size_t i) {
  return getRuleContext<fugue_sqlParser::ColTypeListContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateHiveTableContext::PARTITIONED() {
  return getTokens(fugue_sqlParser::PARTITIONED);
}

tree::TerminalNode* fugue_sqlParser::CreateHiveTableContext::PARTITIONED(size_t i) {
  return getToken(fugue_sqlParser::PARTITIONED, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateHiveTableContext::BY() {
  return getTokens(fugue_sqlParser::BY);
}

tree::TerminalNode* fugue_sqlParser::CreateHiveTableContext::BY(size_t i) {
  return getToken(fugue_sqlParser::BY, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateHiveTableContext::TBLPROPERTIES() {
  return getTokens(fugue_sqlParser::TBLPROPERTIES);
}

tree::TerminalNode* fugue_sqlParser::CreateHiveTableContext::TBLPROPERTIES(size_t i) {
  return getToken(fugue_sqlParser::TBLPROPERTIES, i);
}

std::vector<fugue_sqlParser::IdentifierListContext *> fugue_sqlParser::CreateHiveTableContext::identifierList() {
  return getRuleContexts<fugue_sqlParser::IdentifierListContext>();
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::CreateHiveTableContext::identifierList(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(i);
}

std::vector<fugue_sqlParser::TablePropertyListContext *> fugue_sqlParser::CreateHiveTableContext::tablePropertyList() {
  return getRuleContexts<fugue_sqlParser::TablePropertyListContext>();
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CreateHiveTableContext::tablePropertyList(size_t i) {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(i);
}

tree::TerminalNode* fugue_sqlParser::CreateHiveTableContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::CreateHiveTableContext::CreateHiveTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateHiveTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateHiveTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateFunctionContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::FUNCTION() {
  return getToken(fugue_sqlParser::FUNCTION, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CreateFunctionContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFunctionContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

std::vector<fugue_sqlParser::ResourceContext *> fugue_sqlParser::CreateFunctionContext::resource() {
  return getRuleContexts<fugue_sqlParser::ResourceContext>();
}

fugue_sqlParser::ResourceContext* fugue_sqlParser::CreateFunctionContext::resource(size_t i) {
  return getRuleContext<fugue_sqlParser::ResourceContext>(i);
}

fugue_sqlParser::CreateFunctionContext::CreateFunctionContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowTableContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTableContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTableContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTableContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::ShowTableContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ShowTableContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTableContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::ShowTableContext::ShowTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- HiveReplaceColumnsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::HiveReplaceColumnsContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::HiveReplaceColumnsContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::HiveReplaceColumnsContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::HiveReplaceColumnsContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::HiveReplaceColumnsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::QualifiedColTypeWithPositionListContext* fugue_sqlParser::HiveReplaceColumnsContext::qualifiedColTypeWithPositionList() {
  return getRuleContext<fugue_sqlParser::QualifiedColTypeWithPositionListContext>(0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::HiveReplaceColumnsContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::HiveReplaceColumnsContext::HiveReplaceColumnsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::HiveReplaceColumnsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitHiveReplaceColumns(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CommentNamespaceContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CommentNamespaceContext::COMMENT() {
  return getToken(fugue_sqlParser::COMMENT, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentNamespaceContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::CommentNamespaceContext::theNamespace() {
  return getRuleContext<fugue_sqlParser::TheNamespaceContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CommentNamespaceContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CommentNamespaceContext::IS() {
  return getToken(fugue_sqlParser::IS, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentNamespaceContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentNamespaceContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

fugue_sqlParser::CommentNamespaceContext::CommentNamespaceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CommentNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCommentNamespace(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateTableContext ------------------------------------------------------------------

fugue_sqlParser::CreateTableHeaderContext* fugue_sqlParser::CreateTableContext::createTableHeader() {
  return getRuleContext<fugue_sqlParser::CreateTableHeaderContext>(0);
}

fugue_sqlParser::TableProviderContext* fugue_sqlParser::CreateTableContext::tableProvider() {
  return getRuleContext<fugue_sqlParser::TableProviderContext>(0);
}

fugue_sqlParser::CreateTableClausesContext* fugue_sqlParser::CreateTableContext::createTableClauses() {
  return getRuleContext<fugue_sqlParser::CreateTableClausesContext>(0);
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::CreateTableContext::colTypeList() {
  return getRuleContext<fugue_sqlParser::ColTypeListContext>(0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::CreateTableContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::CreateTableContext::CreateTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DmlStatementContext ------------------------------------------------------------------

fugue_sqlParser::DmlStatementNoWithContext* fugue_sqlParser::DmlStatementContext::dmlStatementNoWith() {
  return getRuleContext<fugue_sqlParser::DmlStatementNoWithContext>(0);
}

fugue_sqlParser::CtesContext* fugue_sqlParser::DmlStatementContext::ctes() {
  return getRuleContext<fugue_sqlParser::CtesContext>(0);
}

fugue_sqlParser::DmlStatementContext::DmlStatementContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DmlStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDmlStatement(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateTableLikeContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

std::vector<fugue_sqlParser::TableIdentifierContext *> fugue_sqlParser::CreateTableLikeContext::tableIdentifier() {
  return getRuleContexts<fugue_sqlParser::TableIdentifierContext>();
}

fugue_sqlParser::TableIdentifierContext* fugue_sqlParser::CreateTableLikeContext::tableIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::TableIdentifierContext>(i);
}

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

std::vector<fugue_sqlParser::TableProviderContext *> fugue_sqlParser::CreateTableLikeContext::tableProvider() {
  return getRuleContexts<fugue_sqlParser::TableProviderContext>();
}

fugue_sqlParser::TableProviderContext* fugue_sqlParser::CreateTableLikeContext::tableProvider(size_t i) {
  return getRuleContext<fugue_sqlParser::TableProviderContext>(i);
}

std::vector<fugue_sqlParser::RowFormatContext *> fugue_sqlParser::CreateTableLikeContext::rowFormat() {
  return getRuleContexts<fugue_sqlParser::RowFormatContext>();
}

fugue_sqlParser::RowFormatContext* fugue_sqlParser::CreateTableLikeContext::rowFormat(size_t i) {
  return getRuleContext<fugue_sqlParser::RowFormatContext>(i);
}

std::vector<fugue_sqlParser::CreateFileFormatContext *> fugue_sqlParser::CreateTableLikeContext::createFileFormat() {
  return getRuleContexts<fugue_sqlParser::CreateFileFormatContext>();
}

fugue_sqlParser::CreateFileFormatContext* fugue_sqlParser::CreateTableLikeContext::createFileFormat(size_t i) {
  return getRuleContext<fugue_sqlParser::CreateFileFormatContext>(i);
}

std::vector<fugue_sqlParser::LocationSpecContext *> fugue_sqlParser::CreateTableLikeContext::locationSpec() {
  return getRuleContexts<fugue_sqlParser::LocationSpecContext>();
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::CreateTableLikeContext::locationSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateTableLikeContext::TBLPROPERTIES() {
  return getTokens(fugue_sqlParser::TBLPROPERTIES);
}

tree::TerminalNode* fugue_sqlParser::CreateTableLikeContext::TBLPROPERTIES(size_t i) {
  return getToken(fugue_sqlParser::TBLPROPERTIES, i);
}

std::vector<fugue_sqlParser::TablePropertyListContext *> fugue_sqlParser::CreateTableLikeContext::tablePropertyList() {
  return getRuleContexts<fugue_sqlParser::TablePropertyListContext>();
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CreateTableLikeContext::tablePropertyList(size_t i) {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(i);
}

fugue_sqlParser::CreateTableLikeContext::CreateTableLikeContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateTableLikeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateTableLike(this);
  else
    return visitor->visitChildren(this);
}
//----------------- UncacheTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::UncacheTableContext::UNCACHE() {
  return getToken(fugue_sqlParser::UNCACHE, 0);
}

tree::TerminalNode* fugue_sqlParser::UncacheTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::UncacheTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::UncacheTableContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::UncacheTableContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::UncacheTableContext::UncacheTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::UncacheTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUncacheTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DropFunctionContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DropFunctionContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::DropFunctionContext::FUNCTION() {
  return getToken(fugue_sqlParser::FUNCTION, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DropFunctionContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DropFunctionContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::DropFunctionContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::DropFunctionContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::DropFunctionContext::DropFunctionContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DropFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDropFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DescribeRelationContext ------------------------------------------------------------------

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DescribeRelationContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DescribeRelationContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeRelationContext::DESCRIBE() {
  return getToken(fugue_sqlParser::DESCRIBE, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeRelationContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::DescribeRelationContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::DescribeColNameContext* fugue_sqlParser::DescribeRelationContext::describeColName() {
  return getRuleContext<fugue_sqlParser::DescribeColNameContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DescribeRelationContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeRelationContext::FORMATTED() {
  return getToken(fugue_sqlParser::FORMATTED, 0);
}

fugue_sqlParser::DescribeRelationContext::DescribeRelationContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DescribeRelationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDescribeRelation(this);
  else
    return visitor->visitChildren(this);
}
//----------------- LoadDataContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::LoadDataContext::LOAD() {
  return getToken(fugue_sqlParser::LOAD, 0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::DATA() {
  return getToken(fugue_sqlParser::DATA, 0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::INPATH() {
  return getToken(fugue_sqlParser::INPATH, 0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::INTO() {
  return getToken(fugue_sqlParser::INTO, 0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::LoadDataContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::LOCAL() {
  return getToken(fugue_sqlParser::LOCAL, 0);
}

tree::TerminalNode* fugue_sqlParser::LoadDataContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::LoadDataContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::LoadDataContext::LoadDataContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::LoadDataContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLoadData(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowPartitionsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowPartitionsContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowPartitionsContext::PARTITIONS() {
  return getToken(fugue_sqlParser::PARTITIONS, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowPartitionsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::ShowPartitionsContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::ShowPartitionsContext::ShowPartitionsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowPartitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowPartitions(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DescribeFunctionContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DescribeFunctionContext::FUNCTION() {
  return getToken(fugue_sqlParser::FUNCTION, 0);
}

fugue_sqlParser::DescribeFuncNameContext* fugue_sqlParser::DescribeFunctionContext::describeFuncName() {
  return getRuleContext<fugue_sqlParser::DescribeFuncNameContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DescribeFunctionContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeFunctionContext::DESCRIBE() {
  return getToken(fugue_sqlParser::DESCRIBE, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeFunctionContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

fugue_sqlParser::DescribeFunctionContext::DescribeFunctionContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DescribeFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDescribeFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RenameTableColumnContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RenameTableColumnContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableColumnContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableColumnContext::RENAME() {
  return getToken(fugue_sqlParser::RENAME, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableColumnContext::COLUMN() {
  return getToken(fugue_sqlParser::COLUMN, 0);
}

tree::TerminalNode* fugue_sqlParser::RenameTableColumnContext::TO() {
  return getToken(fugue_sqlParser::TO, 0);
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::RenameTableColumnContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::RenameTableColumnContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::RenameTableColumnContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}

fugue_sqlParser::RenameTableColumnContext::RenameTableColumnContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RenameTableColumnContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRenameTableColumn(this);
  else
    return visitor->visitChildren(this);
}
//----------------- StatementDefaultContext ------------------------------------------------------------------

fugue_sqlParser::QueryContext* fugue_sqlParser::StatementDefaultContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::StatementDefaultContext::StatementDefaultContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::StatementDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitStatementDefault(this);
  else
    return visitor->visitChildren(this);
}
//----------------- HiveChangeColumnContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::HiveChangeColumnContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::HiveChangeColumnContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::HiveChangeColumnContext::CHANGE() {
  return getToken(fugue_sqlParser::CHANGE, 0);
}

fugue_sqlParser::ColTypeContext* fugue_sqlParser::HiveChangeColumnContext::colType() {
  return getRuleContext<fugue_sqlParser::ColTypeContext>(0);
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::HiveChangeColumnContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::HiveChangeColumnContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::HiveChangeColumnContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

tree::TerminalNode* fugue_sqlParser::HiveChangeColumnContext::COLUMN() {
  return getToken(fugue_sqlParser::COLUMN, 0);
}

fugue_sqlParser::ColPositionContext* fugue_sqlParser::HiveChangeColumnContext::colPosition() {
  return getRuleContext<fugue_sqlParser::ColPositionContext>(0);
}

fugue_sqlParser::HiveChangeColumnContext::HiveChangeColumnContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::HiveChangeColumnContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitHiveChangeColumn(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DescribeQueryContext ------------------------------------------------------------------

fugue_sqlParser::QueryContext* fugue_sqlParser::DescribeQueryContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DescribeQueryContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeQueryContext::DESCRIBE() {
  return getToken(fugue_sqlParser::DESCRIBE, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeQueryContext::QUERY() {
  return getToken(fugue_sqlParser::QUERY, 0);
}

fugue_sqlParser::DescribeQueryContext::DescribeQueryContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DescribeQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDescribeQuery(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TruncateTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::TruncateTableContext::TRUNCATE() {
  return getToken(fugue_sqlParser::TRUNCATE, 0);
}

tree::TerminalNode* fugue_sqlParser::TruncateTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::TruncateTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::TruncateTableContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::TruncateTableContext::TruncateTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TruncateTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTruncateTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetTableSerDeContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::SetTableSerDeContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::SERDE() {
  return getToken(fugue_sqlParser::SERDE, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::SetTableSerDeContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::WITH() {
  return getToken(fugue_sqlParser::WITH, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTableSerDeContext::SERDEPROPERTIES() {
  return getToken(fugue_sqlParser::SERDEPROPERTIES, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::SetTableSerDeContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

fugue_sqlParser::SetTableSerDeContext::SetTableSerDeContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetTableSerDeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetTableSerDe(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateViewContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CreateViewContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CreateViewContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::CreateViewContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::IdentifierCommentListContext* fugue_sqlParser::CreateViewContext::identifierCommentList() {
  return getRuleContext<fugue_sqlParser::IdentifierCommentListContext>(0);
}

std::vector<fugue_sqlParser::CommentSpecContext *> fugue_sqlParser::CreateViewContext::commentSpec() {
  return getRuleContexts<fugue_sqlParser::CommentSpecContext>();
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::CreateViewContext::commentSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateViewContext::PARTITIONED() {
  return getTokens(fugue_sqlParser::PARTITIONED);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::PARTITIONED(size_t i) {
  return getToken(fugue_sqlParser::PARTITIONED, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateViewContext::ON() {
  return getTokens(fugue_sqlParser::ON);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::ON(size_t i) {
  return getToken(fugue_sqlParser::ON, i);
}

std::vector<fugue_sqlParser::IdentifierListContext *> fugue_sqlParser::CreateViewContext::identifierList() {
  return getRuleContexts<fugue_sqlParser::IdentifierListContext>();
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::CreateViewContext::identifierList(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateViewContext::TBLPROPERTIES() {
  return getTokens(fugue_sqlParser::TBLPROPERTIES);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::TBLPROPERTIES(size_t i) {
  return getToken(fugue_sqlParser::TBLPROPERTIES, i);
}

std::vector<fugue_sqlParser::TablePropertyListContext *> fugue_sqlParser::CreateViewContext::tablePropertyList() {
  return getRuleContexts<fugue_sqlParser::TablePropertyListContext>();
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CreateViewContext::tablePropertyList(size_t i) {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(i);
}

tree::TerminalNode* fugue_sqlParser::CreateViewContext::GLOBAL() {
  return getToken(fugue_sqlParser::GLOBAL, 0);
}

fugue_sqlParser::CreateViewContext::CreateViewContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateViewContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateView(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DropTablePartitionsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DropTablePartitionsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

std::vector<fugue_sqlParser::PartitionSpecContext *> fugue_sqlParser::DropTablePartitionsContext::partitionSpec() {
  return getRuleContexts<fugue_sqlParser::PartitionSpecContext>();
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::DropTablePartitionsContext::partitionSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(i);
}

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTablePartitionsContext::PURGE() {
  return getToken(fugue_sqlParser::PURGE, 0);
}

fugue_sqlParser::DropTablePartitionsContext::DropTablePartitionsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DropTablePartitionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDropTablePartitions(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetConfigurationContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SetConfigurationContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

fugue_sqlParser::SetConfigurationContext::SetConfigurationContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetConfigurationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetConfiguration(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DropTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DropTableContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DropTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DropTableContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTableContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTableContext::PURGE() {
  return getToken(fugue_sqlParser::PURGE, 0);
}

fugue_sqlParser::DropTableContext::DropTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DropTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDropTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DescribeNamespaceContext ------------------------------------------------------------------

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::DescribeNamespaceContext::theNamespace() {
  return getRuleContext<fugue_sqlParser::TheNamespaceContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DescribeNamespaceContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DescribeNamespaceContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeNamespaceContext::DESCRIBE() {
  return getToken(fugue_sqlParser::DESCRIBE, 0);
}

tree::TerminalNode* fugue_sqlParser::DescribeNamespaceContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

fugue_sqlParser::DescribeNamespaceContext::DescribeNamespaceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DescribeNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDescribeNamespace(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AlterTableAlterColumnContext ------------------------------------------------------------------

std::vector<tree::TerminalNode *> fugue_sqlParser::AlterTableAlterColumnContext::ALTER() {
  return getTokens(fugue_sqlParser::ALTER);
}

tree::TerminalNode* fugue_sqlParser::AlterTableAlterColumnContext::ALTER(size_t i) {
  return getToken(fugue_sqlParser::ALTER, i);
}

tree::TerminalNode* fugue_sqlParser::AlterTableAlterColumnContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::AlterTableAlterColumnContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::AlterTableAlterColumnContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}

tree::TerminalNode* fugue_sqlParser::AlterTableAlterColumnContext::CHANGE() {
  return getToken(fugue_sqlParser::CHANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::AlterTableAlterColumnContext::COLUMN() {
  return getToken(fugue_sqlParser::COLUMN, 0);
}

fugue_sqlParser::AlterColumnActionContext* fugue_sqlParser::AlterTableAlterColumnContext::alterColumnAction() {
  return getRuleContext<fugue_sqlParser::AlterColumnActionContext>(0);
}

fugue_sqlParser::AlterTableAlterColumnContext::AlterTableAlterColumnContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AlterTableAlterColumnContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAlterTableAlterColumn(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CommentTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CommentTableContext::COMMENT() {
  return getToken(fugue_sqlParser::COMMENT, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentTableContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CommentTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CommentTableContext::IS() {
  return getToken(fugue_sqlParser::IS, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentTableContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentTableContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

fugue_sqlParser::CommentTableContext::CommentTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CommentTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCommentTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CreateNamespaceContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::CreateNamespaceContext::theNamespace() {
  return getRuleContext<fugue_sqlParser::TheNamespaceContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CreateNamespaceContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

std::vector<fugue_sqlParser::CommentSpecContext *> fugue_sqlParser::CreateNamespaceContext::commentSpec() {
  return getRuleContexts<fugue_sqlParser::CommentSpecContext>();
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::CreateNamespaceContext::commentSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(i);
}

std::vector<fugue_sqlParser::LocationSpecContext *> fugue_sqlParser::CreateNamespaceContext::locationSpec() {
  return getRuleContexts<fugue_sqlParser::LocationSpecContext>();
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::CreateNamespaceContext::locationSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateNamespaceContext::WITH() {
  return getTokens(fugue_sqlParser::WITH);
}

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::WITH(size_t i) {
  return getToken(fugue_sqlParser::WITH, i);
}

std::vector<fugue_sqlParser::TablePropertyListContext *> fugue_sqlParser::CreateNamespaceContext::tablePropertyList() {
  return getRuleContexts<fugue_sqlParser::TablePropertyListContext>();
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CreateNamespaceContext::tablePropertyList(size_t i) {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateNamespaceContext::DBPROPERTIES() {
  return getTokens(fugue_sqlParser::DBPROPERTIES);
}

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::DBPROPERTIES(size_t i) {
  return getToken(fugue_sqlParser::DBPROPERTIES, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateNamespaceContext::PROPERTIES() {
  return getTokens(fugue_sqlParser::PROPERTIES);
}

tree::TerminalNode* fugue_sqlParser::CreateNamespaceContext::PROPERTIES(size_t i) {
  return getToken(fugue_sqlParser::PROPERTIES, i);
}

fugue_sqlParser::CreateNamespaceContext::CreateNamespaceContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CreateNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateNamespace(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowTblPropertiesContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowTblPropertiesContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowTblPropertiesContext::TBLPROPERTIES() {
  return getToken(fugue_sqlParser::TBLPROPERTIES, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowTblPropertiesContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::TablePropertyKeyContext* fugue_sqlParser::ShowTblPropertiesContext::tablePropertyKey() {
  return getRuleContext<fugue_sqlParser::TablePropertyKeyContext>(0);
}

fugue_sqlParser::ShowTblPropertiesContext::ShowTblPropertiesContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowTblPropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowTblProperties(this);
  else
    return visitor->visitChildren(this);
}
//----------------- UnsetTablePropertiesContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::UnsetTablePropertiesContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::UNSET() {
  return getToken(fugue_sqlParser::UNSET, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::TBLPROPERTIES() {
  return getToken(fugue_sqlParser::TBLPROPERTIES, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::UnsetTablePropertiesContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsetTablePropertiesContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::UnsetTablePropertiesContext::UnsetTablePropertiesContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::UnsetTablePropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUnsetTableProperties(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetTableLocationContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SetTableLocationContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTableLocationContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::SetTableLocationContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetTableLocationContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::SetTableLocationContext::locationSpec() {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::SetTableLocationContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::SetTableLocationContext::SetTableLocationContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetTableLocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetTableLocation(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DropTableColumnsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DropTableColumnsContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTableColumnsContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DropTableColumnsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DropTableColumnsContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTableColumnsContext::COLUMN() {
  return getToken(fugue_sqlParser::COLUMN, 0);
}

tree::TerminalNode* fugue_sqlParser::DropTableColumnsContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::MultipartIdentifierListContext* fugue_sqlParser::DropTableColumnsContext::multipartIdentifierList() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierListContext>(0);
}

fugue_sqlParser::DropTableColumnsContext::DropTableColumnsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DropTableColumnsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDropTableColumns(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowViewsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowViewsContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowViewsContext::VIEWS() {
  return getToken(fugue_sqlParser::VIEWS, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowViewsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ShowViewsContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowViewsContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowViewsContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowViewsContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

fugue_sqlParser::ShowViewsContext::ShowViewsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowViewsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowViews(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ShowFunctionsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ShowFunctionsContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowFunctionsContext::FUNCTIONS() {
  return getToken(fugue_sqlParser::FUNCTIONS, 0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ShowFunctionsContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ShowFunctionsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ShowFunctionsContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::ShowFunctionsContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::ShowFunctionsContext::ShowFunctionsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ShowFunctionsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitShowFunctions(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CacheTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CacheTableContext::CACHE() {
  return getToken(fugue_sqlParser::CACHE, 0);
}

tree::TerminalNode* fugue_sqlParser::CacheTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CacheTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CacheTableContext::LAZY() {
  return getToken(fugue_sqlParser::LAZY, 0);
}

tree::TerminalNode* fugue_sqlParser::CacheTableContext::OPTIONS() {
  return getToken(fugue_sqlParser::OPTIONS, 0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::CacheTableContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CacheTableContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CacheTableContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::CacheTableContext::CacheTableContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CacheTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCacheTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AddTableColumnsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::AddTableColumnsContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTableColumnsContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::AddTableColumnsContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AddTableColumnsContext::ADD() {
  return getToken(fugue_sqlParser::ADD, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTableColumnsContext::COLUMN() {
  return getToken(fugue_sqlParser::COLUMN, 0);
}

tree::TerminalNode* fugue_sqlParser::AddTableColumnsContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

fugue_sqlParser::QualifiedColTypeWithPositionListContext* fugue_sqlParser::AddTableColumnsContext::qualifiedColTypeWithPositionList() {
  return getRuleContext<fugue_sqlParser::QualifiedColTypeWithPositionListContext>(0);
}

fugue_sqlParser::AddTableColumnsContext::AddTableColumnsContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AddTableColumnsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAddTableColumns(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetTablePropertiesContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SetTablePropertiesContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::SetTablePropertiesContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetTablePropertiesContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTablePropertiesContext::TBLPROPERTIES() {
  return getToken(fugue_sqlParser::TBLPROPERTIES, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::SetTablePropertiesContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SetTablePropertiesContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::SetTablePropertiesContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

fugue_sqlParser::SetTablePropertiesContext::SetTablePropertiesContext(StatementContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetTablePropertiesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetTableProperties(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::StatementContext* fugue_sqlParser::statement() {
  StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
  enterRule(_localctx, 164, fugue_sqlParser::RuleStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(1842);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 232, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::StatementDefaultContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(1137);
      query();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DmlStatementContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(1139);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::WITH) {
        setState(1138);
        ctes();
      }
      setState(1141);
      dmlStatementNoWith();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::UseContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(1142);
      match(fugue_sqlParser::USE);
      setState(1144);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 128, _ctx)) {
      case 1: {
        setState(1143);
        match(fugue_sqlParser::NAMESPACE);
        break;
      }

      default:
        break;
      }
      setState(1146);
      multipartIdentifier();
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(1147);
      match(fugue_sqlParser::CREATE);
      setState(1148);
      theNamespace();
      setState(1152);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
      case 1: {
        setState(1149);
        match(fugue_sqlParser::IF);
        setState(1150);
        match(fugue_sqlParser::NOT);
        setState(1151);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1154);
      multipartIdentifier();
      setState(1162);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::COMMENT || _la == fugue_sqlParser::LOCATION || _la == fugue_sqlParser::WITH) {
        setState(1160);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::COMMENT: {
            setState(1155);
            commentSpec();
            break;
          }

          case fugue_sqlParser::LOCATION: {
            setState(1156);
            locationSpec();
            break;
          }

          case fugue_sqlParser::WITH: {
            setState(1157);
            match(fugue_sqlParser::WITH);
            setState(1158);
            _la = _input->LA(1);
            if (!(_la == fugue_sqlParser::DBPROPERTIES || _la == fugue_sqlParser::PROPERTIES)) {
            _errHandler->recoverInline(this);
            }
            else {
              _errHandler->reportMatch(this);
              consume();
            }
            setState(1159);
            tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1164);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetNamespacePropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(1165);
      match(fugue_sqlParser::ALTER);
      setState(1166);
      theNamespace();
      setState(1167);
      multipartIdentifier();
      setState(1168);
      match(fugue_sqlParser::SET);
      setState(1169);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DBPROPERTIES || _la == fugue_sqlParser::PROPERTIES)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1170);
      tablePropertyList();
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetNamespaceLocationContext>(_localctx);
      enterOuterAlt(_localctx, 6);
      setState(1172);
      match(fugue_sqlParser::ALTER);
      setState(1173);
      theNamespace();
      setState(1174);
      multipartIdentifier();
      setState(1175);
      match(fugue_sqlParser::SET);
      setState(1176);
      locationSpec();
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 7);
      setState(1178);
      match(fugue_sqlParser::DROP);
      setState(1179);
      theNamespace();
      setState(1182);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 132, _ctx)) {
      case 1: {
        setState(1180);
        match(fugue_sqlParser::IF);
        setState(1181);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1184);
      multipartIdentifier();
      setState(1186);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::CASCADE || _la == fugue_sqlParser::RESTRICT) {
        setState(1185);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::CASCADE || _la == fugue_sqlParser::RESTRICT)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
      }
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowNamespacesContext>(_localctx);
      enterOuterAlt(_localctx, 8);
      setState(1188);
      match(fugue_sqlParser::SHOW);
      setState(1189);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DATABASES || _la == fugue_sqlParser::NAMESPACES)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1192);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1190);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1191);
        multipartIdentifier();
      }
      setState(1198);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LIKE || _la == fugue_sqlParser::STRING) {
        setState(1195);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::LIKE) {
          setState(1194);
          match(fugue_sqlParser::LIKE);
        }
        setState(1197);
        antlrcpp::downCast<ShowNamespacesContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateTableContext>(_localctx);
      enterOuterAlt(_localctx, 9);
      setState(1200);
      createTableHeader();
      setState(1205);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__2) {
        setState(1201);
        match(fugue_sqlParser::T__2);
        setState(1202);
        colTypeList();
        setState(1203);
        match(fugue_sqlParser::T__3);
      }
      setState(1207);
      tableProvider();
      setState(1208);
      createTableClauses();
      setState(1213);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::FILL)
        | (1ULL << fugue_sqlParser::TAKE)
        | (1ULL << fugue_sqlParser::PROCESS)
        | (1ULL << fugue_sqlParser::ZIP)
        | (1ULL << fugue_sqlParser::SAVE)
        | (1ULL << fugue_sqlParser::CONNECT)
        | (1ULL << fugue_sqlParser::SAMPLE)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 94) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 94)) & ((1ULL << (fugue_sqlParser::CREATE - 94))
        | (1ULL << (fugue_sqlParser::DROP - 94))
        | (1ULL << (fugue_sqlParser::FROM - 94)))) != 0) || ((((_la - 177) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 177)) & ((1ULL << (fugue_sqlParser::LOAD - 177))
        | (1ULL << (fugue_sqlParser::MAP - 177))
        | (1ULL << (fugue_sqlParser::REDUCE - 177))
        | (1ULL << (fugue_sqlParser::RENAME - 177)))) != 0) || ((((_la - 247) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 247)) & ((1ULL << (fugue_sqlParser::SELECT - 247))
        | (1ULL << (fugue_sqlParser::TABLE - 247))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 247))
        | (1ULL << (fugue_sqlParser::VALUES - 247))
        | (1ULL << (fugue_sqlParser::WITH - 247)))) != 0)) {
        setState(1210);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1209);
          match(fugue_sqlParser::AS);
        }
        setState(1212);
        query();
      }
      break;
    }

    case 10: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateHiveTableContext>(_localctx);
      enterOuterAlt(_localctx, 10);
      setState(1215);
      createTableHeader();
      setState(1220);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__2) {
        setState(1216);
        match(fugue_sqlParser::T__2);
        setState(1217);
        antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->columns = colTypeList();
        setState(1218);
        match(fugue_sqlParser::T__3);
      }
      setState(1243);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::CLUSTERED

      || _la == fugue_sqlParser::COMMENT || _la == fugue_sqlParser::LOCATION

      || _la == fugue_sqlParser::PARTITIONED || ((((_la - 243) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 243)) & ((1ULL << (fugue_sqlParser::ROW - 243))
        | (1ULL << (fugue_sqlParser::SKEWED - 243))
        | (1ULL << (fugue_sqlParser::STORED - 243))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 243)))) != 0)) {
        setState(1241);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::COMMENT: {
            setState(1222);
            commentSpec();
            break;
          }

          case fugue_sqlParser::PARTITIONED: {
            setState(1232);
            _errHandler->sync(this);
            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 141, _ctx)) {
            case 1: {
              setState(1223);
              match(fugue_sqlParser::PARTITIONED);
              setState(1224);
              match(fugue_sqlParser::BY);
              setState(1225);
              match(fugue_sqlParser::T__2);
              setState(1226);
              antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->partitionColumns = colTypeList();
              setState(1227);
              match(fugue_sqlParser::T__3);
              break;
            }

            case 2: {
              setState(1229);
              match(fugue_sqlParser::PARTITIONED);
              setState(1230);
              match(fugue_sqlParser::BY);
              setState(1231);
              antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->partitionColumnNames = identifierList();
              break;
            }

            default:
              break;
            }
            break;
          }

          case fugue_sqlParser::CLUSTERED: {
            setState(1234);
            bucketSpec();
            break;
          }

          case fugue_sqlParser::SKEWED: {
            setState(1235);
            skewSpec();
            break;
          }

          case fugue_sqlParser::ROW: {
            setState(1236);
            rowFormat();
            break;
          }

          case fugue_sqlParser::STORED: {
            setState(1237);
            createFileFormat();
            break;
          }

          case fugue_sqlParser::LOCATION: {
            setState(1238);
            locationSpec();
            break;
          }

          case fugue_sqlParser::TBLPROPERTIES: {
            setState(1239);
            match(fugue_sqlParser::TBLPROPERTIES);
            setState(1240);
            antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->tableProps = tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1245);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1250);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::FILL)
        | (1ULL << fugue_sqlParser::TAKE)
        | (1ULL << fugue_sqlParser::PROCESS)
        | (1ULL << fugue_sqlParser::ZIP)
        | (1ULL << fugue_sqlParser::SAVE)
        | (1ULL << fugue_sqlParser::CONNECT)
        | (1ULL << fugue_sqlParser::SAMPLE)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 94) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 94)) & ((1ULL << (fugue_sqlParser::CREATE - 94))
        | (1ULL << (fugue_sqlParser::DROP - 94))
        | (1ULL << (fugue_sqlParser::FROM - 94)))) != 0) || ((((_la - 177) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 177)) & ((1ULL << (fugue_sqlParser::LOAD - 177))
        | (1ULL << (fugue_sqlParser::MAP - 177))
        | (1ULL << (fugue_sqlParser::REDUCE - 177))
        | (1ULL << (fugue_sqlParser::RENAME - 177)))) != 0) || ((((_la - 247) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 247)) & ((1ULL << (fugue_sqlParser::SELECT - 247))
        | (1ULL << (fugue_sqlParser::TABLE - 247))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 247))
        | (1ULL << (fugue_sqlParser::VALUES - 247))
        | (1ULL << (fugue_sqlParser::WITH - 247)))) != 0)) {
        setState(1247);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1246);
          match(fugue_sqlParser::AS);
        }
        setState(1249);
        query();
      }
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateTableLikeContext>(_localctx);
      enterOuterAlt(_localctx, 11);
      setState(1252);
      match(fugue_sqlParser::CREATE);
      setState(1253);
      match(fugue_sqlParser::TABLE);
      setState(1257);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 146, _ctx)) {
      case 1: {
        setState(1254);
        match(fugue_sqlParser::IF);
        setState(1255);
        match(fugue_sqlParser::NOT);
        setState(1256);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1259);
      antlrcpp::downCast<CreateTableLikeContext *>(_localctx)->target = tableIdentifier();
      setState(1260);
      match(fugue_sqlParser::LIKE);
      setState(1261);
      antlrcpp::downCast<CreateTableLikeContext *>(_localctx)->source = tableIdentifier();
      setState(1270);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::LOCATION || ((((_la - 243) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 243)) & ((1ULL << (fugue_sqlParser::ROW - 243))
        | (1ULL << (fugue_sqlParser::STORED - 243))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 243))
        | (1ULL << (fugue_sqlParser::USING - 243)))) != 0)) {
        setState(1268);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::USING: {
            setState(1262);
            tableProvider();
            break;
          }

          case fugue_sqlParser::ROW: {
            setState(1263);
            rowFormat();
            break;
          }

          case fugue_sqlParser::STORED: {
            setState(1264);
            createFileFormat();
            break;
          }

          case fugue_sqlParser::LOCATION: {
            setState(1265);
            locationSpec();
            break;
          }

          case fugue_sqlParser::TBLPROPERTIES: {
            setState(1266);
            match(fugue_sqlParser::TBLPROPERTIES);
            setState(1267);
            antlrcpp::downCast<CreateTableLikeContext *>(_localctx)->tableProps = tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1272);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ReplaceTableContext>(_localctx);
      enterOuterAlt(_localctx, 12);
      setState(1273);
      replaceTableHeader();
      setState(1278);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__2) {
        setState(1274);
        match(fugue_sqlParser::T__2);
        setState(1275);
        colTypeList();
        setState(1276);
        match(fugue_sqlParser::T__3);
      }
      setState(1280);
      tableProvider();
      setState(1281);
      createTableClauses();
      setState(1286);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::FILL)
        | (1ULL << fugue_sqlParser::TAKE)
        | (1ULL << fugue_sqlParser::PROCESS)
        | (1ULL << fugue_sqlParser::ZIP)
        | (1ULL << fugue_sqlParser::SAVE)
        | (1ULL << fugue_sqlParser::CONNECT)
        | (1ULL << fugue_sqlParser::SAMPLE)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 94) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 94)) & ((1ULL << (fugue_sqlParser::CREATE - 94))
        | (1ULL << (fugue_sqlParser::DROP - 94))
        | (1ULL << (fugue_sqlParser::FROM - 94)))) != 0) || ((((_la - 177) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 177)) & ((1ULL << (fugue_sqlParser::LOAD - 177))
        | (1ULL << (fugue_sqlParser::MAP - 177))
        | (1ULL << (fugue_sqlParser::REDUCE - 177))
        | (1ULL << (fugue_sqlParser::RENAME - 177)))) != 0) || ((((_la - 247) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 247)) & ((1ULL << (fugue_sqlParser::SELECT - 247))
        | (1ULL << (fugue_sqlParser::TABLE - 247))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 247))
        | (1ULL << (fugue_sqlParser::VALUES - 247))
        | (1ULL << (fugue_sqlParser::WITH - 247)))) != 0)) {
        setState(1283);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1282);
          match(fugue_sqlParser::AS);
        }
        setState(1285);
        query();
      }
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AnalyzeContext>(_localctx);
      enterOuterAlt(_localctx, 13);
      setState(1288);
      match(fugue_sqlParser::ANALYZE);
      setState(1289);
      match(fugue_sqlParser::TABLE);
      setState(1290);
      multipartIdentifier();
      setState(1292);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1291);
        partitionSpec();
      }
      setState(1294);
      match(fugue_sqlParser::COMPUTE);
      setState(1295);
      match(fugue_sqlParser::STATISTICS);
      setState(1303);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 153, _ctx)) {
      case 1: {
        setState(1296);
        identifier();
        break;
      }

      case 2: {
        setState(1297);
        match(fugue_sqlParser::FOR);
        setState(1298);
        match(fugue_sqlParser::COLUMNS);
        setState(1299);
        identifierSeq();
        break;
      }

      case 3: {
        setState(1300);
        match(fugue_sqlParser::FOR);
        setState(1301);
        match(fugue_sqlParser::ALL);
        setState(1302);
        match(fugue_sqlParser::COLUMNS);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AddTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 14);
      setState(1305);
      match(fugue_sqlParser::ALTER);
      setState(1306);
      match(fugue_sqlParser::TABLE);
      setState(1307);
      multipartIdentifier();
      setState(1308);
      match(fugue_sqlParser::ADD);
      setState(1309);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1310);
      antlrcpp::downCast<AddTableColumnsContext *>(_localctx)->columns = qualifiedColTypeWithPositionList();
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AddTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 15);
      setState(1312);
      match(fugue_sqlParser::ALTER);
      setState(1313);
      match(fugue_sqlParser::TABLE);
      setState(1314);
      multipartIdentifier();
      setState(1315);
      match(fugue_sqlParser::ADD);
      setState(1316);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1317);
      match(fugue_sqlParser::T__2);
      setState(1318);
      antlrcpp::downCast<AddTableColumnsContext *>(_localctx)->columns = qualifiedColTypeWithPositionList();
      setState(1319);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RenameTableColumnContext>(_localctx);
      enterOuterAlt(_localctx, 16);
      setState(1321);
      match(fugue_sqlParser::ALTER);
      setState(1322);
      match(fugue_sqlParser::TABLE);
      setState(1323);
      antlrcpp::downCast<RenameTableColumnContext *>(_localctx)->table = multipartIdentifier();
      setState(1324);
      match(fugue_sqlParser::RENAME);
      setState(1325);
      match(fugue_sqlParser::COLUMN);
      setState(1326);
      antlrcpp::downCast<RenameTableColumnContext *>(_localctx)->ifrom = multipartIdentifier();
      setState(1327);
      match(fugue_sqlParser::TO);
      setState(1328);
      antlrcpp::downCast<RenameTableColumnContext *>(_localctx)->to = errorCapturingIdentifier();
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 17);
      setState(1330);
      match(fugue_sqlParser::ALTER);
      setState(1331);
      match(fugue_sqlParser::TABLE);
      setState(1332);
      multipartIdentifier();
      setState(1333);
      match(fugue_sqlParser::DROP);
      setState(1334);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1335);
      match(fugue_sqlParser::T__2);
      setState(1336);
      antlrcpp::downCast<DropTableColumnsContext *>(_localctx)->columns = multipartIdentifierList();
      setState(1337);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 18);
      setState(1339);
      match(fugue_sqlParser::ALTER);
      setState(1340);
      match(fugue_sqlParser::TABLE);
      setState(1341);
      multipartIdentifier();
      setState(1342);
      match(fugue_sqlParser::DROP);
      setState(1343);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1344);
      antlrcpp::downCast<DropTableColumnsContext *>(_localctx)->columns = multipartIdentifierList();
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RenameTableContext>(_localctx);
      enterOuterAlt(_localctx, 19);
      setState(1346);
      match(fugue_sqlParser::ALTER);
      setState(1347);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1348);
      antlrcpp::downCast<RenameTableContext *>(_localctx)->ifrom = multipartIdentifier();
      setState(1349);
      match(fugue_sqlParser::RENAME);
      setState(1350);
      match(fugue_sqlParser::TO);
      setState(1351);
      antlrcpp::downCast<RenameTableContext *>(_localctx)->to = multipartIdentifier();
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTablePropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 20);
      setState(1353);
      match(fugue_sqlParser::ALTER);
      setState(1354);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1355);
      multipartIdentifier();
      setState(1356);
      match(fugue_sqlParser::SET);
      setState(1357);
      match(fugue_sqlParser::TBLPROPERTIES);
      setState(1358);
      tablePropertyList();
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<fugue_sqlParser::UnsetTablePropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 21);
      setState(1360);
      match(fugue_sqlParser::ALTER);
      setState(1361);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1362);
      multipartIdentifier();
      setState(1363);
      match(fugue_sqlParser::UNSET);
      setState(1364);
      match(fugue_sqlParser::TBLPROPERTIES);
      setState(1367);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(1365);
        match(fugue_sqlParser::IF);
        setState(1366);
        match(fugue_sqlParser::EXISTS);
      }
      setState(1369);
      tablePropertyList();
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AlterTableAlterColumnContext>(_localctx);
      enterOuterAlt(_localctx, 22);
      setState(1371);
      match(fugue_sqlParser::ALTER);
      setState(1372);
      match(fugue_sqlParser::TABLE);
      setState(1373);
      antlrcpp::downCast<AlterTableAlterColumnContext *>(_localctx)->table = multipartIdentifier();
      setState(1374);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ALTER

      || _la == fugue_sqlParser::CHANGE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1376);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 155, _ctx)) {
      case 1: {
        setState(1375);
        match(fugue_sqlParser::COLUMN);
        break;
      }

      default:
        break;
      }
      setState(1378);
      antlrcpp::downCast<AlterTableAlterColumnContext *>(_localctx)->column = multipartIdentifier();
      setState(1380);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AFTER || ((((_la - 86) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 86)) & ((1ULL << (fugue_sqlParser::COMMENT - 86))
        | (1ULL << (fugue_sqlParser::DROP - 86))
        | (1ULL << (fugue_sqlParser::FIRST - 86)))) != 0) || _la == fugue_sqlParser::SET

      || _la == fugue_sqlParser::TYPE) {
        setState(1379);
        alterColumnAction();
      }
      break;
    }

    case 23: {
      _localctx = _tracker.createInstance<fugue_sqlParser::HiveChangeColumnContext>(_localctx);
      enterOuterAlt(_localctx, 23);
      setState(1382);
      match(fugue_sqlParser::ALTER);
      setState(1383);
      match(fugue_sqlParser::TABLE);
      setState(1384);
      antlrcpp::downCast<HiveChangeColumnContext *>(_localctx)->table = multipartIdentifier();
      setState(1386);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1385);
        partitionSpec();
      }
      setState(1388);
      match(fugue_sqlParser::CHANGE);
      setState(1390);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx)) {
      case 1: {
        setState(1389);
        match(fugue_sqlParser::COLUMN);
        break;
      }

      default:
        break;
      }
      setState(1392);
      antlrcpp::downCast<HiveChangeColumnContext *>(_localctx)->colName = multipartIdentifier();
      setState(1393);
      colType();
      setState(1395);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AFTER || _la == fugue_sqlParser::FIRST) {
        setState(1394);
        colPosition();
      }
      break;
    }

    case 24: {
      _localctx = _tracker.createInstance<fugue_sqlParser::HiveReplaceColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 24);
      setState(1397);
      match(fugue_sqlParser::ALTER);
      setState(1398);
      match(fugue_sqlParser::TABLE);
      setState(1399);
      antlrcpp::downCast<HiveReplaceColumnsContext *>(_localctx)->table = multipartIdentifier();
      setState(1401);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1400);
        partitionSpec();
      }
      setState(1403);
      match(fugue_sqlParser::REPLACE);
      setState(1404);
      match(fugue_sqlParser::COLUMNS);
      setState(1405);
      match(fugue_sqlParser::T__2);
      setState(1406);
      antlrcpp::downCast<HiveReplaceColumnsContext *>(_localctx)->columns = qualifiedColTypeWithPositionList();
      setState(1407);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 25: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTableSerDeContext>(_localctx);
      enterOuterAlt(_localctx, 25);
      setState(1409);
      match(fugue_sqlParser::ALTER);
      setState(1410);
      match(fugue_sqlParser::TABLE);
      setState(1411);
      multipartIdentifier();
      setState(1413);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1412);
        partitionSpec();
      }
      setState(1415);
      match(fugue_sqlParser::SET);
      setState(1416);
      match(fugue_sqlParser::SERDE);
      setState(1417);
      match(fugue_sqlParser::STRING);
      setState(1421);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::WITH) {
        setState(1418);
        match(fugue_sqlParser::WITH);
        setState(1419);
        match(fugue_sqlParser::SERDEPROPERTIES);
        setState(1420);
        tablePropertyList();
      }
      break;
    }

    case 26: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTableSerDeContext>(_localctx);
      enterOuterAlt(_localctx, 26);
      setState(1423);
      match(fugue_sqlParser::ALTER);
      setState(1424);
      match(fugue_sqlParser::TABLE);
      setState(1425);
      multipartIdentifier();
      setState(1427);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1426);
        partitionSpec();
      }
      setState(1429);
      match(fugue_sqlParser::SET);
      setState(1430);
      match(fugue_sqlParser::SERDEPROPERTIES);
      setState(1431);
      tablePropertyList();
      break;
    }

    case 27: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AddTablePartitionContext>(_localctx);
      enterOuterAlt(_localctx, 27);
      setState(1433);
      match(fugue_sqlParser::ALTER);
      setState(1434);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1435);
      multipartIdentifier();
      setState(1436);
      match(fugue_sqlParser::ADD);
      setState(1440);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(1437);
        match(fugue_sqlParser::IF);
        setState(1438);
        match(fugue_sqlParser::NOT);
        setState(1439);
        match(fugue_sqlParser::EXISTS);
      }
      setState(1443); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1442);
        partitionSpecLocation();
        setState(1445); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::PARTITION);
      break;
    }

    case 28: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RenameTablePartitionContext>(_localctx);
      enterOuterAlt(_localctx, 28);
      setState(1447);
      match(fugue_sqlParser::ALTER);
      setState(1448);
      match(fugue_sqlParser::TABLE);
      setState(1449);
      multipartIdentifier();
      setState(1450);
      antlrcpp::downCast<RenameTablePartitionContext *>(_localctx)->ifrom = partitionSpec();
      setState(1451);
      match(fugue_sqlParser::RENAME);
      setState(1452);
      match(fugue_sqlParser::TO);
      setState(1453);
      antlrcpp::downCast<RenameTablePartitionContext *>(_localctx)->to = partitionSpec();
      break;
    }

    case 29: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTablePartitionsContext>(_localctx);
      enterOuterAlt(_localctx, 29);
      setState(1455);
      match(fugue_sqlParser::ALTER);
      setState(1456);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1457);
      multipartIdentifier();
      setState(1458);
      match(fugue_sqlParser::DROP);
      setState(1461);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(1459);
        match(fugue_sqlParser::IF);
        setState(1460);
        match(fugue_sqlParser::EXISTS);
      }
      setState(1463);
      partitionSpec();
      setState(1468);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(1464);
        match(fugue_sqlParser::T__0);
        setState(1465);
        partitionSpec();
        setState(1470);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1472);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PURGE) {
        setState(1471);
        match(fugue_sqlParser::PURGE);
      }
      break;
    }

    case 30: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTableLocationContext>(_localctx);
      enterOuterAlt(_localctx, 30);
      setState(1474);
      match(fugue_sqlParser::ALTER);
      setState(1475);
      match(fugue_sqlParser::TABLE);
      setState(1476);
      multipartIdentifier();
      setState(1478);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1477);
        partitionSpec();
      }
      setState(1480);
      match(fugue_sqlParser::SET);
      setState(1481);
      locationSpec();
      break;
    }

    case 31: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RecoverPartitionsContext>(_localctx);
      enterOuterAlt(_localctx, 31);
      setState(1483);
      match(fugue_sqlParser::ALTER);
      setState(1484);
      match(fugue_sqlParser::TABLE);
      setState(1485);
      multipartIdentifier();
      setState(1486);
      match(fugue_sqlParser::RECOVER);
      setState(1487);
      match(fugue_sqlParser::PARTITIONS);
      break;
    }

    case 32: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTableContext>(_localctx);
      enterOuterAlt(_localctx, 32);
      setState(1489);
      match(fugue_sqlParser::DROP);
      setState(1490);
      match(fugue_sqlParser::TABLE);
      setState(1493);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 170, _ctx)) {
      case 1: {
        setState(1491);
        match(fugue_sqlParser::IF);
        setState(1492);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1495);
      multipartIdentifier();
      setState(1497);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PURGE) {
        setState(1496);
        match(fugue_sqlParser::PURGE);
      }
      break;
    }

    case 33: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropViewContext>(_localctx);
      enterOuterAlt(_localctx, 33);
      setState(1499);
      match(fugue_sqlParser::DROP);
      setState(1500);
      match(fugue_sqlParser::VIEW);
      setState(1503);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 172, _ctx)) {
      case 1: {
        setState(1501);
        match(fugue_sqlParser::IF);
        setState(1502);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1505);
      multipartIdentifier();
      break;
    }

    case 34: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateViewContext>(_localctx);
      enterOuterAlt(_localctx, 34);
      setState(1506);
      match(fugue_sqlParser::CREATE);
      setState(1509);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OR) {
        setState(1507);
        match(fugue_sqlParser::OR);
        setState(1508);
        match(fugue_sqlParser::REPLACE);
      }
      setState(1515);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::GLOBAL || _la == fugue_sqlParser::TEMPORARY) {
        setState(1512);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::GLOBAL) {
          setState(1511);
          match(fugue_sqlParser::GLOBAL);
        }
        setState(1514);
        match(fugue_sqlParser::TEMPORARY);
      }
      setState(1517);
      match(fugue_sqlParser::VIEW);
      setState(1521);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 176, _ctx)) {
      case 1: {
        setState(1518);
        match(fugue_sqlParser::IF);
        setState(1519);
        match(fugue_sqlParser::NOT);
        setState(1520);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1523);
      multipartIdentifier();
      setState(1525);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__2) {
        setState(1524);
        identifierCommentList();
      }
      setState(1535);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::COMMENT || _la == fugue_sqlParser::PARTITIONED

      || _la == fugue_sqlParser::TBLPROPERTIES) {
        setState(1533);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::COMMENT: {
            setState(1527);
            commentSpec();
            break;
          }

          case fugue_sqlParser::PARTITIONED: {
            setState(1528);
            match(fugue_sqlParser::PARTITIONED);
            setState(1529);
            match(fugue_sqlParser::ON);
            setState(1530);
            identifierList();
            break;
          }

          case fugue_sqlParser::TBLPROPERTIES: {
            setState(1531);
            match(fugue_sqlParser::TBLPROPERTIES);
            setState(1532);
            tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1537);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1538);
      match(fugue_sqlParser::AS);
      setState(1539);
      query();
      break;
    }

    case 35: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateTempViewUsingContext>(_localctx);
      enterOuterAlt(_localctx, 35);
      setState(1541);
      match(fugue_sqlParser::CREATE);
      setState(1544);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OR) {
        setState(1542);
        match(fugue_sqlParser::OR);
        setState(1543);
        match(fugue_sqlParser::REPLACE);
      }
      setState(1547);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::GLOBAL) {
        setState(1546);
        match(fugue_sqlParser::GLOBAL);
      }
      setState(1549);
      match(fugue_sqlParser::TEMPORARY);
      setState(1550);
      match(fugue_sqlParser::VIEW);
      setState(1551);
      tableIdentifier();
      setState(1556);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__2) {
        setState(1552);
        match(fugue_sqlParser::T__2);
        setState(1553);
        colTypeList();
        setState(1554);
        match(fugue_sqlParser::T__3);
      }
      setState(1558);
      tableProvider();
      setState(1561);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OPTIONS) {
        setState(1559);
        match(fugue_sqlParser::OPTIONS);
        setState(1560);
        tablePropertyList();
      }
      break;
    }

    case 36: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AlterViewQueryContext>(_localctx);
      enterOuterAlt(_localctx, 36);
      setState(1563);
      match(fugue_sqlParser::ALTER);
      setState(1564);
      match(fugue_sqlParser::VIEW);
      setState(1565);
      multipartIdentifier();
      setState(1567);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AS) {
        setState(1566);
        match(fugue_sqlParser::AS);
      }
      setState(1569);
      query();
      break;
    }

    case 37: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 37);
      setState(1571);
      match(fugue_sqlParser::CREATE);
      setState(1574);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OR) {
        setState(1572);
        match(fugue_sqlParser::OR);
        setState(1573);
        match(fugue_sqlParser::REPLACE);
      }
      setState(1577);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TEMPORARY) {
        setState(1576);
        match(fugue_sqlParser::TEMPORARY);
      }
      setState(1579);
      match(fugue_sqlParser::FUNCTION);
      setState(1583);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 187, _ctx)) {
      case 1: {
        setState(1580);
        match(fugue_sqlParser::IF);
        setState(1581);
        match(fugue_sqlParser::NOT);
        setState(1582);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1585);
      multipartIdentifier();
      setState(1586);
      match(fugue_sqlParser::AS);
      setState(1587);
      antlrcpp::downCast<CreateFunctionContext *>(_localctx)->className = match(fugue_sqlParser::STRING);
      setState(1597);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::USING) {
        setState(1588);
        match(fugue_sqlParser::USING);
        setState(1589);
        resource();
        setState(1594);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(1590);
          match(fugue_sqlParser::T__0);
          setState(1591);
          resource();
          setState(1596);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      break;
    }

    case 38: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 38);
      setState(1599);
      match(fugue_sqlParser::DROP);
      setState(1601);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TEMPORARY) {
        setState(1600);
        match(fugue_sqlParser::TEMPORARY);
      }
      setState(1603);
      match(fugue_sqlParser::FUNCTION);
      setState(1606);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 191, _ctx)) {
      case 1: {
        setState(1604);
        match(fugue_sqlParser::IF);
        setState(1605);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1608);
      multipartIdentifier();
      break;
    }

    case 39: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ExplainContext>(_localctx);
      enterOuterAlt(_localctx, 39);
      setState(1609);
      match(fugue_sqlParser::EXPLAIN);
      setState(1611);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 81) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 81)) & ((1ULL << (fugue_sqlParser::CODEGEN - 81))
        | (1ULL << (fugue_sqlParser::COST - 81))
        | (1ULL << (fugue_sqlParser::EXTENDED - 81))
        | (1ULL << (fugue_sqlParser::FORMATTED - 81)))) != 0) || _la == fugue_sqlParser::LOGICAL) {
        setState(1610);
        _la = _input->LA(1);
        if (!(((((_la - 81) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 81)) & ((1ULL << (fugue_sqlParser::CODEGEN - 81))
          | (1ULL << (fugue_sqlParser::COST - 81))
          | (1ULL << (fugue_sqlParser::EXTENDED - 81))
          | (1ULL << (fugue_sqlParser::FORMATTED - 81)))) != 0) || _la == fugue_sqlParser::LOGICAL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
      }
      setState(1613);
      statement();
      break;
    }

    case 40: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowTablesContext>(_localctx);
      enterOuterAlt(_localctx, 40);
      setState(1614);
      match(fugue_sqlParser::SHOW);
      setState(1615);
      match(fugue_sqlParser::TABLES);
      setState(1618);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1616);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1617);
        multipartIdentifier();
      }
      setState(1624);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LIKE || _la == fugue_sqlParser::STRING) {
        setState(1621);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::LIKE) {
          setState(1620);
          match(fugue_sqlParser::LIKE);
        }
        setState(1623);
        antlrcpp::downCast<ShowTablesContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 41: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowTableContext>(_localctx);
      enterOuterAlt(_localctx, 41);
      setState(1626);
      match(fugue_sqlParser::SHOW);
      setState(1627);
      match(fugue_sqlParser::TABLE);
      setState(1628);
      match(fugue_sqlParser::EXTENDED);
      setState(1631);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1629);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1630);
        antlrcpp::downCast<ShowTableContext *>(_localctx)->ns = multipartIdentifier();
      }
      setState(1633);
      match(fugue_sqlParser::LIKE);
      setState(1634);
      antlrcpp::downCast<ShowTableContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      setState(1636);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1635);
        partitionSpec();
      }
      break;
    }

    case 42: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowTblPropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 42);
      setState(1638);
      match(fugue_sqlParser::SHOW);
      setState(1639);
      match(fugue_sqlParser::TBLPROPERTIES);
      setState(1640);
      antlrcpp::downCast<ShowTblPropertiesContext *>(_localctx)->table = multipartIdentifier();
      setState(1645);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__2) {
        setState(1641);
        match(fugue_sqlParser::T__2);
        setState(1642);
        antlrcpp::downCast<ShowTblPropertiesContext *>(_localctx)->key = tablePropertyKey();
        setState(1643);
        match(fugue_sqlParser::T__3);
      }
      break;
    }

    case 43: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 43);
      setState(1647);
      match(fugue_sqlParser::SHOW);
      setState(1648);
      match(fugue_sqlParser::COLUMNS);
      setState(1649);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1650);
      antlrcpp::downCast<ShowColumnsContext *>(_localctx)->table = multipartIdentifier();
      setState(1653);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1651);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1652);
        antlrcpp::downCast<ShowColumnsContext *>(_localctx)->ns = multipartIdentifier();
      }
      break;
    }

    case 44: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowViewsContext>(_localctx);
      enterOuterAlt(_localctx, 44);
      setState(1655);
      match(fugue_sqlParser::SHOW);
      setState(1656);
      match(fugue_sqlParser::VIEWS);
      setState(1659);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1657);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1658);
        multipartIdentifier();
      }
      setState(1665);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LIKE || _la == fugue_sqlParser::STRING) {
        setState(1662);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::LIKE) {
          setState(1661);
          match(fugue_sqlParser::LIKE);
        }
        setState(1664);
        antlrcpp::downCast<ShowViewsContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 45: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowPartitionsContext>(_localctx);
      enterOuterAlt(_localctx, 45);
      setState(1667);
      match(fugue_sqlParser::SHOW);
      setState(1668);
      match(fugue_sqlParser::PARTITIONS);
      setState(1669);
      multipartIdentifier();
      setState(1671);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1670);
        partitionSpec();
      }
      break;
    }

    case 46: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowFunctionsContext>(_localctx);
      enterOuterAlt(_localctx, 46);
      setState(1673);
      match(fugue_sqlParser::SHOW);
      setState(1675);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 204, _ctx)) {
      case 1: {
        setState(1674);
        identifier();
        break;
      }

      default:
        break;
      }
      setState(1677);
      match(fugue_sqlParser::FUNCTIONS);
      setState(1685);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((((_la - 53) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 53)) & ((1ULL << (fugue_sqlParser::ADD - 53))
        | (1ULL << (fugue_sqlParser::AFTER - 53))
        | (1ULL << (fugue_sqlParser::ALL - 53))
        | (1ULL << (fugue_sqlParser::ALTER - 53))
        | (1ULL << (fugue_sqlParser::ANALYZE - 53))
        | (1ULL << (fugue_sqlParser::AND - 53))
        | (1ULL << (fugue_sqlParser::ANTI - 53))
        | (1ULL << (fugue_sqlParser::ANY - 53))
        | (1ULL << (fugue_sqlParser::ARCHIVE - 53))
        | (1ULL << (fugue_sqlParser::ARRAY - 53))
        | (1ULL << (fugue_sqlParser::AS - 53))
        | (1ULL << (fugue_sqlParser::ASC - 53))
        | (1ULL << (fugue_sqlParser::AT - 53))
        | (1ULL << (fugue_sqlParser::AUTHORIZATION - 53))
        | (1ULL << (fugue_sqlParser::BETWEEN - 53))
        | (1ULL << (fugue_sqlParser::BOTH - 53))
        | (1ULL << (fugue_sqlParser::BUCKET - 53))
        | (1ULL << (fugue_sqlParser::BUCKETS - 53))
        | (1ULL << (fugue_sqlParser::BY - 53))
        | (1ULL << (fugue_sqlParser::CACHE - 53))
        | (1ULL << (fugue_sqlParser::CASCADE - 53))
        | (1ULL << (fugue_sqlParser::CASE - 53))
        | (1ULL << (fugue_sqlParser::CAST - 53))
        | (1ULL << (fugue_sqlParser::CHANGE - 53))
        | (1ULL << (fugue_sqlParser::CHECK - 53))
        | (1ULL << (fugue_sqlParser::CLEAR - 53))
        | (1ULL << (fugue_sqlParser::CLUSTER - 53))
        | (1ULL << (fugue_sqlParser::CLUSTERED - 53))
        | (1ULL << (fugue_sqlParser::CODEGEN - 53))
        | (1ULL << (fugue_sqlParser::COLLATE - 53))
        | (1ULL << (fugue_sqlParser::COLLECTION - 53))
        | (1ULL << (fugue_sqlParser::COLUMN - 53))
        | (1ULL << (fugue_sqlParser::COLUMNS - 53))
        | (1ULL << (fugue_sqlParser::COMMENT - 53))
        | (1ULL << (fugue_sqlParser::COMMIT - 53))
        | (1ULL << (fugue_sqlParser::COMPACT - 53))
        | (1ULL << (fugue_sqlParser::COMPACTIONS - 53))
        | (1ULL << (fugue_sqlParser::COMPUTE - 53))
        | (1ULL << (fugue_sqlParser::CONCATENATE - 53))
        | (1ULL << (fugue_sqlParser::CONSTRAINT - 53))
        | (1ULL << (fugue_sqlParser::COST - 53))
        | (1ULL << (fugue_sqlParser::CREATE - 53))
        | (1ULL << (fugue_sqlParser::CROSS - 53))
        | (1ULL << (fugue_sqlParser::CUBE - 53))
        | (1ULL << (fugue_sqlParser::CURRENT - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_DATE - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_TIME - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_USER - 53))
        | (1ULL << (fugue_sqlParser::DATA - 53))
        | (1ULL << (fugue_sqlParser::DATABASE - 53))
        | (1ULL << (fugue_sqlParser::DATABASES - 53))
        | (1ULL << (fugue_sqlParser::DAY - 53))
        | (1ULL << (fugue_sqlParser::DBPROPERTIES - 53))
        | (1ULL << (fugue_sqlParser::DEFINED - 53))
        | (1ULL << (fugue_sqlParser::DELETE - 53))
        | (1ULL << (fugue_sqlParser::DELIMITED - 53))
        | (1ULL << (fugue_sqlParser::DESC - 53))
        | (1ULL << (fugue_sqlParser::DESCRIBE - 53))
        | (1ULL << (fugue_sqlParser::DFS - 53))
        | (1ULL << (fugue_sqlParser::DIRECTORIES - 53))
        | (1ULL << (fugue_sqlParser::DIRECTORY - 53))
        | (1ULL << (fugue_sqlParser::DISTINCT - 53))
        | (1ULL << (fugue_sqlParser::DISTRIBUTE - 53)))) != 0) || ((((_la - 117) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 117)) & ((1ULL << (fugue_sqlParser::DROP - 117))
        | (1ULL << (fugue_sqlParser::ELSE - 117))
        | (1ULL << (fugue_sqlParser::END - 117))
        | (1ULL << (fugue_sqlParser::ESCAPE - 117))
        | (1ULL << (fugue_sqlParser::ESCAPED - 117))
        | (1ULL << (fugue_sqlParser::EXCEPT - 117))
        | (1ULL << (fugue_sqlParser::EXCHANGE - 117))
        | (1ULL << (fugue_sqlParser::EXISTS - 117))
        | (1ULL << (fugue_sqlParser::EXPLAIN - 117))
        | (1ULL << (fugue_sqlParser::EXPORT - 117))
        | (1ULL << (fugue_sqlParser::EXTENDED - 117))
        | (1ULL << (fugue_sqlParser::EXTERNAL - 117))
        | (1ULL << (fugue_sqlParser::EXTRACT - 117))
        | (1ULL << (fugue_sqlParser::FALSE - 117))
        | (1ULL << (fugue_sqlParser::FETCH - 117))
        | (1ULL << (fugue_sqlParser::FIELDS - 117))
        | (1ULL << (fugue_sqlParser::FILTER - 117))
        | (1ULL << (fugue_sqlParser::FILEFORMAT - 117))
        | (1ULL << (fugue_sqlParser::FIRST - 117))
        | (1ULL << (fugue_sqlParser::FOLLOWING - 117))
        | (1ULL << (fugue_sqlParser::FOR - 117))
        | (1ULL << (fugue_sqlParser::FOREIGN - 117))
        | (1ULL << (fugue_sqlParser::FORMAT - 117))
        | (1ULL << (fugue_sqlParser::FORMATTED - 117))
        | (1ULL << (fugue_sqlParser::FROM - 117))
        | (1ULL << (fugue_sqlParser::FULL - 117))
        | (1ULL << (fugue_sqlParser::FUNCTION - 117))
        | (1ULL << (fugue_sqlParser::FUNCTIONS - 117))
        | (1ULL << (fugue_sqlParser::GLOBAL - 117))
        | (1ULL << (fugue_sqlParser::GRANT - 117))
        | (1ULL << (fugue_sqlParser::GROUP - 117))
        | (1ULL << (fugue_sqlParser::GROUPING - 117))
        | (1ULL << (fugue_sqlParser::HAVING - 117))
        | (1ULL << (fugue_sqlParser::HOUR - 117))
        | (1ULL << (fugue_sqlParser::IF - 117))
        | (1ULL << (fugue_sqlParser::IGNORE - 117))
        | (1ULL << (fugue_sqlParser::IMPORT - 117))
        | (1ULL << (fugue_sqlParser::IN - 117))
        | (1ULL << (fugue_sqlParser::INDEX - 117))
        | (1ULL << (fugue_sqlParser::INDEXES - 117))
        | (1ULL << (fugue_sqlParser::INNER - 117))
        | (1ULL << (fugue_sqlParser::INPATH - 117))
        | (1ULL << (fugue_sqlParser::INPUTFORMAT - 117))
        | (1ULL << (fugue_sqlParser::INSERT - 117))
        | (1ULL << (fugue_sqlParser::INTERSECT - 117))
        | (1ULL << (fugue_sqlParser::INTERVAL - 117))
        | (1ULL << (fugue_sqlParser::INTO - 117))
        | (1ULL << (fugue_sqlParser::IS - 117))
        | (1ULL << (fugue_sqlParser::ITEMS - 117))
        | (1ULL << (fugue_sqlParser::JOIN - 117))
        | (1ULL << (fugue_sqlParser::KEYS - 117))
        | (1ULL << (fugue_sqlParser::LAST - 117))
        | (1ULL << (fugue_sqlParser::LATERAL - 117))
        | (1ULL << (fugue_sqlParser::LAZY - 117))
        | (1ULL << (fugue_sqlParser::LEADING - 117))
        | (1ULL << (fugue_sqlParser::LEFT - 117))
        | (1ULL << (fugue_sqlParser::LIKE - 117))
        | (1ULL << (fugue_sqlParser::LIMIT - 117))
        | (1ULL << (fugue_sqlParser::LINES - 117))
        | (1ULL << (fugue_sqlParser::LIST - 117))
        | (1ULL << (fugue_sqlParser::LOAD - 117))
        | (1ULL << (fugue_sqlParser::LOCAL - 117))
        | (1ULL << (fugue_sqlParser::LOCATION - 117))
        | (1ULL << (fugue_sqlParser::LOCK - 117)))) != 0) || ((((_la - 181) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 181)) & ((1ULL << (fugue_sqlParser::LOCKS - 181))
        | (1ULL << (fugue_sqlParser::LOGICAL - 181))
        | (1ULL << (fugue_sqlParser::MACRO - 181))
        | (1ULL << (fugue_sqlParser::MAP - 181))
        | (1ULL << (fugue_sqlParser::MATCHED - 181))
        | (1ULL << (fugue_sqlParser::MERGE - 181))
        | (1ULL << (fugue_sqlParser::MINUTE - 181))
        | (1ULL << (fugue_sqlParser::MONTH - 181))
        | (1ULL << (fugue_sqlParser::MSCK - 181))
        | (1ULL << (fugue_sqlParser::NAMESPACE - 181))
        | (1ULL << (fugue_sqlParser::NAMESPACES - 181))
        | (1ULL << (fugue_sqlParser::NATURAL - 181))
        | (1ULL << (fugue_sqlParser::NO - 181))
        | (1ULL << (fugue_sqlParser::NOT - 181))
        | (1ULL << (fugue_sqlParser::THENULL - 181))
        | (1ULL << (fugue_sqlParser::THENULLS - 181))
        | (1ULL << (fugue_sqlParser::OF - 181))
        | (1ULL << (fugue_sqlParser::ON - 181))
        | (1ULL << (fugue_sqlParser::ONLY - 181))
        | (1ULL << (fugue_sqlParser::OPTION - 181))
        | (1ULL << (fugue_sqlParser::OPTIONS - 181))
        | (1ULL << (fugue_sqlParser::OR - 181))
        | (1ULL << (fugue_sqlParser::ORDER - 181))
        | (1ULL << (fugue_sqlParser::OUT - 181))
        | (1ULL << (fugue_sqlParser::OUTER - 181))
        | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 181))
        | (1ULL << (fugue_sqlParser::OVER - 181))
        | (1ULL << (fugue_sqlParser::OVERLAPS - 181))
        | (1ULL << (fugue_sqlParser::OVERLAY - 181))
        | (1ULL << (fugue_sqlParser::OVERWRITE - 181))
        | (1ULL << (fugue_sqlParser::PARTITION - 181))
        | (1ULL << (fugue_sqlParser::PARTITIONED - 181))
        | (1ULL << (fugue_sqlParser::PARTITIONS - 181))
        | (1ULL << (fugue_sqlParser::PERCENTLIT - 181))
        | (1ULL << (fugue_sqlParser::PIVOT - 181))
        | (1ULL << (fugue_sqlParser::PLACING - 181))
        | (1ULL << (fugue_sqlParser::POSITION - 181))
        | (1ULL << (fugue_sqlParser::PRECEDING - 181))
        | (1ULL << (fugue_sqlParser::PRIMARY - 181))
        | (1ULL << (fugue_sqlParser::PRINCIPALS - 181))
        | (1ULL << (fugue_sqlParser::PROPERTIES - 181))
        | (1ULL << (fugue_sqlParser::PURGE - 181))
        | (1ULL << (fugue_sqlParser::QUERY - 181))
        | (1ULL << (fugue_sqlParser::RANGE - 181))
        | (1ULL << (fugue_sqlParser::RECORDREADER - 181))
        | (1ULL << (fugue_sqlParser::RECORDWRITER - 181))
        | (1ULL << (fugue_sqlParser::RECOVER - 181))
        | (1ULL << (fugue_sqlParser::REDUCE - 181))
        | (1ULL << (fugue_sqlParser::REFERENCES - 181))
        | (1ULL << (fugue_sqlParser::REFRESH - 181))
        | (1ULL << (fugue_sqlParser::RENAME - 181))
        | (1ULL << (fugue_sqlParser::REPAIR - 181))
        | (1ULL << (fugue_sqlParser::REPLACE - 181))
        | (1ULL << (fugue_sqlParser::RESET - 181))
        | (1ULL << (fugue_sqlParser::RESTRICT - 181))
        | (1ULL << (fugue_sqlParser::REVOKE - 181))
        | (1ULL << (fugue_sqlParser::RIGHT - 181))
        | (1ULL << (fugue_sqlParser::RLIKE - 181))
        | (1ULL << (fugue_sqlParser::ROLE - 181))
        | (1ULL << (fugue_sqlParser::ROLES - 181))
        | (1ULL << (fugue_sqlParser::ROLLBACK - 181))
        | (1ULL << (fugue_sqlParser::ROLLUP - 181))
        | (1ULL << (fugue_sqlParser::ROW - 181))
        | (1ULL << (fugue_sqlParser::ROWS - 181)))) != 0) || ((((_la - 245) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 245)) & ((1ULL << (fugue_sqlParser::SCHEMA - 245))
        | (1ULL << (fugue_sqlParser::SECOND - 245))
        | (1ULL << (fugue_sqlParser::SELECT - 245))
        | (1ULL << (fugue_sqlParser::SEMI - 245))
        | (1ULL << (fugue_sqlParser::SEPARATED - 245))
        | (1ULL << (fugue_sqlParser::SERDE - 245))
        | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 245))
        | (1ULL << (fugue_sqlParser::SESSION_USER - 245))
        | (1ULL << (fugue_sqlParser::SET - 245))
        | (1ULL << (fugue_sqlParser::SETMINUS - 245))
        | (1ULL << (fugue_sqlParser::SETS - 245))
        | (1ULL << (fugue_sqlParser::SHOW - 245))
        | (1ULL << (fugue_sqlParser::SKEWED - 245))
        | (1ULL << (fugue_sqlParser::SOME - 245))
        | (1ULL << (fugue_sqlParser::SORT - 245))
        | (1ULL << (fugue_sqlParser::SORTED - 245))
        | (1ULL << (fugue_sqlParser::START - 245))
        | (1ULL << (fugue_sqlParser::STATISTICS - 245))
        | (1ULL << (fugue_sqlParser::STORED - 245))
        | (1ULL << (fugue_sqlParser::STRATIFY - 245))
        | (1ULL << (fugue_sqlParser::STRUCT - 245))
        | (1ULL << (fugue_sqlParser::SUBSTR - 245))
        | (1ULL << (fugue_sqlParser::SUBSTRING - 245))
        | (1ULL << (fugue_sqlParser::TABLE - 245))
        | (1ULL << (fugue_sqlParser::TABLES - 245))
        | (1ULL << (fugue_sqlParser::TABLESAMPLE - 245))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 245))
        | (1ULL << (fugue_sqlParser::TEMPORARY - 245))
        | (1ULL << (fugue_sqlParser::TERMINATED - 245))
        | (1ULL << (fugue_sqlParser::THEN - 245))
        | (1ULL << (fugue_sqlParser::TO - 245))
        | (1ULL << (fugue_sqlParser::TOUCH - 245))
        | (1ULL << (fugue_sqlParser::TRAILING - 245))
        | (1ULL << (fugue_sqlParser::TRANSACTION - 245))
        | (1ULL << (fugue_sqlParser::TRANSACTIONS - 245))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 245))
        | (1ULL << (fugue_sqlParser::TRIM - 245))
        | (1ULL << (fugue_sqlParser::TRUE - 245))
        | (1ULL << (fugue_sqlParser::TRUNCATE - 245))
        | (1ULL << (fugue_sqlParser::TYPE - 245))
        | (1ULL << (fugue_sqlParser::UNARCHIVE - 245))
        | (1ULL << (fugue_sqlParser::UNBOUNDED - 245))
        | (1ULL << (fugue_sqlParser::UNCACHE - 245))
        | (1ULL << (fugue_sqlParser::UNION - 245))
        | (1ULL << (fugue_sqlParser::UNIQUE - 245))
        | (1ULL << (fugue_sqlParser::UNKNOWN - 245))
        | (1ULL << (fugue_sqlParser::UNLOCK - 245))
        | (1ULL << (fugue_sqlParser::UNSET - 245))
        | (1ULL << (fugue_sqlParser::UPDATE - 245))
        | (1ULL << (fugue_sqlParser::USE - 245))
        | (1ULL << (fugue_sqlParser::USER - 245))
        | (1ULL << (fugue_sqlParser::USING - 245))
        | (1ULL << (fugue_sqlParser::VALUES - 245))
        | (1ULL << (fugue_sqlParser::VIEW - 245))
        | (1ULL << (fugue_sqlParser::VIEWS - 245))
        | (1ULL << (fugue_sqlParser::WHEN - 245))
        | (1ULL << (fugue_sqlParser::WHERE - 245))
        | (1ULL << (fugue_sqlParser::WINDOW - 245))
        | (1ULL << (fugue_sqlParser::WITH - 245))
        | (1ULL << (fugue_sqlParser::YEAR - 245)))) != 0) || ((((_la - 319) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 319)) & ((1ULL << (fugue_sqlParser::DIV - 319))
        | (1ULL << (fugue_sqlParser::STRING - 319))
        | (1ULL << (fugue_sqlParser::IDENTIFIER - 319))
        | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 319)))) != 0)) {
        setState(1679);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 205, _ctx)) {
        case 1: {
          setState(1678);
          match(fugue_sqlParser::LIKE);
          break;
        }

        default:
          break;
        }
        setState(1683);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::ADD:
          case fugue_sqlParser::AFTER:
          case fugue_sqlParser::ALL:
          case fugue_sqlParser::ALTER:
          case fugue_sqlParser::ANALYZE:
          case fugue_sqlParser::AND:
          case fugue_sqlParser::ANTI:
          case fugue_sqlParser::ANY:
          case fugue_sqlParser::ARCHIVE:
          case fugue_sqlParser::ARRAY:
          case fugue_sqlParser::AS:
          case fugue_sqlParser::ASC:
          case fugue_sqlParser::AT:
          case fugue_sqlParser::AUTHORIZATION:
          case fugue_sqlParser::BETWEEN:
          case fugue_sqlParser::BOTH:
          case fugue_sqlParser::BUCKET:
          case fugue_sqlParser::BUCKETS:
          case fugue_sqlParser::BY:
          case fugue_sqlParser::CACHE:
          case fugue_sqlParser::CASCADE:
          case fugue_sqlParser::CASE:
          case fugue_sqlParser::CAST:
          case fugue_sqlParser::CHANGE:
          case fugue_sqlParser::CHECK:
          case fugue_sqlParser::CLEAR:
          case fugue_sqlParser::CLUSTER:
          case fugue_sqlParser::CLUSTERED:
          case fugue_sqlParser::CODEGEN:
          case fugue_sqlParser::COLLATE:
          case fugue_sqlParser::COLLECTION:
          case fugue_sqlParser::COLUMN:
          case fugue_sqlParser::COLUMNS:
          case fugue_sqlParser::COMMENT:
          case fugue_sqlParser::COMMIT:
          case fugue_sqlParser::COMPACT:
          case fugue_sqlParser::COMPACTIONS:
          case fugue_sqlParser::COMPUTE:
          case fugue_sqlParser::CONCATENATE:
          case fugue_sqlParser::CONSTRAINT:
          case fugue_sqlParser::COST:
          case fugue_sqlParser::CREATE:
          case fugue_sqlParser::CROSS:
          case fugue_sqlParser::CUBE:
          case fugue_sqlParser::CURRENT:
          case fugue_sqlParser::CURRENT_DATE:
          case fugue_sqlParser::CURRENT_TIME:
          case fugue_sqlParser::CURRENT_TIMESTAMP:
          case fugue_sqlParser::CURRENT_USER:
          case fugue_sqlParser::DATA:
          case fugue_sqlParser::DATABASE:
          case fugue_sqlParser::DATABASES:
          case fugue_sqlParser::DAY:
          case fugue_sqlParser::DBPROPERTIES:
          case fugue_sqlParser::DEFINED:
          case fugue_sqlParser::DELETE:
          case fugue_sqlParser::DELIMITED:
          case fugue_sqlParser::DESC:
          case fugue_sqlParser::DESCRIBE:
          case fugue_sqlParser::DFS:
          case fugue_sqlParser::DIRECTORIES:
          case fugue_sqlParser::DIRECTORY:
          case fugue_sqlParser::DISTINCT:
          case fugue_sqlParser::DISTRIBUTE:
          case fugue_sqlParser::DROP:
          case fugue_sqlParser::ELSE:
          case fugue_sqlParser::END:
          case fugue_sqlParser::ESCAPE:
          case fugue_sqlParser::ESCAPED:
          case fugue_sqlParser::EXCEPT:
          case fugue_sqlParser::EXCHANGE:
          case fugue_sqlParser::EXISTS:
          case fugue_sqlParser::EXPLAIN:
          case fugue_sqlParser::EXPORT:
          case fugue_sqlParser::EXTENDED:
          case fugue_sqlParser::EXTERNAL:
          case fugue_sqlParser::EXTRACT:
          case fugue_sqlParser::FALSE:
          case fugue_sqlParser::FETCH:
          case fugue_sqlParser::FIELDS:
          case fugue_sqlParser::FILTER:
          case fugue_sqlParser::FILEFORMAT:
          case fugue_sqlParser::FIRST:
          case fugue_sqlParser::FOLLOWING:
          case fugue_sqlParser::FOR:
          case fugue_sqlParser::FOREIGN:
          case fugue_sqlParser::FORMAT:
          case fugue_sqlParser::FORMATTED:
          case fugue_sqlParser::FROM:
          case fugue_sqlParser::FULL:
          case fugue_sqlParser::FUNCTION:
          case fugue_sqlParser::FUNCTIONS:
          case fugue_sqlParser::GLOBAL:
          case fugue_sqlParser::GRANT:
          case fugue_sqlParser::GROUP:
          case fugue_sqlParser::GROUPING:
          case fugue_sqlParser::HAVING:
          case fugue_sqlParser::HOUR:
          case fugue_sqlParser::IF:
          case fugue_sqlParser::IGNORE:
          case fugue_sqlParser::IMPORT:
          case fugue_sqlParser::IN:
          case fugue_sqlParser::INDEX:
          case fugue_sqlParser::INDEXES:
          case fugue_sqlParser::INNER:
          case fugue_sqlParser::INPATH:
          case fugue_sqlParser::INPUTFORMAT:
          case fugue_sqlParser::INSERT:
          case fugue_sqlParser::INTERSECT:
          case fugue_sqlParser::INTERVAL:
          case fugue_sqlParser::INTO:
          case fugue_sqlParser::IS:
          case fugue_sqlParser::ITEMS:
          case fugue_sqlParser::JOIN:
          case fugue_sqlParser::KEYS:
          case fugue_sqlParser::LAST:
          case fugue_sqlParser::LATERAL:
          case fugue_sqlParser::LAZY:
          case fugue_sqlParser::LEADING:
          case fugue_sqlParser::LEFT:
          case fugue_sqlParser::LIKE:
          case fugue_sqlParser::LIMIT:
          case fugue_sqlParser::LINES:
          case fugue_sqlParser::LIST:
          case fugue_sqlParser::LOAD:
          case fugue_sqlParser::LOCAL:
          case fugue_sqlParser::LOCATION:
          case fugue_sqlParser::LOCK:
          case fugue_sqlParser::LOCKS:
          case fugue_sqlParser::LOGICAL:
          case fugue_sqlParser::MACRO:
          case fugue_sqlParser::MAP:
          case fugue_sqlParser::MATCHED:
          case fugue_sqlParser::MERGE:
          case fugue_sqlParser::MINUTE:
          case fugue_sqlParser::MONTH:
          case fugue_sqlParser::MSCK:
          case fugue_sqlParser::NAMESPACE:
          case fugue_sqlParser::NAMESPACES:
          case fugue_sqlParser::NATURAL:
          case fugue_sqlParser::NO:
          case fugue_sqlParser::NOT:
          case fugue_sqlParser::THENULL:
          case fugue_sqlParser::THENULLS:
          case fugue_sqlParser::OF:
          case fugue_sqlParser::ON:
          case fugue_sqlParser::ONLY:
          case fugue_sqlParser::OPTION:
          case fugue_sqlParser::OPTIONS:
          case fugue_sqlParser::OR:
          case fugue_sqlParser::ORDER:
          case fugue_sqlParser::OUT:
          case fugue_sqlParser::OUTER:
          case fugue_sqlParser::OUTPUTFORMAT:
          case fugue_sqlParser::OVER:
          case fugue_sqlParser::OVERLAPS:
          case fugue_sqlParser::OVERLAY:
          case fugue_sqlParser::OVERWRITE:
          case fugue_sqlParser::PARTITION:
          case fugue_sqlParser::PARTITIONED:
          case fugue_sqlParser::PARTITIONS:
          case fugue_sqlParser::PERCENTLIT:
          case fugue_sqlParser::PIVOT:
          case fugue_sqlParser::PLACING:
          case fugue_sqlParser::POSITION:
          case fugue_sqlParser::PRECEDING:
          case fugue_sqlParser::PRIMARY:
          case fugue_sqlParser::PRINCIPALS:
          case fugue_sqlParser::PROPERTIES:
          case fugue_sqlParser::PURGE:
          case fugue_sqlParser::QUERY:
          case fugue_sqlParser::RANGE:
          case fugue_sqlParser::RECORDREADER:
          case fugue_sqlParser::RECORDWRITER:
          case fugue_sqlParser::RECOVER:
          case fugue_sqlParser::REDUCE:
          case fugue_sqlParser::REFERENCES:
          case fugue_sqlParser::REFRESH:
          case fugue_sqlParser::RENAME:
          case fugue_sqlParser::REPAIR:
          case fugue_sqlParser::REPLACE:
          case fugue_sqlParser::RESET:
          case fugue_sqlParser::RESTRICT:
          case fugue_sqlParser::REVOKE:
          case fugue_sqlParser::RIGHT:
          case fugue_sqlParser::RLIKE:
          case fugue_sqlParser::ROLE:
          case fugue_sqlParser::ROLES:
          case fugue_sqlParser::ROLLBACK:
          case fugue_sqlParser::ROLLUP:
          case fugue_sqlParser::ROW:
          case fugue_sqlParser::ROWS:
          case fugue_sqlParser::SCHEMA:
          case fugue_sqlParser::SECOND:
          case fugue_sqlParser::SELECT:
          case fugue_sqlParser::SEMI:
          case fugue_sqlParser::SEPARATED:
          case fugue_sqlParser::SERDE:
          case fugue_sqlParser::SERDEPROPERTIES:
          case fugue_sqlParser::SESSION_USER:
          case fugue_sqlParser::SET:
          case fugue_sqlParser::SETMINUS:
          case fugue_sqlParser::SETS:
          case fugue_sqlParser::SHOW:
          case fugue_sqlParser::SKEWED:
          case fugue_sqlParser::SOME:
          case fugue_sqlParser::SORT:
          case fugue_sqlParser::SORTED:
          case fugue_sqlParser::START:
          case fugue_sqlParser::STATISTICS:
          case fugue_sqlParser::STORED:
          case fugue_sqlParser::STRATIFY:
          case fugue_sqlParser::STRUCT:
          case fugue_sqlParser::SUBSTR:
          case fugue_sqlParser::SUBSTRING:
          case fugue_sqlParser::TABLE:
          case fugue_sqlParser::TABLES:
          case fugue_sqlParser::TABLESAMPLE:
          case fugue_sqlParser::TBLPROPERTIES:
          case fugue_sqlParser::TEMPORARY:
          case fugue_sqlParser::TERMINATED:
          case fugue_sqlParser::THEN:
          case fugue_sqlParser::TO:
          case fugue_sqlParser::TOUCH:
          case fugue_sqlParser::TRAILING:
          case fugue_sqlParser::TRANSACTION:
          case fugue_sqlParser::TRANSACTIONS:
          case fugue_sqlParser::TRANSFORM:
          case fugue_sqlParser::TRIM:
          case fugue_sqlParser::TRUE:
          case fugue_sqlParser::TRUNCATE:
          case fugue_sqlParser::TYPE:
          case fugue_sqlParser::UNARCHIVE:
          case fugue_sqlParser::UNBOUNDED:
          case fugue_sqlParser::UNCACHE:
          case fugue_sqlParser::UNION:
          case fugue_sqlParser::UNIQUE:
          case fugue_sqlParser::UNKNOWN:
          case fugue_sqlParser::UNLOCK:
          case fugue_sqlParser::UNSET:
          case fugue_sqlParser::UPDATE:
          case fugue_sqlParser::USE:
          case fugue_sqlParser::USER:
          case fugue_sqlParser::USING:
          case fugue_sqlParser::VALUES:
          case fugue_sqlParser::VIEW:
          case fugue_sqlParser::VIEWS:
          case fugue_sqlParser::WHEN:
          case fugue_sqlParser::WHERE:
          case fugue_sqlParser::WINDOW:
          case fugue_sqlParser::WITH:
          case fugue_sqlParser::YEAR:
          case fugue_sqlParser::DIV:
          case fugue_sqlParser::IDENTIFIER:
          case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
            setState(1681);
            multipartIdentifier();
            break;
          }

          case fugue_sqlParser::STRING: {
            setState(1682);
            antlrcpp::downCast<ShowFunctionsContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
            break;
          }

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

    case 47: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowCreateTableContext>(_localctx);
      enterOuterAlt(_localctx, 47);
      setState(1687);
      match(fugue_sqlParser::SHOW);
      setState(1688);
      match(fugue_sqlParser::CREATE);
      setState(1689);
      match(fugue_sqlParser::TABLE);
      setState(1690);
      multipartIdentifier();
      setState(1693);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AS) {
        setState(1691);
        match(fugue_sqlParser::AS);
        setState(1692);
        match(fugue_sqlParser::SERDE);
      }
      break;
    }

    case 48: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowCurrentNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 48);
      setState(1695);
      match(fugue_sqlParser::SHOW);
      setState(1696);
      match(fugue_sqlParser::CURRENT);
      setState(1697);
      match(fugue_sqlParser::NAMESPACE);
      break;
    }

    case 49: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 49);
      setState(1698);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

      || _la == fugue_sqlParser::DESCRIBE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1699);
      match(fugue_sqlParser::FUNCTION);
      setState(1701);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 209, _ctx)) {
      case 1: {
        setState(1700);
        match(fugue_sqlParser::EXTENDED);
        break;
      }

      default:
        break;
      }
      setState(1703);
      describeFuncName();
      break;
    }

    case 50: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 50);
      setState(1704);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

      || _la == fugue_sqlParser::DESCRIBE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1705);
      theNamespace();
      setState(1707);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx)) {
      case 1: {
        setState(1706);
        match(fugue_sqlParser::EXTENDED);
        break;
      }

      default:
        break;
      }
      setState(1709);
      multipartIdentifier();
      break;
    }

    case 51: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeRelationContext>(_localctx);
      enterOuterAlt(_localctx, 51);
      setState(1711);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

      || _la == fugue_sqlParser::DESCRIBE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1713);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 211, _ctx)) {
      case 1: {
        setState(1712);
        match(fugue_sqlParser::TABLE);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 212, _ctx)) {
      case 1: {
        setState(1715);
        antlrcpp::downCast<DescribeRelationContext *>(_localctx)->option = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::EXTENDED

        || _la == fugue_sqlParser::FORMATTED)) {
          antlrcpp::downCast<DescribeRelationContext *>(_localctx)->option = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

      default:
        break;
      }
      setState(1718);
      multipartIdentifier();
      setState(1720);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if (((((_la - 53) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 53)) & ((1ULL << (fugue_sqlParser::ADD - 53))
        | (1ULL << (fugue_sqlParser::AFTER - 53))
        | (1ULL << (fugue_sqlParser::ALL - 53))
        | (1ULL << (fugue_sqlParser::ALTER - 53))
        | (1ULL << (fugue_sqlParser::ANALYZE - 53))
        | (1ULL << (fugue_sqlParser::AND - 53))
        | (1ULL << (fugue_sqlParser::ANTI - 53))
        | (1ULL << (fugue_sqlParser::ANY - 53))
        | (1ULL << (fugue_sqlParser::ARCHIVE - 53))
        | (1ULL << (fugue_sqlParser::ARRAY - 53))
        | (1ULL << (fugue_sqlParser::AS - 53))
        | (1ULL << (fugue_sqlParser::ASC - 53))
        | (1ULL << (fugue_sqlParser::AT - 53))
        | (1ULL << (fugue_sqlParser::AUTHORIZATION - 53))
        | (1ULL << (fugue_sqlParser::BETWEEN - 53))
        | (1ULL << (fugue_sqlParser::BOTH - 53))
        | (1ULL << (fugue_sqlParser::BUCKET - 53))
        | (1ULL << (fugue_sqlParser::BUCKETS - 53))
        | (1ULL << (fugue_sqlParser::BY - 53))
        | (1ULL << (fugue_sqlParser::CACHE - 53))
        | (1ULL << (fugue_sqlParser::CASCADE - 53))
        | (1ULL << (fugue_sqlParser::CASE - 53))
        | (1ULL << (fugue_sqlParser::CAST - 53))
        | (1ULL << (fugue_sqlParser::CHANGE - 53))
        | (1ULL << (fugue_sqlParser::CHECK - 53))
        | (1ULL << (fugue_sqlParser::CLEAR - 53))
        | (1ULL << (fugue_sqlParser::CLUSTER - 53))
        | (1ULL << (fugue_sqlParser::CLUSTERED - 53))
        | (1ULL << (fugue_sqlParser::CODEGEN - 53))
        | (1ULL << (fugue_sqlParser::COLLATE - 53))
        | (1ULL << (fugue_sqlParser::COLLECTION - 53))
        | (1ULL << (fugue_sqlParser::COLUMN - 53))
        | (1ULL << (fugue_sqlParser::COLUMNS - 53))
        | (1ULL << (fugue_sqlParser::COMMENT - 53))
        | (1ULL << (fugue_sqlParser::COMMIT - 53))
        | (1ULL << (fugue_sqlParser::COMPACT - 53))
        | (1ULL << (fugue_sqlParser::COMPACTIONS - 53))
        | (1ULL << (fugue_sqlParser::COMPUTE - 53))
        | (1ULL << (fugue_sqlParser::CONCATENATE - 53))
        | (1ULL << (fugue_sqlParser::CONSTRAINT - 53))
        | (1ULL << (fugue_sqlParser::COST - 53))
        | (1ULL << (fugue_sqlParser::CREATE - 53))
        | (1ULL << (fugue_sqlParser::CROSS - 53))
        | (1ULL << (fugue_sqlParser::CUBE - 53))
        | (1ULL << (fugue_sqlParser::CURRENT - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_DATE - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_TIME - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 53))
        | (1ULL << (fugue_sqlParser::CURRENT_USER - 53))
        | (1ULL << (fugue_sqlParser::DATA - 53))
        | (1ULL << (fugue_sqlParser::DATABASE - 53))
        | (1ULL << (fugue_sqlParser::DATABASES - 53))
        | (1ULL << (fugue_sqlParser::DAY - 53))
        | (1ULL << (fugue_sqlParser::DBPROPERTIES - 53))
        | (1ULL << (fugue_sqlParser::DEFINED - 53))
        | (1ULL << (fugue_sqlParser::DELETE - 53))
        | (1ULL << (fugue_sqlParser::DELIMITED - 53))
        | (1ULL << (fugue_sqlParser::DESC - 53))
        | (1ULL << (fugue_sqlParser::DESCRIBE - 53))
        | (1ULL << (fugue_sqlParser::DFS - 53))
        | (1ULL << (fugue_sqlParser::DIRECTORIES - 53))
        | (1ULL << (fugue_sqlParser::DIRECTORY - 53))
        | (1ULL << (fugue_sqlParser::DISTINCT - 53))
        | (1ULL << (fugue_sqlParser::DISTRIBUTE - 53)))) != 0) || ((((_la - 117) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 117)) & ((1ULL << (fugue_sqlParser::DROP - 117))
        | (1ULL << (fugue_sqlParser::ELSE - 117))
        | (1ULL << (fugue_sqlParser::END - 117))
        | (1ULL << (fugue_sqlParser::ESCAPE - 117))
        | (1ULL << (fugue_sqlParser::ESCAPED - 117))
        | (1ULL << (fugue_sqlParser::EXCEPT - 117))
        | (1ULL << (fugue_sqlParser::EXCHANGE - 117))
        | (1ULL << (fugue_sqlParser::EXISTS - 117))
        | (1ULL << (fugue_sqlParser::EXPLAIN - 117))
        | (1ULL << (fugue_sqlParser::EXPORT - 117))
        | (1ULL << (fugue_sqlParser::EXTENDED - 117))
        | (1ULL << (fugue_sqlParser::EXTERNAL - 117))
        | (1ULL << (fugue_sqlParser::EXTRACT - 117))
        | (1ULL << (fugue_sqlParser::FALSE - 117))
        | (1ULL << (fugue_sqlParser::FETCH - 117))
        | (1ULL << (fugue_sqlParser::FIELDS - 117))
        | (1ULL << (fugue_sqlParser::FILTER - 117))
        | (1ULL << (fugue_sqlParser::FILEFORMAT - 117))
        | (1ULL << (fugue_sqlParser::FIRST - 117))
        | (1ULL << (fugue_sqlParser::FOLLOWING - 117))
        | (1ULL << (fugue_sqlParser::FOR - 117))
        | (1ULL << (fugue_sqlParser::FOREIGN - 117))
        | (1ULL << (fugue_sqlParser::FORMAT - 117))
        | (1ULL << (fugue_sqlParser::FORMATTED - 117))
        | (1ULL << (fugue_sqlParser::FROM - 117))
        | (1ULL << (fugue_sqlParser::FULL - 117))
        | (1ULL << (fugue_sqlParser::FUNCTION - 117))
        | (1ULL << (fugue_sqlParser::FUNCTIONS - 117))
        | (1ULL << (fugue_sqlParser::GLOBAL - 117))
        | (1ULL << (fugue_sqlParser::GRANT - 117))
        | (1ULL << (fugue_sqlParser::GROUP - 117))
        | (1ULL << (fugue_sqlParser::GROUPING - 117))
        | (1ULL << (fugue_sqlParser::HAVING - 117))
        | (1ULL << (fugue_sqlParser::HOUR - 117))
        | (1ULL << (fugue_sqlParser::IF - 117))
        | (1ULL << (fugue_sqlParser::IGNORE - 117))
        | (1ULL << (fugue_sqlParser::IMPORT - 117))
        | (1ULL << (fugue_sqlParser::IN - 117))
        | (1ULL << (fugue_sqlParser::INDEX - 117))
        | (1ULL << (fugue_sqlParser::INDEXES - 117))
        | (1ULL << (fugue_sqlParser::INNER - 117))
        | (1ULL << (fugue_sqlParser::INPATH - 117))
        | (1ULL << (fugue_sqlParser::INPUTFORMAT - 117))
        | (1ULL << (fugue_sqlParser::INSERT - 117))
        | (1ULL << (fugue_sqlParser::INTERSECT - 117))
        | (1ULL << (fugue_sqlParser::INTERVAL - 117))
        | (1ULL << (fugue_sqlParser::INTO - 117))
        | (1ULL << (fugue_sqlParser::IS - 117))
        | (1ULL << (fugue_sqlParser::ITEMS - 117))
        | (1ULL << (fugue_sqlParser::JOIN - 117))
        | (1ULL << (fugue_sqlParser::KEYS - 117))
        | (1ULL << (fugue_sqlParser::LAST - 117))
        | (1ULL << (fugue_sqlParser::LATERAL - 117))
        | (1ULL << (fugue_sqlParser::LAZY - 117))
        | (1ULL << (fugue_sqlParser::LEADING - 117))
        | (1ULL << (fugue_sqlParser::LEFT - 117))
        | (1ULL << (fugue_sqlParser::LIKE - 117))
        | (1ULL << (fugue_sqlParser::LIMIT - 117))
        | (1ULL << (fugue_sqlParser::LINES - 117))
        | (1ULL << (fugue_sqlParser::LIST - 117))
        | (1ULL << (fugue_sqlParser::LOAD - 117))
        | (1ULL << (fugue_sqlParser::LOCAL - 117))
        | (1ULL << (fugue_sqlParser::LOCATION - 117))
        | (1ULL << (fugue_sqlParser::LOCK - 117)))) != 0) || ((((_la - 181) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 181)) & ((1ULL << (fugue_sqlParser::LOCKS - 181))
        | (1ULL << (fugue_sqlParser::LOGICAL - 181))
        | (1ULL << (fugue_sqlParser::MACRO - 181))
        | (1ULL << (fugue_sqlParser::MAP - 181))
        | (1ULL << (fugue_sqlParser::MATCHED - 181))
        | (1ULL << (fugue_sqlParser::MERGE - 181))
        | (1ULL << (fugue_sqlParser::MINUTE - 181))
        | (1ULL << (fugue_sqlParser::MONTH - 181))
        | (1ULL << (fugue_sqlParser::MSCK - 181))
        | (1ULL << (fugue_sqlParser::NAMESPACE - 181))
        | (1ULL << (fugue_sqlParser::NAMESPACES - 181))
        | (1ULL << (fugue_sqlParser::NATURAL - 181))
        | (1ULL << (fugue_sqlParser::NO - 181))
        | (1ULL << (fugue_sqlParser::NOT - 181))
        | (1ULL << (fugue_sqlParser::THENULL - 181))
        | (1ULL << (fugue_sqlParser::THENULLS - 181))
        | (1ULL << (fugue_sqlParser::OF - 181))
        | (1ULL << (fugue_sqlParser::ON - 181))
        | (1ULL << (fugue_sqlParser::ONLY - 181))
        | (1ULL << (fugue_sqlParser::OPTION - 181))
        | (1ULL << (fugue_sqlParser::OPTIONS - 181))
        | (1ULL << (fugue_sqlParser::OR - 181))
        | (1ULL << (fugue_sqlParser::ORDER - 181))
        | (1ULL << (fugue_sqlParser::OUT - 181))
        | (1ULL << (fugue_sqlParser::OUTER - 181))
        | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 181))
        | (1ULL << (fugue_sqlParser::OVER - 181))
        | (1ULL << (fugue_sqlParser::OVERLAPS - 181))
        | (1ULL << (fugue_sqlParser::OVERLAY - 181))
        | (1ULL << (fugue_sqlParser::OVERWRITE - 181))
        | (1ULL << (fugue_sqlParser::PARTITION - 181))
        | (1ULL << (fugue_sqlParser::PARTITIONED - 181))
        | (1ULL << (fugue_sqlParser::PARTITIONS - 181))
        | (1ULL << (fugue_sqlParser::PERCENTLIT - 181))
        | (1ULL << (fugue_sqlParser::PIVOT - 181))
        | (1ULL << (fugue_sqlParser::PLACING - 181))
        | (1ULL << (fugue_sqlParser::POSITION - 181))
        | (1ULL << (fugue_sqlParser::PRECEDING - 181))
        | (1ULL << (fugue_sqlParser::PRIMARY - 181))
        | (1ULL << (fugue_sqlParser::PRINCIPALS - 181))
        | (1ULL << (fugue_sqlParser::PROPERTIES - 181))
        | (1ULL << (fugue_sqlParser::PURGE - 181))
        | (1ULL << (fugue_sqlParser::QUERY - 181))
        | (1ULL << (fugue_sqlParser::RANGE - 181))
        | (1ULL << (fugue_sqlParser::RECORDREADER - 181))
        | (1ULL << (fugue_sqlParser::RECORDWRITER - 181))
        | (1ULL << (fugue_sqlParser::RECOVER - 181))
        | (1ULL << (fugue_sqlParser::REDUCE - 181))
        | (1ULL << (fugue_sqlParser::REFERENCES - 181))
        | (1ULL << (fugue_sqlParser::REFRESH - 181))
        | (1ULL << (fugue_sqlParser::RENAME - 181))
        | (1ULL << (fugue_sqlParser::REPAIR - 181))
        | (1ULL << (fugue_sqlParser::REPLACE - 181))
        | (1ULL << (fugue_sqlParser::RESET - 181))
        | (1ULL << (fugue_sqlParser::RESTRICT - 181))
        | (1ULL << (fugue_sqlParser::REVOKE - 181))
        | (1ULL << (fugue_sqlParser::RIGHT - 181))
        | (1ULL << (fugue_sqlParser::RLIKE - 181))
        | (1ULL << (fugue_sqlParser::ROLE - 181))
        | (1ULL << (fugue_sqlParser::ROLES - 181))
        | (1ULL << (fugue_sqlParser::ROLLBACK - 181))
        | (1ULL << (fugue_sqlParser::ROLLUP - 181))
        | (1ULL << (fugue_sqlParser::ROW - 181))
        | (1ULL << (fugue_sqlParser::ROWS - 181)))) != 0) || ((((_la - 245) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 245)) & ((1ULL << (fugue_sqlParser::SCHEMA - 245))
        | (1ULL << (fugue_sqlParser::SECOND - 245))
        | (1ULL << (fugue_sqlParser::SELECT - 245))
        | (1ULL << (fugue_sqlParser::SEMI - 245))
        | (1ULL << (fugue_sqlParser::SEPARATED - 245))
        | (1ULL << (fugue_sqlParser::SERDE - 245))
        | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 245))
        | (1ULL << (fugue_sqlParser::SESSION_USER - 245))
        | (1ULL << (fugue_sqlParser::SET - 245))
        | (1ULL << (fugue_sqlParser::SETMINUS - 245))
        | (1ULL << (fugue_sqlParser::SETS - 245))
        | (1ULL << (fugue_sqlParser::SHOW - 245))
        | (1ULL << (fugue_sqlParser::SKEWED - 245))
        | (1ULL << (fugue_sqlParser::SOME - 245))
        | (1ULL << (fugue_sqlParser::SORT - 245))
        | (1ULL << (fugue_sqlParser::SORTED - 245))
        | (1ULL << (fugue_sqlParser::START - 245))
        | (1ULL << (fugue_sqlParser::STATISTICS - 245))
        | (1ULL << (fugue_sqlParser::STORED - 245))
        | (1ULL << (fugue_sqlParser::STRATIFY - 245))
        | (1ULL << (fugue_sqlParser::STRUCT - 245))
        | (1ULL << (fugue_sqlParser::SUBSTR - 245))
        | (1ULL << (fugue_sqlParser::SUBSTRING - 245))
        | (1ULL << (fugue_sqlParser::TABLE - 245))
        | (1ULL << (fugue_sqlParser::TABLES - 245))
        | (1ULL << (fugue_sqlParser::TABLESAMPLE - 245))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 245))
        | (1ULL << (fugue_sqlParser::TEMPORARY - 245))
        | (1ULL << (fugue_sqlParser::TERMINATED - 245))
        | (1ULL << (fugue_sqlParser::THEN - 245))
        | (1ULL << (fugue_sqlParser::TO - 245))
        | (1ULL << (fugue_sqlParser::TOUCH - 245))
        | (1ULL << (fugue_sqlParser::TRAILING - 245))
        | (1ULL << (fugue_sqlParser::TRANSACTION - 245))
        | (1ULL << (fugue_sqlParser::TRANSACTIONS - 245))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 245))
        | (1ULL << (fugue_sqlParser::TRIM - 245))
        | (1ULL << (fugue_sqlParser::TRUE - 245))
        | (1ULL << (fugue_sqlParser::TRUNCATE - 245))
        | (1ULL << (fugue_sqlParser::TYPE - 245))
        | (1ULL << (fugue_sqlParser::UNARCHIVE - 245))
        | (1ULL << (fugue_sqlParser::UNBOUNDED - 245))
        | (1ULL << (fugue_sqlParser::UNCACHE - 245))
        | (1ULL << (fugue_sqlParser::UNION - 245))
        | (1ULL << (fugue_sqlParser::UNIQUE - 245))
        | (1ULL << (fugue_sqlParser::UNKNOWN - 245))
        | (1ULL << (fugue_sqlParser::UNLOCK - 245))
        | (1ULL << (fugue_sqlParser::UNSET - 245))
        | (1ULL << (fugue_sqlParser::UPDATE - 245))
        | (1ULL << (fugue_sqlParser::USE - 245))
        | (1ULL << (fugue_sqlParser::USER - 245))
        | (1ULL << (fugue_sqlParser::USING - 245))
        | (1ULL << (fugue_sqlParser::VALUES - 245))
        | (1ULL << (fugue_sqlParser::VIEW - 245))
        | (1ULL << (fugue_sqlParser::VIEWS - 245))
        | (1ULL << (fugue_sqlParser::WHEN - 245))
        | (1ULL << (fugue_sqlParser::WHERE - 245))
        | (1ULL << (fugue_sqlParser::WINDOW - 245))
        | (1ULL << (fugue_sqlParser::WITH - 245))
        | (1ULL << (fugue_sqlParser::YEAR - 245)))) != 0) || ((((_la - 319) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 319)) & ((1ULL << (fugue_sqlParser::DIV - 319))
        | (1ULL << (fugue_sqlParser::IDENTIFIER - 319))
        | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 319)))) != 0)) {
        setState(1722);
        describeColName();
      }
      break;
    }

    case 52: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeQueryContext>(_localctx);
      enterOuterAlt(_localctx, 52);
      setState(1725);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

      || _la == fugue_sqlParser::DESCRIBE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1727);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::QUERY) {
        setState(1726);
        match(fugue_sqlParser::QUERY);
      }
      setState(1729);
      query();
      break;
    }

    case 53: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CommentNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 53);
      setState(1730);
      match(fugue_sqlParser::COMMENT);
      setState(1731);
      match(fugue_sqlParser::ON);
      setState(1732);
      theNamespace();
      setState(1733);
      multipartIdentifier();
      setState(1734);
      match(fugue_sqlParser::IS);
      setState(1735);
      antlrcpp::downCast<CommentNamespaceContext *>(_localctx)->comment = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::THENULL || _la == fugue_sqlParser::STRING)) {
        antlrcpp::downCast<CommentNamespaceContext *>(_localctx)->comment = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 54: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CommentTableContext>(_localctx);
      enterOuterAlt(_localctx, 54);
      setState(1737);
      match(fugue_sqlParser::COMMENT);
      setState(1738);
      match(fugue_sqlParser::ON);
      setState(1739);
      match(fugue_sqlParser::TABLE);
      setState(1740);
      multipartIdentifier();
      setState(1741);
      match(fugue_sqlParser::IS);
      setState(1742);
      antlrcpp::downCast<CommentTableContext *>(_localctx)->comment = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::THENULL || _la == fugue_sqlParser::STRING)) {
        antlrcpp::downCast<CommentTableContext *>(_localctx)->comment = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 55: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RefreshTableContext>(_localctx);
      enterOuterAlt(_localctx, 55);
      setState(1744);
      match(fugue_sqlParser::REFRESH);
      setState(1745);
      match(fugue_sqlParser::TABLE);
      setState(1746);
      multipartIdentifier();
      break;
    }

    case 56: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RefreshResourceContext>(_localctx);
      enterOuterAlt(_localctx, 56);
      setState(1747);
      match(fugue_sqlParser::REFRESH);
      setState(1755);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 217, _ctx)) {
      case 1: {
        setState(1748);
        match(fugue_sqlParser::STRING);
        break;
      }

      case 2: {
        setState(1752);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 216, _ctx);
        while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1 + 1) {
            setState(1749);
            matchWildcard(); 
          }
          setState(1754);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 216, _ctx);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 57: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CacheTableContext>(_localctx);
      enterOuterAlt(_localctx, 57);
      setState(1757);
      match(fugue_sqlParser::CACHE);
      setState(1759);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LAZY) {
        setState(1758);
        match(fugue_sqlParser::LAZY);
      }
      setState(1761);
      match(fugue_sqlParser::TABLE);
      setState(1762);
      multipartIdentifier();
      setState(1765);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OPTIONS) {
        setState(1763);
        match(fugue_sqlParser::OPTIONS);
        setState(1764);
        antlrcpp::downCast<CacheTableContext *>(_localctx)->options = tablePropertyList();
      }
      setState(1771);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::FILL)
        | (1ULL << fugue_sqlParser::TAKE)
        | (1ULL << fugue_sqlParser::PROCESS)
        | (1ULL << fugue_sqlParser::ZIP)
        | (1ULL << fugue_sqlParser::SAVE)
        | (1ULL << fugue_sqlParser::CONNECT)
        | (1ULL << fugue_sqlParser::SAMPLE)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 94) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 94)) & ((1ULL << (fugue_sqlParser::CREATE - 94))
        | (1ULL << (fugue_sqlParser::DROP - 94))
        | (1ULL << (fugue_sqlParser::FROM - 94)))) != 0) || ((((_la - 177) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 177)) & ((1ULL << (fugue_sqlParser::LOAD - 177))
        | (1ULL << (fugue_sqlParser::MAP - 177))
        | (1ULL << (fugue_sqlParser::REDUCE - 177))
        | (1ULL << (fugue_sqlParser::RENAME - 177)))) != 0) || ((((_la - 247) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 247)) & ((1ULL << (fugue_sqlParser::SELECT - 247))
        | (1ULL << (fugue_sqlParser::TABLE - 247))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 247))
        | (1ULL << (fugue_sqlParser::VALUES - 247))
        | (1ULL << (fugue_sqlParser::WITH - 247)))) != 0)) {
        setState(1768);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1767);
          match(fugue_sqlParser::AS);
        }
        setState(1770);
        query();
      }
      break;
    }

    case 58: {
      _localctx = _tracker.createInstance<fugue_sqlParser::UncacheTableContext>(_localctx);
      enterOuterAlt(_localctx, 58);
      setState(1773);
      match(fugue_sqlParser::UNCACHE);
      setState(1774);
      match(fugue_sqlParser::TABLE);
      setState(1777);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 222, _ctx)) {
      case 1: {
        setState(1775);
        match(fugue_sqlParser::IF);
        setState(1776);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1779);
      multipartIdentifier();
      break;
    }

    case 59: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ClearCacheContext>(_localctx);
      enterOuterAlt(_localctx, 59);
      setState(1780);
      match(fugue_sqlParser::CLEAR);
      setState(1781);
      match(fugue_sqlParser::CACHE);
      break;
    }

    case 60: {
      _localctx = _tracker.createInstance<fugue_sqlParser::LoadDataContext>(_localctx);
      enterOuterAlt(_localctx, 60);
      setState(1782);
      match(fugue_sqlParser::LOAD);
      setState(1783);
      match(fugue_sqlParser::DATA);
      setState(1785);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(1784);
        match(fugue_sqlParser::LOCAL);
      }
      setState(1787);
      match(fugue_sqlParser::INPATH);
      setState(1788);
      antlrcpp::downCast<LoadDataContext *>(_localctx)->path = match(fugue_sqlParser::STRING);
      setState(1790);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OVERWRITE) {
        setState(1789);
        match(fugue_sqlParser::OVERWRITE);
      }
      setState(1792);
      match(fugue_sqlParser::INTO);
      setState(1793);
      match(fugue_sqlParser::TABLE);
      setState(1794);
      multipartIdentifier();
      setState(1796);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1795);
        partitionSpec();
      }
      break;
    }

    case 61: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TruncateTableContext>(_localctx);
      enterOuterAlt(_localctx, 61);
      setState(1798);
      match(fugue_sqlParser::TRUNCATE);
      setState(1799);
      match(fugue_sqlParser::TABLE);
      setState(1800);
      multipartIdentifier();
      setState(1802);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1801);
        partitionSpec();
      }
      break;
    }

    case 62: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RepairTableContext>(_localctx);
      enterOuterAlt(_localctx, 62);
      setState(1804);
      match(fugue_sqlParser::MSCK);
      setState(1805);
      match(fugue_sqlParser::REPAIR);
      setState(1806);
      match(fugue_sqlParser::TABLE);
      setState(1807);
      multipartIdentifier();
      break;
    }

    case 63: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ManageResourceContext>(_localctx);
      enterOuterAlt(_localctx, 63);
      setState(1808);
      antlrcpp::downCast<ManageResourceContext *>(_localctx)->op = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ADD || _la == fugue_sqlParser::LIST)) {
        antlrcpp::downCast<ManageResourceContext *>(_localctx)->op = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1809);
      identifier();
      setState(1817);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 228, _ctx)) {
      case 1: {
        setState(1810);
        match(fugue_sqlParser::STRING);
        break;
      }

      case 2: {
        setState(1814);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 227, _ctx);
        while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1 + 1) {
            setState(1811);
            matchWildcard(); 
          }
          setState(1816);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 227, _ctx);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 64: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FailNativeCommandContext>(_localctx);
      enterOuterAlt(_localctx, 64);
      setState(1819);
      match(fugue_sqlParser::SET);
      setState(1820);
      match(fugue_sqlParser::ROLE);
      setState(1824);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 229, _ctx);
      while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1 + 1) {
          setState(1821);
          matchWildcard(); 
        }
        setState(1826);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 229, _ctx);
      }
      break;
    }

    case 65: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetConfigurationContext>(_localctx);
      enterOuterAlt(_localctx, 65);
      setState(1827);
      match(fugue_sqlParser::SET);
      setState(1831);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx);
      while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1 + 1) {
          setState(1828);
          matchWildcard(); 
        }
        setState(1833);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 230, _ctx);
      }
      break;
    }

    case 66: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ResetConfigurationContext>(_localctx);
      enterOuterAlt(_localctx, 66);
      setState(1834);
      match(fugue_sqlParser::RESET);
      break;
    }

    case 67: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FailNativeCommandContext>(_localctx);
      enterOuterAlt(_localctx, 67);
      setState(1835);
      unsupportedHiveNativeCommands();
      setState(1839);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 231, _ctx);
      while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1 + 1) {
          setState(1836);
          matchWildcard(); 
        }
        setState(1841);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 231, _ctx);
      }
      break;
    }

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

  return _localctx;
}

//----------------- UnsupportedHiveNativeCommandsContext ------------------------------------------------------------------

fugue_sqlParser::UnsupportedHiveNativeCommandsContext::UnsupportedHiveNativeCommandsContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::ROLE() {
  return getToken(fugue_sqlParser::ROLE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::GRANT() {
  return getToken(fugue_sqlParser::GRANT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::REVOKE() {
  return getToken(fugue_sqlParser::REVOKE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::PRINCIPALS() {
  return getToken(fugue_sqlParser::PRINCIPALS, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::ROLES() {
  return getToken(fugue_sqlParser::ROLES, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::CURRENT() {
  return getToken(fugue_sqlParser::CURRENT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::EXPORT() {
  return getToken(fugue_sqlParser::EXPORT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::IMPORT() {
  return getToken(fugue_sqlParser::IMPORT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::COMPACTIONS() {
  return getToken(fugue_sqlParser::COMPACTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::TRANSACTIONS() {
  return getToken(fugue_sqlParser::TRANSACTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::INDEXES() {
  return getToken(fugue_sqlParser::INDEXES, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::LOCKS() {
  return getToken(fugue_sqlParser::LOCKS, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::INDEX() {
  return getToken(fugue_sqlParser::INDEX, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::LOCK() {
  return getToken(fugue_sqlParser::LOCK, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::DATABASE() {
  return getToken(fugue_sqlParser::DATABASE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::UNLOCK() {
  return getToken(fugue_sqlParser::UNLOCK, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::MACRO() {
  return getToken(fugue_sqlParser::MACRO, 0);
}

fugue_sqlParser::TableIdentifierContext* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::tableIdentifier() {
  return getRuleContext<fugue_sqlParser::TableIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::CLUSTERED() {
  return getToken(fugue_sqlParser::CLUSTERED, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::SORTED() {
  return getToken(fugue_sqlParser::SORTED, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::SKEWED() {
  return getToken(fugue_sqlParser::SKEWED, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::STORED() {
  return getToken(fugue_sqlParser::STORED, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::DIRECTORIES() {
  return getToken(fugue_sqlParser::DIRECTORIES, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::LOCATION() {
  return getToken(fugue_sqlParser::LOCATION, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::EXCHANGE() {
  return getToken(fugue_sqlParser::EXCHANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::PARTITION() {
  return getToken(fugue_sqlParser::PARTITION, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::ARCHIVE() {
  return getToken(fugue_sqlParser::ARCHIVE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::UNARCHIVE() {
  return getToken(fugue_sqlParser::UNARCHIVE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::TOUCH() {
  return getToken(fugue_sqlParser::TOUCH, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::COMPACT() {
  return getToken(fugue_sqlParser::COMPACT, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::CONCATENATE() {
  return getToken(fugue_sqlParser::CONCATENATE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::FILEFORMAT() {
  return getToken(fugue_sqlParser::FILEFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::START() {
  return getToken(fugue_sqlParser::START, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::TRANSACTION() {
  return getToken(fugue_sqlParser::TRANSACTION, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::COMMIT() {
  return getToken(fugue_sqlParser::COMMIT, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::ROLLBACK() {
  return getToken(fugue_sqlParser::ROLLBACK, 0);
}

tree::TerminalNode* fugue_sqlParser::UnsupportedHiveNativeCommandsContext::DFS() {
  return getToken(fugue_sqlParser::DFS, 0);
}


size_t fugue_sqlParser::UnsupportedHiveNativeCommandsContext::getRuleIndex() const {
  return fugue_sqlParser::RuleUnsupportedHiveNativeCommands;
}


std::any fugue_sqlParser::UnsupportedHiveNativeCommandsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUnsupportedHiveNativeCommands(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::UnsupportedHiveNativeCommandsContext* fugue_sqlParser::unsupportedHiveNativeCommands() {
  UnsupportedHiveNativeCommandsContext *_localctx = _tracker.createInstance<UnsupportedHiveNativeCommandsContext>(_ctx, getState());
  enterRule(_localctx, 166, fugue_sqlParser::RuleUnsupportedHiveNativeCommands);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2012);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1844);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::CREATE);
      setState(1845);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1846);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DROP);
      setState(1847);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1848);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::GRANT);
      setState(1850);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 233, _ctx)) {
      case 1: {
        setState(1849);
        antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1852);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::REVOKE);
      setState(1854);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx)) {
      case 1: {
        setState(1853);
        antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1856);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1857);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::GRANT);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1858);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1859);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
      setState(1861);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 235, _ctx)) {
      case 1: {
        setState(1860);
        antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::GRANT);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1863);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1864);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::PRINCIPALS);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1865);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1866);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLES);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1867);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1868);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::CURRENT);
      setState(1869);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::ROLES);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1870);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::EXPORT);
      setState(1871);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1872);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::IMPORT);
      setState(1873);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1874);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1875);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::COMPACTIONS);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1876);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1877);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::CREATE);
      setState(1878);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1879);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1880);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TRANSACTIONS);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(1881);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1882);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEXES);
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(1883);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1884);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::LOCKS);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(1885);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::CREATE);
      setState(1886);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEX);
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(1887);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DROP);
      setState(1888);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEX);
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(1889);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1890);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEX);
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(1891);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::LOCK);
      setState(1892);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(1893);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::LOCK);
      setState(1894);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::DATABASE);
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(1895);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::UNLOCK);
      setState(1896);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(1897);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::UNLOCK);
      setState(1898);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::DATABASE);
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(1899);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::CREATE);
      setState(1900);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TEMPORARY);
      setState(1901);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::MACRO);
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(1902);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DROP);
      setState(1903);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TEMPORARY);
      setState(1904);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::MACRO);
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(1905);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1906);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1907);
      tableIdentifier();
      setState(1908);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1909);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::CLUSTERED);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(1911);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1912);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1913);
      tableIdentifier();
      setState(1914);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::CLUSTERED);
      setState(1915);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::BY);
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(1917);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1918);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1919);
      tableIdentifier();
      setState(1920);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1921);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::SORTED);
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(1923);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1924);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1925);
      tableIdentifier();
      setState(1926);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::SKEWED);
      setState(1927);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::BY);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(1929);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1930);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1931);
      tableIdentifier();
      setState(1932);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1933);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::SKEWED);
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(1935);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1936);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1937);
      tableIdentifier();
      setState(1938);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1939);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::STORED);
      setState(1940);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw5 = match(fugue_sqlParser::AS);
      setState(1941);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw6 = match(fugue_sqlParser::DIRECTORIES);
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(1943);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1944);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1945);
      tableIdentifier();
      setState(1946);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::SET);
      setState(1947);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::SKEWED);
      setState(1948);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw5 = match(fugue_sqlParser::LOCATION);
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(1950);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1951);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1952);
      tableIdentifier();
      setState(1953);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::EXCHANGE);
      setState(1954);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::PARTITION);
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(1956);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1957);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1958);
      tableIdentifier();
      setState(1959);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::ARCHIVE);
      setState(1960);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::PARTITION);
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(1962);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1963);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1964);
      tableIdentifier();
      setState(1965);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::UNARCHIVE);
      setState(1966);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::PARTITION);
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(1968);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1969);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1970);
      tableIdentifier();
      setState(1971);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::TOUCH);
      break;
    }

    case 37: {
      enterOuterAlt(_localctx, 37);
      setState(1973);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1974);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1975);
      tableIdentifier();
      setState(1977);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1976);
        partitionSpec();
      }
      setState(1979);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::COMPACT);
      break;
    }

    case 38: {
      enterOuterAlt(_localctx, 38);
      setState(1981);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1982);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1983);
      tableIdentifier();
      setState(1985);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1984);
        partitionSpec();
      }
      setState(1987);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::CONCATENATE);
      break;
    }

    case 39: {
      enterOuterAlt(_localctx, 39);
      setState(1989);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1990);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1991);
      tableIdentifier();
      setState(1993);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1992);
        partitionSpec();
      }
      setState(1995);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::SET);
      setState(1996);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::FILEFORMAT);
      break;
    }

    case 40: {
      enterOuterAlt(_localctx, 40);
      setState(1998);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1999);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(2000);
      tableIdentifier();
      setState(2002);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2001);
        partitionSpec();
      }
      setState(2004);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::REPLACE);
      setState(2005);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::COLUMNS);
      break;
    }

    case 41: {
      enterOuterAlt(_localctx, 41);
      setState(2007);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::START);
      setState(2008);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TRANSACTION);
      break;
    }

    case 42: {
      enterOuterAlt(_localctx, 42);
      setState(2009);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::COMMIT);
      break;
    }

    case 43: {
      enterOuterAlt(_localctx, 43);
      setState(2010);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ROLLBACK);
      break;
    }

    case 44: {
      enterOuterAlt(_localctx, 44);
      setState(2011);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DFS);
      break;
    }

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

  return _localctx;
}

//----------------- CreateTableHeaderContext ------------------------------------------------------------------

fugue_sqlParser::CreateTableHeaderContext::CreateTableHeaderContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::CreateTableHeaderContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::EXTERNAL() {
  return getToken(fugue_sqlParser::EXTERNAL, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateTableHeaderContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}


size_t fugue_sqlParser::CreateTableHeaderContext::getRuleIndex() const {
  return fugue_sqlParser::RuleCreateTableHeader;
}


std::any fugue_sqlParser::CreateTableHeaderContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateTableHeader(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::CreateTableHeaderContext* fugue_sqlParser::createTableHeader() {
  CreateTableHeaderContext *_localctx = _tracker.createInstance<CreateTableHeaderContext>(_ctx, getState());
  enterRule(_localctx, 168, fugue_sqlParser::RuleCreateTableHeader);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::TEMPORARY) {
      setState(2015);
      match(fugue_sqlParser::TEMPORARY);
    }
    setState(2019);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::EXTERNAL) {
      setState(2018);
      match(fugue_sqlParser::EXTERNAL);
    }
    setState(2021);
    match(fugue_sqlParser::TABLE);
    setState(2025);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 243, _ctx)) {
    case 1: {
      setState(2022);
      match(fugue_sqlParser::IF);
      setState(2023);
      match(fugue_sqlParser::NOT);
      setState(2024);
      match(fugue_sqlParser::EXISTS);
      break;
    }

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

  return _localctx;
}

//----------------- ReplaceTableHeaderContext ------------------------------------------------------------------

fugue_sqlParser::ReplaceTableHeaderContext::ReplaceTableHeaderContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::ReplaceTableHeaderContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::ReplaceTableHeaderContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::ReplaceTableHeaderContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ReplaceTableHeaderContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::ReplaceTableHeaderContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}


size_t fugue_sqlParser::ReplaceTableHeaderContext::getRuleIndex() const {
  return fugue_sqlParser::RuleReplaceTableHeader;
}


std::any fugue_sqlParser::ReplaceTableHeaderContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitReplaceTableHeader(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ReplaceTableHeaderContext* fugue_sqlParser::replaceTableHeader() {
  ReplaceTableHeaderContext *_localctx = _tracker.createInstance<ReplaceTableHeaderContext>(_ctx, getState());
  enterRule(_localctx, 170, fugue_sqlParser::RuleReplaceTableHeader);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::CREATE) {
      setState(2029);
      match(fugue_sqlParser::CREATE);
      setState(2030);
      match(fugue_sqlParser::OR);
    }
    setState(2033);
    match(fugue_sqlParser::REPLACE);
    setState(2034);
    match(fugue_sqlParser::TABLE);
    setState(2035);
    multipartIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BucketSpecContext ------------------------------------------------------------------

fugue_sqlParser::BucketSpecContext::BucketSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::BucketSpecContext::CLUSTERED() {
  return getToken(fugue_sqlParser::CLUSTERED, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::BucketSpecContext::BY() {
  return getTokens(fugue_sqlParser::BY);
}

tree::TerminalNode* fugue_sqlParser::BucketSpecContext::BY(size_t i) {
  return getToken(fugue_sqlParser::BY, i);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::BucketSpecContext::identifierList() {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::BucketSpecContext::INTO() {
  return getToken(fugue_sqlParser::INTO, 0);
}

tree::TerminalNode* fugue_sqlParser::BucketSpecContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::BucketSpecContext::BUCKETS() {
  return getToken(fugue_sqlParser::BUCKETS, 0);
}

tree::TerminalNode* fugue_sqlParser::BucketSpecContext::SORTED() {
  return getToken(fugue_sqlParser::SORTED, 0);
}

fugue_sqlParser::OrderedIdentifierListContext* fugue_sqlParser::BucketSpecContext::orderedIdentifierList() {
  return getRuleContext<fugue_sqlParser::OrderedIdentifierListContext>(0);
}


size_t fugue_sqlParser::BucketSpecContext::getRuleIndex() const {
  return fugue_sqlParser::RuleBucketSpec;
}


std::any fugue_sqlParser::BucketSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitBucketSpec(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::BucketSpecContext* fugue_sqlParser::bucketSpec() {
  BucketSpecContext *_localctx = _tracker.createInstance<BucketSpecContext>(_ctx, getState());
  enterRule(_localctx, 172, fugue_sqlParser::RuleBucketSpec);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2037);
    match(fugue_sqlParser::CLUSTERED);
    setState(2038);
    match(fugue_sqlParser::BY);
    setState(2039);
    identifierList();
    setState(2043);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::SORTED) {
      setState(2040);
      match(fugue_sqlParser::SORTED);
      setState(2041);
      match(fugue_sqlParser::BY);
      setState(2042);
      orderedIdentifierList();
    }
    setState(2045);
    match(fugue_sqlParser::INTO);
    setState(2046);
    match(fugue_sqlParser::INTEGER_VALUE);
    setState(2047);
    match(fugue_sqlParser::BUCKETS);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SkewSpecContext ------------------------------------------------------------------

fugue_sqlParser::SkewSpecContext::SkewSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::SkewSpecContext::SKEWED() {
  return getToken(fugue_sqlParser::SKEWED, 0);
}

tree::TerminalNode* fugue_sqlParser::SkewSpecContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::SkewSpecContext::identifierList() {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SkewSpecContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

fugue_sqlParser::ConstantListContext* fugue_sqlParser::SkewSpecContext::constantList() {
  return getRuleContext<fugue_sqlParser::ConstantListContext>(0);
}

fugue_sqlParser::NestedConstantListContext* fugue_sqlParser::SkewSpecContext::nestedConstantList() {
  return getRuleContext<fugue_sqlParser::NestedConstantListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SkewSpecContext::STORED() {
  return getToken(fugue_sqlParser::STORED, 0);
}

tree::TerminalNode* fugue_sqlParser::SkewSpecContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

tree::TerminalNode* fugue_sqlParser::SkewSpecContext::DIRECTORIES() {
  return getToken(fugue_sqlParser::DIRECTORIES, 0);
}


size_t fugue_sqlParser::SkewSpecContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSkewSpec;
}


std::any fugue_sqlParser::SkewSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSkewSpec(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SkewSpecContext* fugue_sqlParser::skewSpec() {
  SkewSpecContext *_localctx = _tracker.createInstance<SkewSpecContext>(_ctx, getState());
  enterRule(_localctx, 174, fugue_sqlParser::RuleSkewSpec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2049);
    match(fugue_sqlParser::SKEWED);
    setState(2050);
    match(fugue_sqlParser::BY);
    setState(2051);
    identifierList();
    setState(2052);
    match(fugue_sqlParser::ON);
    setState(2055);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 246, _ctx)) {
    case 1: {
      setState(2053);
      constantList();
      break;
    }

    case 2: {
      setState(2054);
      nestedConstantList();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 247, _ctx)) {
    case 1: {
      setState(2057);
      match(fugue_sqlParser::STORED);
      setState(2058);
      match(fugue_sqlParser::AS);
      setState(2059);
      match(fugue_sqlParser::DIRECTORIES);
      break;
    }

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

  return _localctx;
}

//----------------- LocationSpecContext ------------------------------------------------------------------

fugue_sqlParser::LocationSpecContext::LocationSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::LocationSpecContext::LOCATION() {
  return getToken(fugue_sqlParser::LOCATION, 0);
}

tree::TerminalNode* fugue_sqlParser::LocationSpecContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::LocationSpecContext::getRuleIndex() const {
  return fugue_sqlParser::RuleLocationSpec;
}


std::any fugue_sqlParser::LocationSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLocationSpec(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::locationSpec() {
  LocationSpecContext *_localctx = _tracker.createInstance<LocationSpecContext>(_ctx, getState());
  enterRule(_localctx, 176, fugue_sqlParser::RuleLocationSpec);

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

  return _localctx;
}

//----------------- CommentSpecContext ------------------------------------------------------------------

fugue_sqlParser::CommentSpecContext::CommentSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::CommentSpecContext::COMMENT() {
  return getToken(fugue_sqlParser::COMMENT, 0);
}

tree::TerminalNode* fugue_sqlParser::CommentSpecContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::CommentSpecContext::getRuleIndex() const {
  return fugue_sqlParser::RuleCommentSpec;
}


std::any fugue_sqlParser::CommentSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCommentSpec(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::commentSpec() {
  CommentSpecContext *_localctx = _tracker.createInstance<CommentSpecContext>(_ctx, getState());
  enterRule(_localctx, 178, fugue_sqlParser::RuleCommentSpec);

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

  return _localctx;
}

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

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

fugue_sqlParser::QueryTermContext* fugue_sqlParser::QueryContext::queryTerm() {
  return getRuleContext<fugue_sqlParser::QueryTermContext>(0);
}

fugue_sqlParser::QueryOrganizationContext* fugue_sqlParser::QueryContext::queryOrganization() {
  return getRuleContext<fugue_sqlParser::QueryOrganizationContext>(0);
}

fugue_sqlParser::FugueSqlEngineContext* fugue_sqlParser::QueryContext::fugueSqlEngine() {
  return getRuleContext<fugue_sqlParser::FugueSqlEngineContext>(0);
}

fugue_sqlParser::CtesContext* fugue_sqlParser::QueryContext::ctes() {
  return getRuleContext<fugue_sqlParser::CtesContext>(0);
}


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


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

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

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::CONNECT) {
      setState(2068);
      fugueSqlEngine();
    }
    setState(2072);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::WITH) {
      setState(2071);
      ctes();
    }
    setState(2074);
    queryTerm(0);
    setState(2075);
    queryOrganization();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- InsertIntoContext ------------------------------------------------------------------

fugue_sqlParser::InsertIntoContext::InsertIntoContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::InsertIntoContext::getRuleIndex() const {
  return fugue_sqlParser::RuleInsertInto;
}

void fugue_sqlParser::InsertIntoContext::copyFrom(InsertIntoContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- InsertOverwriteHiveDirContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::InsertOverwriteHiveDirContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteHiveDirContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteHiveDirContext::DIRECTORY() {
  return getToken(fugue_sqlParser::DIRECTORY, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteHiveDirContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteHiveDirContext::LOCAL() {
  return getToken(fugue_sqlParser::LOCAL, 0);
}

fugue_sqlParser::RowFormatContext* fugue_sqlParser::InsertOverwriteHiveDirContext::rowFormat() {
  return getRuleContext<fugue_sqlParser::RowFormatContext>(0);
}

fugue_sqlParser::CreateFileFormatContext* fugue_sqlParser::InsertOverwriteHiveDirContext::createFileFormat() {
  return getRuleContext<fugue_sqlParser::CreateFileFormatContext>(0);
}

fugue_sqlParser::InsertOverwriteHiveDirContext::InsertOverwriteHiveDirContext(InsertIntoContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::InsertOverwriteHiveDirContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInsertOverwriteHiveDir(this);
  else
    return visitor->visitChildren(this);
}
//----------------- InsertOverwriteDirContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::InsertOverwriteDirContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteDirContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteDirContext::DIRECTORY() {
  return getToken(fugue_sqlParser::DIRECTORY, 0);
}

fugue_sqlParser::TableProviderContext* fugue_sqlParser::InsertOverwriteDirContext::tableProvider() {
  return getRuleContext<fugue_sqlParser::TableProviderContext>(0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteDirContext::LOCAL() {
  return getToken(fugue_sqlParser::LOCAL, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteDirContext::OPTIONS() {
  return getToken(fugue_sqlParser::OPTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteDirContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::InsertOverwriteDirContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

fugue_sqlParser::InsertOverwriteDirContext::InsertOverwriteDirContext(InsertIntoContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::InsertOverwriteDirContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInsertOverwriteDir(this);
  else
    return visitor->visitChildren(this);
}
//----------------- InsertOverwriteTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::InsertOverwriteTableContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteTableContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::InsertOverwriteTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::InsertOverwriteTableContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteTableContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteTableContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertOverwriteTableContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::InsertOverwriteTableContext::InsertOverwriteTableContext(InsertIntoContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::InsertOverwriteTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInsertOverwriteTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- InsertIntoTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::InsertIntoTableContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertIntoTableContext::INTO() {
  return getToken(fugue_sqlParser::INTO, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::InsertIntoTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::InsertIntoTableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::InsertIntoTableContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

tree::TerminalNode* fugue_sqlParser::InsertIntoTableContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertIntoTableContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::InsertIntoTableContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::InsertIntoTableContext::InsertIntoTableContext(InsertIntoContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::InsertIntoTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInsertIntoTable(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::InsertIntoContext* fugue_sqlParser::insertInto() {
  InsertIntoContext *_localctx = _tracker.createInstance<InsertIntoContext>(_ctx, getState());
  enterRule(_localctx, 182, fugue_sqlParser::RuleInsertInto);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2132);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 262, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertOverwriteTableContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2077);
      match(fugue_sqlParser::INSERT);
      setState(2078);
      match(fugue_sqlParser::OVERWRITE);
      setState(2080);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 250, _ctx)) {
      case 1: {
        setState(2079);
        match(fugue_sqlParser::TABLE);
        break;
      }

      default:
        break;
      }
      setState(2082);
      multipartIdentifier();
      setState(2089);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2083);
        partitionSpec();
        setState(2087);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::IF) {
          setState(2084);
          match(fugue_sqlParser::IF);
          setState(2085);
          match(fugue_sqlParser::NOT);
          setState(2086);
          match(fugue_sqlParser::EXISTS);
        }
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertIntoTableContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2091);
      match(fugue_sqlParser::INSERT);
      setState(2092);
      match(fugue_sqlParser::INTO);
      setState(2094);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 253, _ctx)) {
      case 1: {
        setState(2093);
        match(fugue_sqlParser::TABLE);
        break;
      }

      default:
        break;
      }
      setState(2096);
      multipartIdentifier();
      setState(2098);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2097);
        partitionSpec();
      }
      setState(2103);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(2100);
        match(fugue_sqlParser::IF);
        setState(2101);
        match(fugue_sqlParser::NOT);
        setState(2102);
        match(fugue_sqlParser::EXISTS);
      }
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertOverwriteHiveDirContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(2105);
      match(fugue_sqlParser::INSERT);
      setState(2106);
      match(fugue_sqlParser::OVERWRITE);
      setState(2108);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(2107);
        match(fugue_sqlParser::LOCAL);
      }
      setState(2110);
      match(fugue_sqlParser::DIRECTORY);
      setState(2111);
      antlrcpp::downCast<InsertOverwriteHiveDirContext *>(_localctx)->path = match(fugue_sqlParser::STRING);
      setState(2113);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ROW) {
        setState(2112);
        rowFormat();
      }
      setState(2116);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STORED) {
        setState(2115);
        createFileFormat();
      }
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertOverwriteDirContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(2118);
      match(fugue_sqlParser::INSERT);
      setState(2119);
      match(fugue_sqlParser::OVERWRITE);
      setState(2121);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(2120);
        match(fugue_sqlParser::LOCAL);
      }
      setState(2123);
      match(fugue_sqlParser::DIRECTORY);
      setState(2125);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STRING) {
        setState(2124);
        antlrcpp::downCast<InsertOverwriteDirContext *>(_localctx)->path = match(fugue_sqlParser::STRING);
      }
      setState(2127);
      tableProvider();
      setState(2130);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OPTIONS) {
        setState(2128);
        match(fugue_sqlParser::OPTIONS);
        setState(2129);
        antlrcpp::downCast<InsertOverwriteDirContext *>(_localctx)->options = tablePropertyList();
      }
      break;
    }

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

  return _localctx;
}

//----------------- PartitionSpecLocationContext ------------------------------------------------------------------

fugue_sqlParser::PartitionSpecLocationContext::PartitionSpecLocationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::PartitionSpecLocationContext::partitionSpec() {
  return getRuleContext<fugue_sqlParser::PartitionSpecContext>(0);
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::PartitionSpecLocationContext::locationSpec() {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(0);
}


size_t fugue_sqlParser::PartitionSpecLocationContext::getRuleIndex() const {
  return fugue_sqlParser::RulePartitionSpecLocation;
}


std::any fugue_sqlParser::PartitionSpecLocationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPartitionSpecLocation(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PartitionSpecLocationContext* fugue_sqlParser::partitionSpecLocation() {
  PartitionSpecLocationContext *_localctx = _tracker.createInstance<PartitionSpecLocationContext>(_ctx, getState());
  enterRule(_localctx, 184, fugue_sqlParser::RulePartitionSpecLocation);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::LOCATION) {
      setState(2135);
      locationSpec();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionSpecContext ------------------------------------------------------------------

fugue_sqlParser::PartitionSpecContext::PartitionSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::PartitionSpecContext::PARTITION() {
  return getToken(fugue_sqlParser::PARTITION, 0);
}

std::vector<fugue_sqlParser::PartitionValContext *> fugue_sqlParser::PartitionSpecContext::partitionVal() {
  return getRuleContexts<fugue_sqlParser::PartitionValContext>();
}

fugue_sqlParser::PartitionValContext* fugue_sqlParser::PartitionSpecContext::partitionVal(size_t i) {
  return getRuleContext<fugue_sqlParser::PartitionValContext>(i);
}


size_t fugue_sqlParser::PartitionSpecContext::getRuleIndex() const {
  return fugue_sqlParser::RulePartitionSpec;
}


std::any fugue_sqlParser::PartitionSpecContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPartitionSpec(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PartitionSpecContext* fugue_sqlParser::partitionSpec() {
  PartitionSpecContext *_localctx = _tracker.createInstance<PartitionSpecContext>(_ctx, getState());
  enterRule(_localctx, 186, fugue_sqlParser::RulePartitionSpec);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2138);
    match(fugue_sqlParser::PARTITION);
    setState(2139);
    match(fugue_sqlParser::T__2);
    setState(2140);
    partitionVal();
    setState(2145);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2141);
      match(fugue_sqlParser::T__0);
      setState(2142);
      partitionVal();
      setState(2147);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2148);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PartitionValContext ------------------------------------------------------------------

fugue_sqlParser::PartitionValContext::PartitionValContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::PartitionValContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::PartitionValContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}

fugue_sqlParser::ConstantContext* fugue_sqlParser::PartitionValContext::constant() {
  return getRuleContext<fugue_sqlParser::ConstantContext>(0);
}


size_t fugue_sqlParser::PartitionValContext::getRuleIndex() const {
  return fugue_sqlParser::RulePartitionVal;
}


std::any fugue_sqlParser::PartitionValContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPartitionVal(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PartitionValContext* fugue_sqlParser::partitionVal() {
  PartitionValContext *_localctx = _tracker.createInstance<PartitionValContext>(_ctx, getState());
  enterRule(_localctx, 188, fugue_sqlParser::RulePartitionVal);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::EQUAL) {
      setState(2151);
      match(fugue_sqlParser::EQUAL);
      setState(2152);
      constant();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TheNamespaceContext ------------------------------------------------------------------

fugue_sqlParser::TheNamespaceContext::TheNamespaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::TheNamespaceContext::NAMESPACE() {
  return getToken(fugue_sqlParser::NAMESPACE, 0);
}

tree::TerminalNode* fugue_sqlParser::TheNamespaceContext::DATABASE() {
  return getToken(fugue_sqlParser::DATABASE, 0);
}

tree::TerminalNode* fugue_sqlParser::TheNamespaceContext::SCHEMA() {
  return getToken(fugue_sqlParser::SCHEMA, 0);
}


size_t fugue_sqlParser::TheNamespaceContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTheNamespace;
}


std::any fugue_sqlParser::TheNamespaceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTheNamespace(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TheNamespaceContext* fugue_sqlParser::theNamespace() {
  TheNamespaceContext *_localctx = _tracker.createInstance<TheNamespaceContext>(_ctx, getState());
  enterRule(_localctx, 190, fugue_sqlParser::RuleTheNamespace);
  size_t _la = 0;

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

    || _la == fugue_sqlParser::SCHEMA)) {
    _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;
}

//----------------- DescribeFuncNameContext ------------------------------------------------------------------

fugue_sqlParser::DescribeFuncNameContext::DescribeFuncNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::DescribeFuncNameContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

tree::TerminalNode* fugue_sqlParser::DescribeFuncNameContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::ComparisonOperatorContext* fugue_sqlParser::DescribeFuncNameContext::comparisonOperator() {
  return getRuleContext<fugue_sqlParser::ComparisonOperatorContext>(0);
}

fugue_sqlParser::ArithmeticOperatorContext* fugue_sqlParser::DescribeFuncNameContext::arithmeticOperator() {
  return getRuleContext<fugue_sqlParser::ArithmeticOperatorContext>(0);
}

fugue_sqlParser::PredicateOperatorContext* fugue_sqlParser::DescribeFuncNameContext::predicateOperator() {
  return getRuleContext<fugue_sqlParser::PredicateOperatorContext>(0);
}


size_t fugue_sqlParser::DescribeFuncNameContext::getRuleIndex() const {
  return fugue_sqlParser::RuleDescribeFuncName;
}


std::any fugue_sqlParser::DescribeFuncNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDescribeFuncName(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::DescribeFuncNameContext* fugue_sqlParser::describeFuncName() {
  DescribeFuncNameContext *_localctx = _tracker.createInstance<DescribeFuncNameContext>(_ctx, getState());
  enterRule(_localctx, 192, fugue_sqlParser::RuleDescribeFuncName);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2158);
      match(fugue_sqlParser::STRING);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2159);
      comparisonOperator();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2160);
      arithmeticOperator();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2161);
      predicateOperator();
      break;
    }

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

  return _localctx;
}

//----------------- DescribeColNameContext ------------------------------------------------------------------

fugue_sqlParser::DescribeColNameContext::DescribeColNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::DescribeColNameContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::DescribeColNameContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}


size_t fugue_sqlParser::DescribeColNameContext::getRuleIndex() const {
  return fugue_sqlParser::RuleDescribeColName;
}


std::any fugue_sqlParser::DescribeColNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDescribeColName(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::DescribeColNameContext* fugue_sqlParser::describeColName() {
  DescribeColNameContext *_localctx = _tracker.createInstance<DescribeColNameContext>(_ctx, getState());
  enterRule(_localctx, 194, fugue_sqlParser::RuleDescribeColName);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2164);
    antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext = identifier();
    antlrcpp::downCast<DescribeColNameContext *>(_localctx)->nameParts.push_back(antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext);
    setState(2169);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__6) {
      setState(2165);
      match(fugue_sqlParser::T__6);
      setState(2166);
      antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext = identifier();
      antlrcpp::downCast<DescribeColNameContext *>(_localctx)->nameParts.push_back(antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext);
      setState(2171);
      _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;
}

//----------------- CtesContext ------------------------------------------------------------------

fugue_sqlParser::CtesContext::CtesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::CtesContext::WITH() {
  return getToken(fugue_sqlParser::WITH, 0);
}

std::vector<fugue_sqlParser::NamedQueryContext *> fugue_sqlParser::CtesContext::namedQuery() {
  return getRuleContexts<fugue_sqlParser::NamedQueryContext>();
}

fugue_sqlParser::NamedQueryContext* fugue_sqlParser::CtesContext::namedQuery(size_t i) {
  return getRuleContext<fugue_sqlParser::NamedQueryContext>(i);
}


size_t fugue_sqlParser::CtesContext::getRuleIndex() const {
  return fugue_sqlParser::RuleCtes;
}


std::any fugue_sqlParser::CtesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCtes(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::CtesContext* fugue_sqlParser::ctes() {
  CtesContext *_localctx = _tracker.createInstance<CtesContext>(_ctx, getState());
  enterRule(_localctx, 196, fugue_sqlParser::RuleCtes);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2172);
    match(fugue_sqlParser::WITH);
    setState(2173);
    namedQuery();
    setState(2178);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2174);
      match(fugue_sqlParser::T__0);
      setState(2175);
      namedQuery();
      setState(2180);
      _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;
}

//----------------- NamedQueryContext ------------------------------------------------------------------

fugue_sqlParser::NamedQueryContext::NamedQueryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::QueryContext* fugue_sqlParser::NamedQueryContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::NamedQueryContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::NamedQueryContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::NamedQueryContext::identifierList() {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(0);
}


size_t fugue_sqlParser::NamedQueryContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNamedQuery;
}


std::any fugue_sqlParser::NamedQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNamedQuery(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NamedQueryContext* fugue_sqlParser::namedQuery() {
  NamedQueryContext *_localctx = _tracker.createInstance<NamedQueryContext>(_ctx, getState());
  enterRule(_localctx, 198, fugue_sqlParser::RuleNamedQuery);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2181);
    antlrcpp::downCast<NamedQueryContext *>(_localctx)->name = errorCapturingIdentifier();
    setState(2183);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 269, _ctx)) {
    case 1: {
      setState(2182);
      antlrcpp::downCast<NamedQueryContext *>(_localctx)->columnAliases = identifierList();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AS) {
      setState(2185);
      match(fugue_sqlParser::AS);
    }
    setState(2188);
    match(fugue_sqlParser::T__2);
    setState(2189);
    query();
    setState(2190);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableProviderContext ------------------------------------------------------------------

fugue_sqlParser::TableProviderContext::TableProviderContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::TableProviderContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::TableProviderContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}


size_t fugue_sqlParser::TableProviderContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTableProvider;
}


std::any fugue_sqlParser::TableProviderContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableProvider(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TableProviderContext* fugue_sqlParser::tableProvider() {
  TableProviderContext *_localctx = _tracker.createInstance<TableProviderContext>(_ctx, getState());
  enterRule(_localctx, 200, fugue_sqlParser::RuleTableProvider);

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

  return _localctx;
}

//----------------- CreateTableClausesContext ------------------------------------------------------------------

fugue_sqlParser::CreateTableClausesContext::CreateTableClausesContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::BucketSpecContext *> fugue_sqlParser::CreateTableClausesContext::bucketSpec() {
  return getRuleContexts<fugue_sqlParser::BucketSpecContext>();
}

fugue_sqlParser::BucketSpecContext* fugue_sqlParser::CreateTableClausesContext::bucketSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::BucketSpecContext>(i);
}

std::vector<fugue_sqlParser::LocationSpecContext *> fugue_sqlParser::CreateTableClausesContext::locationSpec() {
  return getRuleContexts<fugue_sqlParser::LocationSpecContext>();
}

fugue_sqlParser::LocationSpecContext* fugue_sqlParser::CreateTableClausesContext::locationSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::LocationSpecContext>(i);
}

std::vector<fugue_sqlParser::CommentSpecContext *> fugue_sqlParser::CreateTableClausesContext::commentSpec() {
  return getRuleContexts<fugue_sqlParser::CommentSpecContext>();
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::CreateTableClausesContext::commentSpec(size_t i) {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateTableClausesContext::OPTIONS() {
  return getTokens(fugue_sqlParser::OPTIONS);
}

tree::TerminalNode* fugue_sqlParser::CreateTableClausesContext::OPTIONS(size_t i) {
  return getToken(fugue_sqlParser::OPTIONS, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateTableClausesContext::PARTITIONED() {
  return getTokens(fugue_sqlParser::PARTITIONED);
}

tree::TerminalNode* fugue_sqlParser::CreateTableClausesContext::PARTITIONED(size_t i) {
  return getToken(fugue_sqlParser::PARTITIONED, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateTableClausesContext::BY() {
  return getTokens(fugue_sqlParser::BY);
}

tree::TerminalNode* fugue_sqlParser::CreateTableClausesContext::BY(size_t i) {
  return getToken(fugue_sqlParser::BY, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::CreateTableClausesContext::TBLPROPERTIES() {
  return getTokens(fugue_sqlParser::TBLPROPERTIES);
}

tree::TerminalNode* fugue_sqlParser::CreateTableClausesContext::TBLPROPERTIES(size_t i) {
  return getToken(fugue_sqlParser::TBLPROPERTIES, i);
}

std::vector<fugue_sqlParser::TablePropertyListContext *> fugue_sqlParser::CreateTableClausesContext::tablePropertyList() {
  return getRuleContexts<fugue_sqlParser::TablePropertyListContext>();
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::CreateTableClausesContext::tablePropertyList(size_t i) {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(i);
}

std::vector<fugue_sqlParser::TransformListContext *> fugue_sqlParser::CreateTableClausesContext::transformList() {
  return getRuleContexts<fugue_sqlParser::TransformListContext>();
}

fugue_sqlParser::TransformListContext* fugue_sqlParser::CreateTableClausesContext::transformList(size_t i) {
  return getRuleContext<fugue_sqlParser::TransformListContext>(i);
}


size_t fugue_sqlParser::CreateTableClausesContext::getRuleIndex() const {
  return fugue_sqlParser::RuleCreateTableClauses;
}


std::any fugue_sqlParser::CreateTableClausesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateTableClauses(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::CreateTableClausesContext* fugue_sqlParser::createTableClauses() {
  CreateTableClausesContext *_localctx = _tracker.createInstance<CreateTableClausesContext>(_ctx, getState());
  enterRule(_localctx, 202, fugue_sqlParser::RuleCreateTableClauses);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2207);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::CLUSTERED

    || _la == fugue_sqlParser::COMMENT || ((((_la - 179) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 179)) & ((1ULL << (fugue_sqlParser::LOCATION - 179))
      | (1ULL << (fugue_sqlParser::OPTIONS - 179))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 179)))) != 0) || _la == fugue_sqlParser::TBLPROPERTIES) {
      setState(2205);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::OPTIONS: {
          setState(2195);
          match(fugue_sqlParser::OPTIONS);
          setState(2196);
          antlrcpp::downCast<CreateTableClausesContext *>(_localctx)->options = tablePropertyList();
          break;
        }

        case fugue_sqlParser::PARTITIONED: {
          setState(2197);
          match(fugue_sqlParser::PARTITIONED);
          setState(2198);
          match(fugue_sqlParser::BY);
          setState(2199);
          antlrcpp::downCast<CreateTableClausesContext *>(_localctx)->partitioning = transformList();
          break;
        }

        case fugue_sqlParser::CLUSTERED: {
          setState(2200);
          bucketSpec();
          break;
        }

        case fugue_sqlParser::LOCATION: {
          setState(2201);
          locationSpec();
          break;
        }

        case fugue_sqlParser::COMMENT: {
          setState(2202);
          commentSpec();
          break;
        }

        case fugue_sqlParser::TBLPROPERTIES: {
          setState(2203);
          match(fugue_sqlParser::TBLPROPERTIES);
          setState(2204);
          antlrcpp::downCast<CreateTableClausesContext *>(_localctx)->tableProps = tablePropertyList();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(2209);
      _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;
}

//----------------- TablePropertyListContext ------------------------------------------------------------------

fugue_sqlParser::TablePropertyListContext::TablePropertyListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::TablePropertyContext *> fugue_sqlParser::TablePropertyListContext::tableProperty() {
  return getRuleContexts<fugue_sqlParser::TablePropertyContext>();
}

fugue_sqlParser::TablePropertyContext* fugue_sqlParser::TablePropertyListContext::tableProperty(size_t i) {
  return getRuleContext<fugue_sqlParser::TablePropertyContext>(i);
}


size_t fugue_sqlParser::TablePropertyListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTablePropertyList;
}


std::any fugue_sqlParser::TablePropertyListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTablePropertyList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::tablePropertyList() {
  TablePropertyListContext *_localctx = _tracker.createInstance<TablePropertyListContext>(_ctx, getState());
  enterRule(_localctx, 204, fugue_sqlParser::RuleTablePropertyList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2210);
    match(fugue_sqlParser::T__2);
    setState(2211);
    tableProperty();
    setState(2216);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2212);
      match(fugue_sqlParser::T__0);
      setState(2213);
      tableProperty();
      setState(2218);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2219);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablePropertyContext ------------------------------------------------------------------

fugue_sqlParser::TablePropertyContext::TablePropertyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::TablePropertyKeyContext* fugue_sqlParser::TablePropertyContext::tablePropertyKey() {
  return getRuleContext<fugue_sqlParser::TablePropertyKeyContext>(0);
}

fugue_sqlParser::TablePropertyValueContext* fugue_sqlParser::TablePropertyContext::tablePropertyValue() {
  return getRuleContext<fugue_sqlParser::TablePropertyValueContext>(0);
}

tree::TerminalNode* fugue_sqlParser::TablePropertyContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}


size_t fugue_sqlParser::TablePropertyContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTableProperty;
}


std::any fugue_sqlParser::TablePropertyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableProperty(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TablePropertyContext* fugue_sqlParser::tableProperty() {
  TablePropertyContext *_localctx = _tracker.createInstance<TablePropertyContext>(_ctx, getState());
  enterRule(_localctx, 206, fugue_sqlParser::RuleTableProperty);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2221);
    antlrcpp::downCast<TablePropertyContext *>(_localctx)->key = tablePropertyKey();
    setState(2226);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::FALSE || ((((_la - 282) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 282)) & ((1ULL << (fugue_sqlParser::TRUE - 282))
      | (1ULL << (fugue_sqlParser::EQUAL - 282))
      | (1ULL << (fugue_sqlParser::STRING - 282))
      | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 282))
      | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 282)))) != 0)) {
      setState(2223);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::EQUAL) {
        setState(2222);
        match(fugue_sqlParser::EQUAL);
      }
      setState(2225);
      antlrcpp::downCast<TablePropertyContext *>(_localctx)->value = tablePropertyValue();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TablePropertyKeyContext ------------------------------------------------------------------

fugue_sqlParser::TablePropertyKeyContext::TablePropertyKeyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::TablePropertyKeyContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::TablePropertyKeyContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}

tree::TerminalNode* fugue_sqlParser::TablePropertyKeyContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::TablePropertyKeyContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTablePropertyKey;
}


std::any fugue_sqlParser::TablePropertyKeyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTablePropertyKey(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TablePropertyKeyContext* fugue_sqlParser::tablePropertyKey() {
  TablePropertyKeyContext *_localctx = _tracker.createInstance<TablePropertyKeyContext>(_ctx, getState());
  enterRule(_localctx, 208, fugue_sqlParser::RuleTablePropertyKey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2237);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        enterOuterAlt(_localctx, 1);
        setState(2228);
        identifier();
        setState(2233);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__6) {
          setState(2229);
          match(fugue_sqlParser::T__6);
          setState(2230);
          identifier();
          setState(2235);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 2);
        setState(2236);
        match(fugue_sqlParser::STRING);
        break;
      }

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

  return _localctx;
}

//----------------- TablePropertyValueContext ------------------------------------------------------------------

fugue_sqlParser::TablePropertyValueContext::TablePropertyValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::TablePropertyValueContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::TablePropertyValueContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

fugue_sqlParser::BooleanValueContext* fugue_sqlParser::TablePropertyValueContext::booleanValue() {
  return getRuleContext<fugue_sqlParser::BooleanValueContext>(0);
}

tree::TerminalNode* fugue_sqlParser::TablePropertyValueContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::TablePropertyValueContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTablePropertyValue;
}


std::any fugue_sqlParser::TablePropertyValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTablePropertyValue(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TablePropertyValueContext* fugue_sqlParser::tablePropertyValue() {
  TablePropertyValueContext *_localctx = _tracker.createInstance<TablePropertyValueContext>(_ctx, getState());
  enterRule(_localctx, 210, fugue_sqlParser::RuleTablePropertyValue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2243);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::INTEGER_VALUE: {
        enterOuterAlt(_localctx, 1);
        setState(2239);
        match(fugue_sqlParser::INTEGER_VALUE);
        break;
      }

      case fugue_sqlParser::DECIMAL_VALUE: {
        enterOuterAlt(_localctx, 2);
        setState(2240);
        match(fugue_sqlParser::DECIMAL_VALUE);
        break;
      }

      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::TRUE: {
        enterOuterAlt(_localctx, 3);
        setState(2241);
        booleanValue();
        break;
      }

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 4);
        setState(2242);
        match(fugue_sqlParser::STRING);
        break;
      }

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

  return _localctx;
}

//----------------- ConstantListContext ------------------------------------------------------------------

fugue_sqlParser::ConstantListContext::ConstantListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ConstantContext *> fugue_sqlParser::ConstantListContext::constant() {
  return getRuleContexts<fugue_sqlParser::ConstantContext>();
}

fugue_sqlParser::ConstantContext* fugue_sqlParser::ConstantListContext::constant(size_t i) {
  return getRuleContext<fugue_sqlParser::ConstantContext>(i);
}


size_t fugue_sqlParser::ConstantListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleConstantList;
}


std::any fugue_sqlParser::ConstantListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitConstantList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ConstantListContext* fugue_sqlParser::constantList() {
  ConstantListContext *_localctx = _tracker.createInstance<ConstantListContext>(_ctx, getState());
  enterRule(_localctx, 212, fugue_sqlParser::RuleConstantList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2245);
    match(fugue_sqlParser::T__2);
    setState(2246);
    constant();
    setState(2251);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2247);
      match(fugue_sqlParser::T__0);
      setState(2248);
      constant();
      setState(2253);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2254);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NestedConstantListContext ------------------------------------------------------------------

fugue_sqlParser::NestedConstantListContext::NestedConstantListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ConstantListContext *> fugue_sqlParser::NestedConstantListContext::constantList() {
  return getRuleContexts<fugue_sqlParser::ConstantListContext>();
}

fugue_sqlParser::ConstantListContext* fugue_sqlParser::NestedConstantListContext::constantList(size_t i) {
  return getRuleContext<fugue_sqlParser::ConstantListContext>(i);
}


size_t fugue_sqlParser::NestedConstantListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNestedConstantList;
}


std::any fugue_sqlParser::NestedConstantListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNestedConstantList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NestedConstantListContext* fugue_sqlParser::nestedConstantList() {
  NestedConstantListContext *_localctx = _tracker.createInstance<NestedConstantListContext>(_ctx, getState());
  enterRule(_localctx, 214, fugue_sqlParser::RuleNestedConstantList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2256);
    match(fugue_sqlParser::T__2);
    setState(2257);
    constantList();
    setState(2262);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2258);
      match(fugue_sqlParser::T__0);
      setState(2259);
      constantList();
      setState(2264);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2265);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CreateFileFormatContext ------------------------------------------------------------------

fugue_sqlParser::CreateFileFormatContext::CreateFileFormatContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::CreateFileFormatContext::STORED() {
  return getToken(fugue_sqlParser::STORED, 0);
}

tree::TerminalNode* fugue_sqlParser::CreateFileFormatContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::FileFormatContext* fugue_sqlParser::CreateFileFormatContext::fileFormat() {
  return getRuleContext<fugue_sqlParser::FileFormatContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CreateFileFormatContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

fugue_sqlParser::StorageHandlerContext* fugue_sqlParser::CreateFileFormatContext::storageHandler() {
  return getRuleContext<fugue_sqlParser::StorageHandlerContext>(0);
}


size_t fugue_sqlParser::CreateFileFormatContext::getRuleIndex() const {
  return fugue_sqlParser::RuleCreateFileFormat;
}


std::any fugue_sqlParser::CreateFileFormatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCreateFileFormat(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::CreateFileFormatContext* fugue_sqlParser::createFileFormat() {
  CreateFileFormatContext *_localctx = _tracker.createInstance<CreateFileFormatContext>(_ctx, getState());
  enterRule(_localctx, 216, fugue_sqlParser::RuleCreateFileFormat);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2273);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 281, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2267);
      match(fugue_sqlParser::STORED);
      setState(2268);
      match(fugue_sqlParser::AS);
      setState(2269);
      fileFormat();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2270);
      match(fugue_sqlParser::STORED);
      setState(2271);
      match(fugue_sqlParser::BY);
      setState(2272);
      storageHandler();
      break;
    }

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

  return _localctx;
}

//----------------- FileFormatContext ------------------------------------------------------------------

fugue_sqlParser::FileFormatContext::FileFormatContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::FileFormatContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFileFormat;
}

void fugue_sqlParser::FileFormatContext::copyFrom(FileFormatContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- TableFileFormatContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::TableFileFormatContext::INPUTFORMAT() {
  return getToken(fugue_sqlParser::INPUTFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::TableFileFormatContext::OUTPUTFORMAT() {
  return getToken(fugue_sqlParser::OUTPUTFORMAT, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::TableFileFormatContext::STRING() {
  return getTokens(fugue_sqlParser::STRING);
}

tree::TerminalNode* fugue_sqlParser::TableFileFormatContext::STRING(size_t i) {
  return getToken(fugue_sqlParser::STRING, i);
}

fugue_sqlParser::TableFileFormatContext::TableFileFormatContext(FileFormatContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TableFileFormatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableFileFormat(this);
  else
    return visitor->visitChildren(this);
}
//----------------- GenericFileFormatContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext* fugue_sqlParser::GenericFileFormatContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::GenericFileFormatContext::GenericFileFormatContext(FileFormatContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::GenericFileFormatContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitGenericFileFormat(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::FileFormatContext* fugue_sqlParser::fileFormat() {
  FileFormatContext *_localctx = _tracker.createInstance<FileFormatContext>(_ctx, getState());
  enterRule(_localctx, 218, fugue_sqlParser::RuleFileFormat);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2280);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 282, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TableFileFormatContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2275);
      match(fugue_sqlParser::INPUTFORMAT);
      setState(2276);
      antlrcpp::downCast<TableFileFormatContext *>(_localctx)->inFmt = match(fugue_sqlParser::STRING);
      setState(2277);
      match(fugue_sqlParser::OUTPUTFORMAT);
      setState(2278);
      antlrcpp::downCast<TableFileFormatContext *>(_localctx)->outFmt = match(fugue_sqlParser::STRING);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::GenericFileFormatContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2279);
      identifier();
      break;
    }

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

  return _localctx;
}

//----------------- StorageHandlerContext ------------------------------------------------------------------

fugue_sqlParser::StorageHandlerContext::StorageHandlerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::StorageHandlerContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::StorageHandlerContext::WITH() {
  return getToken(fugue_sqlParser::WITH, 0);
}

tree::TerminalNode* fugue_sqlParser::StorageHandlerContext::SERDEPROPERTIES() {
  return getToken(fugue_sqlParser::SERDEPROPERTIES, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::StorageHandlerContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}


size_t fugue_sqlParser::StorageHandlerContext::getRuleIndex() const {
  return fugue_sqlParser::RuleStorageHandler;
}


std::any fugue_sqlParser::StorageHandlerContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitStorageHandler(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::StorageHandlerContext* fugue_sqlParser::storageHandler() {
  StorageHandlerContext *_localctx = _tracker.createInstance<StorageHandlerContext>(_ctx, getState());
  enterRule(_localctx, 220, fugue_sqlParser::RuleStorageHandler);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 283, _ctx)) {
    case 1: {
      setState(2283);
      match(fugue_sqlParser::WITH);
      setState(2284);
      match(fugue_sqlParser::SERDEPROPERTIES);
      setState(2285);
      tablePropertyList();
      break;
    }

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

  return _localctx;
}

//----------------- ResourceContext ------------------------------------------------------------------

fugue_sqlParser::ResourceContext::ResourceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ResourceContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ResourceContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::ResourceContext::getRuleIndex() const {
  return fugue_sqlParser::RuleResource;
}


std::any fugue_sqlParser::ResourceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitResource(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ResourceContext* fugue_sqlParser::resource() {
  ResourceContext *_localctx = _tracker.createInstance<ResourceContext>(_ctx, getState());
  enterRule(_localctx, 222, fugue_sqlParser::RuleResource);

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

  return _localctx;
}

//----------------- DmlStatementNoWithContext ------------------------------------------------------------------

fugue_sqlParser::DmlStatementNoWithContext::DmlStatementNoWithContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::DmlStatementNoWithContext::getRuleIndex() const {
  return fugue_sqlParser::RuleDmlStatementNoWith;
}

void fugue_sqlParser::DmlStatementNoWithContext::copyFrom(DmlStatementNoWithContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- DeleteFromTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DeleteFromTableContext::DELETE() {
  return getToken(fugue_sqlParser::DELETE, 0);
}

tree::TerminalNode* fugue_sqlParser::DeleteFromTableContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::DeleteFromTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::DeleteFromTableContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}

fugue_sqlParser::WhereClauseContext* fugue_sqlParser::DeleteFromTableContext::whereClause() {
  return getRuleContext<fugue_sqlParser::WhereClauseContext>(0);
}

fugue_sqlParser::DeleteFromTableContext::DeleteFromTableContext(DmlStatementNoWithContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DeleteFromTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDeleteFromTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SingleInsertQueryContext ------------------------------------------------------------------

fugue_sqlParser::InsertIntoContext* fugue_sqlParser::SingleInsertQueryContext::insertInto() {
  return getRuleContext<fugue_sqlParser::InsertIntoContext>(0);
}

fugue_sqlParser::QueryTermContext* fugue_sqlParser::SingleInsertQueryContext::queryTerm() {
  return getRuleContext<fugue_sqlParser::QueryTermContext>(0);
}

fugue_sqlParser::QueryOrganizationContext* fugue_sqlParser::SingleInsertQueryContext::queryOrganization() {
  return getRuleContext<fugue_sqlParser::QueryOrganizationContext>(0);
}

fugue_sqlParser::SingleInsertQueryContext::SingleInsertQueryContext(DmlStatementNoWithContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SingleInsertQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSingleInsertQuery(this);
  else
    return visitor->visitChildren(this);
}
//----------------- MultiInsertQueryContext ------------------------------------------------------------------

fugue_sqlParser::FromClauseContext* fugue_sqlParser::MultiInsertQueryContext::fromClause() {
  return getRuleContext<fugue_sqlParser::FromClauseContext>(0);
}

std::vector<fugue_sqlParser::MultiInsertQueryBodyContext *> fugue_sqlParser::MultiInsertQueryContext::multiInsertQueryBody() {
  return getRuleContexts<fugue_sqlParser::MultiInsertQueryBodyContext>();
}

fugue_sqlParser::MultiInsertQueryBodyContext* fugue_sqlParser::MultiInsertQueryContext::multiInsertQueryBody(size_t i) {
  return getRuleContext<fugue_sqlParser::MultiInsertQueryBodyContext>(i);
}

fugue_sqlParser::MultiInsertQueryContext::MultiInsertQueryContext(DmlStatementNoWithContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::MultiInsertQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMultiInsertQuery(this);
  else
    return visitor->visitChildren(this);
}
//----------------- UpdateTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::UpdateTableContext::UPDATE() {
  return getToken(fugue_sqlParser::UPDATE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::UpdateTableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::UpdateTableContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}

fugue_sqlParser::SetClauseContext* fugue_sqlParser::UpdateTableContext::setClause() {
  return getRuleContext<fugue_sqlParser::SetClauseContext>(0);
}

fugue_sqlParser::WhereClauseContext* fugue_sqlParser::UpdateTableContext::whereClause() {
  return getRuleContext<fugue_sqlParser::WhereClauseContext>(0);
}

fugue_sqlParser::UpdateTableContext::UpdateTableContext(DmlStatementNoWithContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::UpdateTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUpdateTable(this);
  else
    return visitor->visitChildren(this);
}
//----------------- MergeIntoTableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::MergeIntoTableContext::MERGE() {
  return getToken(fugue_sqlParser::MERGE, 0);
}

tree::TerminalNode* fugue_sqlParser::MergeIntoTableContext::INTO() {
  return getToken(fugue_sqlParser::INTO, 0);
}

tree::TerminalNode* fugue_sqlParser::MergeIntoTableContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

tree::TerminalNode* fugue_sqlParser::MergeIntoTableContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::MergeIntoTableContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::MergeIntoTableContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}

std::vector<fugue_sqlParser::TableAliasContext *> fugue_sqlParser::MergeIntoTableContext::tableAlias() {
  return getRuleContexts<fugue_sqlParser::TableAliasContext>();
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::MergeIntoTableContext::tableAlias(size_t i) {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(i);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::MergeIntoTableContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::MergeIntoTableContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

std::vector<fugue_sqlParser::MatchedClauseContext *> fugue_sqlParser::MergeIntoTableContext::matchedClause() {
  return getRuleContexts<fugue_sqlParser::MatchedClauseContext>();
}

fugue_sqlParser::MatchedClauseContext* fugue_sqlParser::MergeIntoTableContext::matchedClause(size_t i) {
  return getRuleContext<fugue_sqlParser::MatchedClauseContext>(i);
}

std::vector<fugue_sqlParser::NotMatchedClauseContext *> fugue_sqlParser::MergeIntoTableContext::notMatchedClause() {
  return getRuleContexts<fugue_sqlParser::NotMatchedClauseContext>();
}

fugue_sqlParser::NotMatchedClauseContext* fugue_sqlParser::MergeIntoTableContext::notMatchedClause(size_t i) {
  return getRuleContext<fugue_sqlParser::NotMatchedClauseContext>(i);
}

fugue_sqlParser::MergeIntoTableContext::MergeIntoTableContext(DmlStatementNoWithContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::MergeIntoTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMergeIntoTable(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::DmlStatementNoWithContext* fugue_sqlParser::dmlStatementNoWith() {
  DmlStatementNoWithContext *_localctx = _tracker.createInstance<DmlStatementNoWithContext>(_ctx, getState());
  enterRule(_localctx, 224, fugue_sqlParser::RuleDmlStatementNoWith);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(2342);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::INSERT: {
        _localctx = _tracker.createInstance<fugue_sqlParser::SingleInsertQueryContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(2291);
        insertInto();
        setState(2292);
        queryTerm(0);
        setState(2293);
        queryOrganization();
        break;
      }

      case fugue_sqlParser::FROM: {
        _localctx = _tracker.createInstance<fugue_sqlParser::MultiInsertQueryContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(2295);
        fromClause();
        setState(2297); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(2296);
          multiInsertQueryBody();
          setState(2299); 
          _errHandler->sync(this);
          _la = _input->LA(1);
        } while (_la == fugue_sqlParser::INSERT);
        break;
      }

      case fugue_sqlParser::DELETE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::DeleteFromTableContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(2301);
        match(fugue_sqlParser::DELETE);
        setState(2302);
        match(fugue_sqlParser::FROM);
        setState(2303);
        multipartIdentifier();
        setState(2304);
        tableAlias();
        setState(2306);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::WHERE) {
          setState(2305);
          whereClause();
        }
        break;
      }

      case fugue_sqlParser::UPDATE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::UpdateTableContext>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(2308);
        match(fugue_sqlParser::UPDATE);
        setState(2309);
        multipartIdentifier();
        setState(2310);
        tableAlias();
        setState(2311);
        setClause();
        setState(2313);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::WHERE) {
          setState(2312);
          whereClause();
        }
        break;
      }

      case fugue_sqlParser::MERGE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::MergeIntoTableContext>(_localctx);
        enterOuterAlt(_localctx, 5);
        setState(2315);
        match(fugue_sqlParser::MERGE);
        setState(2316);
        match(fugue_sqlParser::INTO);
        setState(2317);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->target = multipartIdentifier();
        setState(2318);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->targetAlias = tableAlias();
        setState(2319);
        match(fugue_sqlParser::USING);
        setState(2325);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::ADD:
          case fugue_sqlParser::AFTER:
          case fugue_sqlParser::ALL:
          case fugue_sqlParser::ALTER:
          case fugue_sqlParser::ANALYZE:
          case fugue_sqlParser::AND:
          case fugue_sqlParser::ANTI:
          case fugue_sqlParser::ANY:
          case fugue_sqlParser::ARCHIVE:
          case fugue_sqlParser::ARRAY:
          case fugue_sqlParser::AS:
          case fugue_sqlParser::ASC:
          case fugue_sqlParser::AT:
          case fugue_sqlParser::AUTHORIZATION:
          case fugue_sqlParser::BETWEEN:
          case fugue_sqlParser::BOTH:
          case fugue_sqlParser::BUCKET:
          case fugue_sqlParser::BUCKETS:
          case fugue_sqlParser::BY:
          case fugue_sqlParser::CACHE:
          case fugue_sqlParser::CASCADE:
          case fugue_sqlParser::CASE:
          case fugue_sqlParser::CAST:
          case fugue_sqlParser::CHANGE:
          case fugue_sqlParser::CHECK:
          case fugue_sqlParser::CLEAR:
          case fugue_sqlParser::CLUSTER:
          case fugue_sqlParser::CLUSTERED:
          case fugue_sqlParser::CODEGEN:
          case fugue_sqlParser::COLLATE:
          case fugue_sqlParser::COLLECTION:
          case fugue_sqlParser::COLUMN:
          case fugue_sqlParser::COLUMNS:
          case fugue_sqlParser::COMMENT:
          case fugue_sqlParser::COMMIT:
          case fugue_sqlParser::COMPACT:
          case fugue_sqlParser::COMPACTIONS:
          case fugue_sqlParser::COMPUTE:
          case fugue_sqlParser::CONCATENATE:
          case fugue_sqlParser::CONSTRAINT:
          case fugue_sqlParser::COST:
          case fugue_sqlParser::CREATE:
          case fugue_sqlParser::CROSS:
          case fugue_sqlParser::CUBE:
          case fugue_sqlParser::CURRENT:
          case fugue_sqlParser::CURRENT_DATE:
          case fugue_sqlParser::CURRENT_TIME:
          case fugue_sqlParser::CURRENT_TIMESTAMP:
          case fugue_sqlParser::CURRENT_USER:
          case fugue_sqlParser::DATA:
          case fugue_sqlParser::DATABASE:
          case fugue_sqlParser::DATABASES:
          case fugue_sqlParser::DAY:
          case fugue_sqlParser::DBPROPERTIES:
          case fugue_sqlParser::DEFINED:
          case fugue_sqlParser::DELETE:
          case fugue_sqlParser::DELIMITED:
          case fugue_sqlParser::DESC:
          case fugue_sqlParser::DESCRIBE:
          case fugue_sqlParser::DFS:
          case fugue_sqlParser::DIRECTORIES:
          case fugue_sqlParser::DIRECTORY:
          case fugue_sqlParser::DISTINCT:
          case fugue_sqlParser::DISTRIBUTE:
          case fugue_sqlParser::DROP:
          case fugue_sqlParser::ELSE:
          case fugue_sqlParser::END:
          case fugue_sqlParser::ESCAPE:
          case fugue_sqlParser::ESCAPED:
          case fugue_sqlParser::EXCEPT:
          case fugue_sqlParser::EXCHANGE:
          case fugue_sqlParser::EXISTS:
          case fugue_sqlParser::EXPLAIN:
          case fugue_sqlParser::EXPORT:
          case fugue_sqlParser::EXTENDED:
          case fugue_sqlParser::EXTERNAL:
          case fugue_sqlParser::EXTRACT:
          case fugue_sqlParser::FALSE:
          case fugue_sqlParser::FETCH:
          case fugue_sqlParser::FIELDS:
          case fugue_sqlParser::FILTER:
          case fugue_sqlParser::FILEFORMAT:
          case fugue_sqlParser::FIRST:
          case fugue_sqlParser::FOLLOWING:
          case fugue_sqlParser::FOR:
          case fugue_sqlParser::FOREIGN:
          case fugue_sqlParser::FORMAT:
          case fugue_sqlParser::FORMATTED:
          case fugue_sqlParser::FROM:
          case fugue_sqlParser::FULL:
          case fugue_sqlParser::FUNCTION:
          case fugue_sqlParser::FUNCTIONS:
          case fugue_sqlParser::GLOBAL:
          case fugue_sqlParser::GRANT:
          case fugue_sqlParser::GROUP:
          case fugue_sqlParser::GROUPING:
          case fugue_sqlParser::HAVING:
          case fugue_sqlParser::HOUR:
          case fugue_sqlParser::IF:
          case fugue_sqlParser::IGNORE:
          case fugue_sqlParser::IMPORT:
          case fugue_sqlParser::IN:
          case fugue_sqlParser::INDEX:
          case fugue_sqlParser::INDEXES:
          case fugue_sqlParser::INNER:
          case fugue_sqlParser::INPATH:
          case fugue_sqlParser::INPUTFORMAT:
          case fugue_sqlParser::INSERT:
          case fugue_sqlParser::INTERSECT:
          case fugue_sqlParser::INTERVAL:
          case fugue_sqlParser::INTO:
          case fugue_sqlParser::IS:
          case fugue_sqlParser::ITEMS:
          case fugue_sqlParser::JOIN:
          case fugue_sqlParser::KEYS:
          case fugue_sqlParser::LAST:
          case fugue_sqlParser::LATERAL:
          case fugue_sqlParser::LAZY:
          case fugue_sqlParser::LEADING:
          case fugue_sqlParser::LEFT:
          case fugue_sqlParser::LIKE:
          case fugue_sqlParser::LIMIT:
          case fugue_sqlParser::LINES:
          case fugue_sqlParser::LIST:
          case fugue_sqlParser::LOAD:
          case fugue_sqlParser::LOCAL:
          case fugue_sqlParser::LOCATION:
          case fugue_sqlParser::LOCK:
          case fugue_sqlParser::LOCKS:
          case fugue_sqlParser::LOGICAL:
          case fugue_sqlParser::MACRO:
          case fugue_sqlParser::MAP:
          case fugue_sqlParser::MATCHED:
          case fugue_sqlParser::MERGE:
          case fugue_sqlParser::MINUTE:
          case fugue_sqlParser::MONTH:
          case fugue_sqlParser::MSCK:
          case fugue_sqlParser::NAMESPACE:
          case fugue_sqlParser::NAMESPACES:
          case fugue_sqlParser::NATURAL:
          case fugue_sqlParser::NO:
          case fugue_sqlParser::NOT:
          case fugue_sqlParser::THENULL:
          case fugue_sqlParser::THENULLS:
          case fugue_sqlParser::OF:
          case fugue_sqlParser::ON:
          case fugue_sqlParser::ONLY:
          case fugue_sqlParser::OPTION:
          case fugue_sqlParser::OPTIONS:
          case fugue_sqlParser::OR:
          case fugue_sqlParser::ORDER:
          case fugue_sqlParser::OUT:
          case fugue_sqlParser::OUTER:
          case fugue_sqlParser::OUTPUTFORMAT:
          case fugue_sqlParser::OVER:
          case fugue_sqlParser::OVERLAPS:
          case fugue_sqlParser::OVERLAY:
          case fugue_sqlParser::OVERWRITE:
          case fugue_sqlParser::PARTITION:
          case fugue_sqlParser::PARTITIONED:
          case fugue_sqlParser::PARTITIONS:
          case fugue_sqlParser::PERCENTLIT:
          case fugue_sqlParser::PIVOT:
          case fugue_sqlParser::PLACING:
          case fugue_sqlParser::POSITION:
          case fugue_sqlParser::PRECEDING:
          case fugue_sqlParser::PRIMARY:
          case fugue_sqlParser::PRINCIPALS:
          case fugue_sqlParser::PROPERTIES:
          case fugue_sqlParser::PURGE:
          case fugue_sqlParser::QUERY:
          case fugue_sqlParser::RANGE:
          case fugue_sqlParser::RECORDREADER:
          case fugue_sqlParser::RECORDWRITER:
          case fugue_sqlParser::RECOVER:
          case fugue_sqlParser::REDUCE:
          case fugue_sqlParser::REFERENCES:
          case fugue_sqlParser::REFRESH:
          case fugue_sqlParser::RENAME:
          case fugue_sqlParser::REPAIR:
          case fugue_sqlParser::REPLACE:
          case fugue_sqlParser::RESET:
          case fugue_sqlParser::RESTRICT:
          case fugue_sqlParser::REVOKE:
          case fugue_sqlParser::RIGHT:
          case fugue_sqlParser::RLIKE:
          case fugue_sqlParser::ROLE:
          case fugue_sqlParser::ROLES:
          case fugue_sqlParser::ROLLBACK:
          case fugue_sqlParser::ROLLUP:
          case fugue_sqlParser::ROW:
          case fugue_sqlParser::ROWS:
          case fugue_sqlParser::SCHEMA:
          case fugue_sqlParser::SECOND:
          case fugue_sqlParser::SELECT:
          case fugue_sqlParser::SEMI:
          case fugue_sqlParser::SEPARATED:
          case fugue_sqlParser::SERDE:
          case fugue_sqlParser::SERDEPROPERTIES:
          case fugue_sqlParser::SESSION_USER:
          case fugue_sqlParser::SET:
          case fugue_sqlParser::SETMINUS:
          case fugue_sqlParser::SETS:
          case fugue_sqlParser::SHOW:
          case fugue_sqlParser::SKEWED:
          case fugue_sqlParser::SOME:
          case fugue_sqlParser::SORT:
          case fugue_sqlParser::SORTED:
          case fugue_sqlParser::START:
          case fugue_sqlParser::STATISTICS:
          case fugue_sqlParser::STORED:
          case fugue_sqlParser::STRATIFY:
          case fugue_sqlParser::STRUCT:
          case fugue_sqlParser::SUBSTR:
          case fugue_sqlParser::SUBSTRING:
          case fugue_sqlParser::TABLE:
          case fugue_sqlParser::TABLES:
          case fugue_sqlParser::TABLESAMPLE:
          case fugue_sqlParser::TBLPROPERTIES:
          case fugue_sqlParser::TEMPORARY:
          case fugue_sqlParser::TERMINATED:
          case fugue_sqlParser::THEN:
          case fugue_sqlParser::TO:
          case fugue_sqlParser::TOUCH:
          case fugue_sqlParser::TRAILING:
          case fugue_sqlParser::TRANSACTION:
          case fugue_sqlParser::TRANSACTIONS:
          case fugue_sqlParser::TRANSFORM:
          case fugue_sqlParser::TRIM:
          case fugue_sqlParser::TRUE:
          case fugue_sqlParser::TRUNCATE:
          case fugue_sqlParser::TYPE:
          case fugue_sqlParser::UNARCHIVE:
          case fugue_sqlParser::UNBOUNDED:
          case fugue_sqlParser::UNCACHE:
          case fugue_sqlParser::UNION:
          case fugue_sqlParser::UNIQUE:
          case fugue_sqlParser::UNKNOWN:
          case fugue_sqlParser::UNLOCK:
          case fugue_sqlParser::UNSET:
          case fugue_sqlParser::UPDATE:
          case fugue_sqlParser::USE:
          case fugue_sqlParser::USER:
          case fugue_sqlParser::USING:
          case fugue_sqlParser::VALUES:
          case fugue_sqlParser::VIEW:
          case fugue_sqlParser::VIEWS:
          case fugue_sqlParser::WHEN:
          case fugue_sqlParser::WHERE:
          case fugue_sqlParser::WINDOW:
          case fugue_sqlParser::WITH:
          case fugue_sqlParser::YEAR:
          case fugue_sqlParser::DIV:
          case fugue_sqlParser::IDENTIFIER:
          case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
            setState(2320);
            antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->source = multipartIdentifier();
            break;
          }

          case fugue_sqlParser::T__2: {
            setState(2321);
            match(fugue_sqlParser::T__2);
            setState(2322);
            antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->sourceQuery = query();
            setState(2323);
            match(fugue_sqlParser::T__3);
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(2327);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->sourceAlias = tableAlias();
        setState(2328);
        match(fugue_sqlParser::ON);
        setState(2329);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->mergeCondition = booleanExpression(0);
        setState(2333);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 288, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2330);
            matchedClause(); 
          }
          setState(2335);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 288, _ctx);
        }
        setState(2339);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::WHEN) {
          setState(2336);
          notMatchedClause();
          setState(2341);
          _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;
}

//----------------- QueryOrganizationContext ------------------------------------------------------------------

fugue_sqlParser::QueryOrganizationContext::QueryOrganizationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::ORDER() {
  return getToken(fugue_sqlParser::ORDER, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::QueryOrganizationContext::BY() {
  return getTokens(fugue_sqlParser::BY);
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::BY(size_t i) {
  return getToken(fugue_sqlParser::BY, i);
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::CLUSTER() {
  return getToken(fugue_sqlParser::CLUSTER, 0);
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::DISTRIBUTE() {
  return getToken(fugue_sqlParser::DISTRIBUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::SORT() {
  return getToken(fugue_sqlParser::SORT, 0);
}

fugue_sqlParser::WindowClauseContext* fugue_sqlParser::QueryOrganizationContext::windowClause() {
  return getRuleContext<fugue_sqlParser::WindowClauseContext>(0);
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::LIMIT() {
  return getToken(fugue_sqlParser::LIMIT, 0);
}

std::vector<fugue_sqlParser::SortItemContext *> fugue_sqlParser::QueryOrganizationContext::sortItem() {
  return getRuleContexts<fugue_sqlParser::SortItemContext>();
}

fugue_sqlParser::SortItemContext* fugue_sqlParser::QueryOrganizationContext::sortItem(size_t i) {
  return getRuleContext<fugue_sqlParser::SortItemContext>(i);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::QueryOrganizationContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::QueryOrganizationContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::QueryOrganizationContext::ALL() {
  return getToken(fugue_sqlParser::ALL, 0);
}


size_t fugue_sqlParser::QueryOrganizationContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQueryOrganization;
}


std::any fugue_sqlParser::QueryOrganizationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQueryOrganization(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QueryOrganizationContext* fugue_sqlParser::queryOrganization() {
  QueryOrganizationContext *_localctx = _tracker.createInstance<QueryOrganizationContext>(_ctx, getState());
  enterRule(_localctx, 226, fugue_sqlParser::RuleQueryOrganization);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 292, _ctx)) {
    case 1: {
      setState(2344);
      match(fugue_sqlParser::ORDER);
      setState(2345);
      match(fugue_sqlParser::BY);
      setState(2346);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->order.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext);
      setState(2351);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 291, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2347);
          match(fugue_sqlParser::T__0);
          setState(2348);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->order.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext); 
        }
        setState(2353);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 291, _ctx);
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 294, _ctx)) {
    case 1: {
      setState(2356);
      match(fugue_sqlParser::CLUSTER);
      setState(2357);
      match(fugue_sqlParser::BY);
      setState(2358);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->clusterBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext);
      setState(2363);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2359);
          match(fugue_sqlParser::T__0);
          setState(2360);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->clusterBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext); 
        }
        setState(2365);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx);
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 296, _ctx)) {
    case 1: {
      setState(2368);
      match(fugue_sqlParser::DISTRIBUTE);
      setState(2369);
      match(fugue_sqlParser::BY);
      setState(2370);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->distributeBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext);
      setState(2375);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 295, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2371);
          match(fugue_sqlParser::T__0);
          setState(2372);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->distributeBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext); 
        }
        setState(2377);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 295, _ctx);
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx)) {
    case 1: {
      setState(2380);
      match(fugue_sqlParser::SORT);
      setState(2381);
      match(fugue_sqlParser::BY);
      setState(2382);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sort.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext);
      setState(2387);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 297, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2383);
          match(fugue_sqlParser::T__0);
          setState(2384);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sort.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext); 
        }
        setState(2389);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 297, _ctx);
      }
      break;
    }

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx)) {
    case 1: {
      setState(2395);
      match(fugue_sqlParser::LIMIT);
      setState(2398);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 300, _ctx)) {
      case 1: {
        setState(2396);
        match(fugue_sqlParser::ALL);
        break;
      }

      case 2: {
        setState(2397);
        antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->limit = expression();
        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;
}

//----------------- MultiInsertQueryBodyContext ------------------------------------------------------------------

fugue_sqlParser::MultiInsertQueryBodyContext::MultiInsertQueryBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::InsertIntoContext* fugue_sqlParser::MultiInsertQueryBodyContext::insertInto() {
  return getRuleContext<fugue_sqlParser::InsertIntoContext>(0);
}

fugue_sqlParser::FromStatementBodyContext* fugue_sqlParser::MultiInsertQueryBodyContext::fromStatementBody() {
  return getRuleContext<fugue_sqlParser::FromStatementBodyContext>(0);
}


size_t fugue_sqlParser::MultiInsertQueryBodyContext::getRuleIndex() const {
  return fugue_sqlParser::RuleMultiInsertQueryBody;
}


std::any fugue_sqlParser::MultiInsertQueryBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMultiInsertQueryBody(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::MultiInsertQueryBodyContext* fugue_sqlParser::multiInsertQueryBody() {
  MultiInsertQueryBodyContext *_localctx = _tracker.createInstance<MultiInsertQueryBodyContext>(_ctx, getState());
  enterRule(_localctx, 228, fugue_sqlParser::RuleMultiInsertQueryBody);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2402);
    insertInto();
    setState(2403);
    fromStatementBody();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- QueryTermContext ------------------------------------------------------------------

fugue_sqlParser::QueryTermContext::QueryTermContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::QueryTermContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQueryTerm;
}

void fugue_sqlParser::QueryTermContext::copyFrom(QueryTermContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- QueryTermDefaultContext ------------------------------------------------------------------

fugue_sqlParser::QueryPrimaryContext* fugue_sqlParser::QueryTermDefaultContext::queryPrimary() {
  return getRuleContext<fugue_sqlParser::QueryPrimaryContext>(0);
}

fugue_sqlParser::QueryTermDefaultContext::QueryTermDefaultContext(QueryTermContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::QueryTermDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQueryTermDefault(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FugueTermContext ------------------------------------------------------------------

fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext* fugue_sqlParser::FugueTermContext::fugueNestableTaskCollectionNoSelect() {
  return getRuleContext<fugue_sqlParser::FugueNestableTaskCollectionNoSelectContext>(0);
}

fugue_sqlParser::FugueTermContext::FugueTermContext(QueryTermContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueTermContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueTerm(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SetOperationContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::QueryTermContext *> fugue_sqlParser::SetOperationContext::queryTerm() {
  return getRuleContexts<fugue_sqlParser::QueryTermContext>();
}

fugue_sqlParser::QueryTermContext* fugue_sqlParser::SetOperationContext::queryTerm(size_t i) {
  return getRuleContext<fugue_sqlParser::QueryTermContext>(i);
}

tree::TerminalNode* fugue_sqlParser::SetOperationContext::INTERSECT() {
  return getToken(fugue_sqlParser::INTERSECT, 0);
}

tree::TerminalNode* fugue_sqlParser::SetOperationContext::UNION() {
  return getToken(fugue_sqlParser::UNION, 0);
}

tree::TerminalNode* fugue_sqlParser::SetOperationContext::EXCEPT() {
  return getToken(fugue_sqlParser::EXCEPT, 0);
}

tree::TerminalNode* fugue_sqlParser::SetOperationContext::SETMINUS() {
  return getToken(fugue_sqlParser::SETMINUS, 0);
}

fugue_sqlParser::SetQuantifierContext* fugue_sqlParser::SetOperationContext::setQuantifier() {
  return getRuleContext<fugue_sqlParser::SetQuantifierContext>(0);
}

fugue_sqlParser::SetOperationContext::SetOperationContext(QueryTermContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SetOperationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetOperation(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QueryTermContext* fugue_sqlParser::queryTerm() {
   return queryTerm(0);
}

fugue_sqlParser::QueryTermContext* fugue_sqlParser::queryTerm(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  fugue_sqlParser::QueryTermContext *_localctx = _tracker.createInstance<QueryTermContext>(_ctx, parentState);
  fugue_sqlParser::QueryTermContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 230;
  enterRecursionRule(_localctx, 230, fugue_sqlParser::RuleQueryTerm, 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(2408);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::VALUES: {
        _localctx = _tracker.createInstance<QueryTermDefaultContext>(_localctx);
        _ctx = _localctx;
        previousContext = _localctx;

        setState(2406);
        queryPrimary();
        break;
      }

      case fugue_sqlParser::FILL:
      case fugue_sqlParser::TAKE:
      case fugue_sqlParser::PROCESS:
      case fugue_sqlParser::ZIP:
      case fugue_sqlParser::SAVE:
      case fugue_sqlParser::SAMPLE:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::TRANSFORM: {
        _localctx = _tracker.createInstance<FugueTermContext>(_localctx);
        _ctx = _localctx;
        previousContext = _localctx;
        setState(2407);
        fugueNestableTaskCollectionNoSelect();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(2430);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(2428);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 306, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<SetOperationContext>(_tracker.createInstance<QueryTermContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleQueryTerm);
          setState(2410);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(2411);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->theOperator = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == fugue_sqlParser::EXCEPT

          || _la == fugue_sqlParser::INTERSECT || _la == fugue_sqlParser::SETMINUS

          || _la == fugue_sqlParser::UNION)) {
            antlrcpp::downCast<SetOperationContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(2413);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ALL

          || _la == fugue_sqlParser::DISTINCT) {
            setState(2412);
            setQuantifier();
          }
          setState(2415);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->right = queryTerm(4);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<SetOperationContext>(_tracker.createInstance<QueryTermContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleQueryTerm);
          setState(2416);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(2417);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->theOperator = match(fugue_sqlParser::INTERSECT);
          setState(2419);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ALL

          || _la == fugue_sqlParser::DISTINCT) {
            setState(2418);
            setQuantifier();
          }
          setState(2421);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->right = queryTerm(3);
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<SetOperationContext>(_tracker.createInstance<QueryTermContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleQueryTerm);
          setState(2422);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(2423);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->theOperator = _input->LT(1);
          _la = _input->LA(1);
          if (!(_la == fugue_sqlParser::EXCEPT || _la == fugue_sqlParser::SETMINUS

          || _la == fugue_sqlParser::UNION)) {
            antlrcpp::downCast<SetOperationContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(2425);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ALL

          || _la == fugue_sqlParser::DISTINCT) {
            setState(2424);
            setQuantifier();
          }
          setState(2427);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->right = queryTerm(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(2432);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 307, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- QueryPrimaryContext ------------------------------------------------------------------

fugue_sqlParser::QueryPrimaryContext::QueryPrimaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::QueryPrimaryContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQueryPrimary;
}

void fugue_sqlParser::QueryPrimaryContext::copyFrom(QueryPrimaryContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- QueryPrimaryDefaultContext ------------------------------------------------------------------

fugue_sqlParser::QuerySpecificationContext* fugue_sqlParser::QueryPrimaryDefaultContext::querySpecification() {
  return getRuleContext<fugue_sqlParser::QuerySpecificationContext>(0);
}

fugue_sqlParser::QueryPrimaryDefaultContext::QueryPrimaryDefaultContext(QueryPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::QueryPrimaryDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQueryPrimaryDefault(this);
  else
    return visitor->visitChildren(this);
}
//----------------- InlineTableDefault1Context ------------------------------------------------------------------

fugue_sqlParser::InlineTableContext* fugue_sqlParser::InlineTableDefault1Context::inlineTable() {
  return getRuleContext<fugue_sqlParser::InlineTableContext>(0);
}

fugue_sqlParser::InlineTableDefault1Context::InlineTableDefault1Context(QueryPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::InlineTableDefault1Context::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInlineTableDefault1(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FromStmtContext ------------------------------------------------------------------

fugue_sqlParser::FromStatementContext* fugue_sqlParser::FromStmtContext::fromStatement() {
  return getRuleContext<fugue_sqlParser::FromStatementContext>(0);
}

fugue_sqlParser::FromStmtContext::FromStmtContext(QueryPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FromStmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFromStmt(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TableContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::TableContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::TableContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::TableContext::TableContext(QueryPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTable(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::QueryPrimaryContext* fugue_sqlParser::queryPrimary() {
  QueryPrimaryContext *_localctx = _tracker.createInstance<QueryPrimaryContext>(_ctx, getState());
  enterRule(_localctx, 232, fugue_sqlParser::RuleQueryPrimary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2438);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::SELECT: {
        _localctx = _tracker.createInstance<fugue_sqlParser::QueryPrimaryDefaultContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(2433);
        querySpecification();
        break;
      }

      case fugue_sqlParser::FROM: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FromStmtContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(2434);
        fromStatement();
        break;
      }

      case fugue_sqlParser::TABLE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::TableContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(2435);
        match(fugue_sqlParser::TABLE);
        setState(2436);
        multipartIdentifier();
        break;
      }

      case fugue_sqlParser::VALUES: {
        _localctx = _tracker.createInstance<fugue_sqlParser::InlineTableDefault1Context>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(2437);
        inlineTable();
        break;
      }

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

  return _localctx;
}

//----------------- SortItemContext ------------------------------------------------------------------

fugue_sqlParser::SortItemContext::SortItemContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::SortItemContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SortItemContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

tree::TerminalNode* fugue_sqlParser::SortItemContext::ASC() {
  return getToken(fugue_sqlParser::ASC, 0);
}

tree::TerminalNode* fugue_sqlParser::SortItemContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::SortItemContext::LAST() {
  return getToken(fugue_sqlParser::LAST, 0);
}

tree::TerminalNode* fugue_sqlParser::SortItemContext::FIRST() {
  return getToken(fugue_sqlParser::FIRST, 0);
}


size_t fugue_sqlParser::SortItemContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSortItem;
}


std::any fugue_sqlParser::SortItemContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSortItem(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SortItemContext* fugue_sqlParser::sortItem() {
  SortItemContext *_localctx = _tracker.createInstance<SortItemContext>(_ctx, getState());
  enterRule(_localctx, 234, fugue_sqlParser::RuleSortItem);
  size_t _la = 0;

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 309, _ctx)) {
    case 1: {
      setState(2441);
      antlrcpp::downCast<SortItemContext *>(_localctx)->ordering = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ASC

      || _la == fugue_sqlParser::DESC)) {
        antlrcpp::downCast<SortItemContext *>(_localctx)->ordering = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 310, _ctx)) {
    case 1: {
      setState(2444);
      match(fugue_sqlParser::THENULLS);
      setState(2445);
      antlrcpp::downCast<SortItemContext *>(_localctx)->nullOrder = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FIRST

      || _la == fugue_sqlParser::LAST)) {
        antlrcpp::downCast<SortItemContext *>(_localctx)->nullOrder = _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;
}

//----------------- FromStatementContext ------------------------------------------------------------------

fugue_sqlParser::FromStatementContext::FromStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FromClauseContext* fugue_sqlParser::FromStatementContext::fromClause() {
  return getRuleContext<fugue_sqlParser::FromClauseContext>(0);
}

std::vector<fugue_sqlParser::FromStatementBodyContext *> fugue_sqlParser::FromStatementContext::fromStatementBody() {
  return getRuleContexts<fugue_sqlParser::FromStatementBodyContext>();
}

fugue_sqlParser::FromStatementBodyContext* fugue_sqlParser::FromStatementContext::fromStatementBody(size_t i) {
  return getRuleContext<fugue_sqlParser::FromStatementBodyContext>(i);
}


size_t fugue_sqlParser::FromStatementContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFromStatement;
}


std::any fugue_sqlParser::FromStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFromStatement(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FromStatementContext* fugue_sqlParser::fromStatement() {
  FromStatementContext *_localctx = _tracker.createInstance<FromStatementContext>(_ctx, getState());
  enterRule(_localctx, 236, fugue_sqlParser::RuleFromStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2448);
    fromClause();
    setState(2450); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2449);
              fromStatementBody();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(2452); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _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;
}

//----------------- FromStatementBodyContext ------------------------------------------------------------------

fugue_sqlParser::FromStatementBodyContext::FromStatementBodyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::TransformClauseContext* fugue_sqlParser::FromStatementBodyContext::transformClause() {
  return getRuleContext<fugue_sqlParser::TransformClauseContext>(0);
}

fugue_sqlParser::QueryOrganizationContext* fugue_sqlParser::FromStatementBodyContext::queryOrganization() {
  return getRuleContext<fugue_sqlParser::QueryOrganizationContext>(0);
}

fugue_sqlParser::WhereClauseContext* fugue_sqlParser::FromStatementBodyContext::whereClause() {
  return getRuleContext<fugue_sqlParser::WhereClauseContext>(0);
}

fugue_sqlParser::SelectClauseContext* fugue_sqlParser::FromStatementBodyContext::selectClause() {
  return getRuleContext<fugue_sqlParser::SelectClauseContext>(0);
}

std::vector<fugue_sqlParser::LateralViewContext *> fugue_sqlParser::FromStatementBodyContext::lateralView() {
  return getRuleContexts<fugue_sqlParser::LateralViewContext>();
}

fugue_sqlParser::LateralViewContext* fugue_sqlParser::FromStatementBodyContext::lateralView(size_t i) {
  return getRuleContext<fugue_sqlParser::LateralViewContext>(i);
}

fugue_sqlParser::AggregationClauseContext* fugue_sqlParser::FromStatementBodyContext::aggregationClause() {
  return getRuleContext<fugue_sqlParser::AggregationClauseContext>(0);
}

fugue_sqlParser::HavingClauseContext* fugue_sqlParser::FromStatementBodyContext::havingClause() {
  return getRuleContext<fugue_sqlParser::HavingClauseContext>(0);
}

fugue_sqlParser::WindowClauseContext* fugue_sqlParser::FromStatementBodyContext::windowClause() {
  return getRuleContext<fugue_sqlParser::WindowClauseContext>(0);
}


size_t fugue_sqlParser::FromStatementBodyContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFromStatementBody;
}


std::any fugue_sqlParser::FromStatementBodyContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFromStatementBody(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FromStatementBodyContext* fugue_sqlParser::fromStatementBody() {
  FromStatementBodyContext *_localctx = _tracker.createInstance<FromStatementBodyContext>(_ctx, getState());
  enterRule(_localctx, 238, fugue_sqlParser::RuleFromStatementBody);

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

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

      default:
        break;
      }
      setState(2458);
      queryOrganization();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2460);
      selectClause();
      setState(2464);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2461);
          lateralView(); 
        }
        setState(2466);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 313, _ctx);
      }
      setState(2468);
      _errHandler->sync(this);

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 315, _ctx)) {
      case 1: {
        setState(2470);
        aggregationClause();
        break;
      }

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

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 317, _ctx)) {
      case 1: {
        setState(2476);
        windowClause();
        break;
      }

      default:
        break;
      }
      setState(2479);
      queryOrganization();
      break;
    }

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

  return _localctx;
}

//----------------- QuerySpecificationContext ------------------------------------------------------------------

fugue_sqlParser::QuerySpecificationContext::QuerySpecificationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::QuerySpecificationContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQuerySpecification;
}

void fugue_sqlParser::QuerySpecificationContext::copyFrom(QuerySpecificationContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- RegularQuerySpecificationContext ------------------------------------------------------------------

fugue_sqlParser::SelectClauseContext* fugue_sqlParser::RegularQuerySpecificationContext::selectClause() {
  return getRuleContext<fugue_sqlParser::SelectClauseContext>(0);
}

fugue_sqlParser::OptionalFromClauseContext* fugue_sqlParser::RegularQuerySpecificationContext::optionalFromClause() {
  return getRuleContext<fugue_sqlParser::OptionalFromClauseContext>(0);
}

std::vector<fugue_sqlParser::LateralViewContext *> fugue_sqlParser::RegularQuerySpecificationContext::lateralView() {
  return getRuleContexts<fugue_sqlParser::LateralViewContext>();
}

fugue_sqlParser::LateralViewContext* fugue_sqlParser::RegularQuerySpecificationContext::lateralView(size_t i) {
  return getRuleContext<fugue_sqlParser::LateralViewContext>(i);
}

fugue_sqlParser::WhereClauseContext* fugue_sqlParser::RegularQuerySpecificationContext::whereClause() {
  return getRuleContext<fugue_sqlParser::WhereClauseContext>(0);
}

fugue_sqlParser::AggregationClauseContext* fugue_sqlParser::RegularQuerySpecificationContext::aggregationClause() {
  return getRuleContext<fugue_sqlParser::AggregationClauseContext>(0);
}

fugue_sqlParser::HavingClauseContext* fugue_sqlParser::RegularQuerySpecificationContext::havingClause() {
  return getRuleContext<fugue_sqlParser::HavingClauseContext>(0);
}

fugue_sqlParser::WindowClauseContext* fugue_sqlParser::RegularQuerySpecificationContext::windowClause() {
  return getRuleContext<fugue_sqlParser::WindowClauseContext>(0);
}

fugue_sqlParser::RegularQuerySpecificationContext::RegularQuerySpecificationContext(QuerySpecificationContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RegularQuerySpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRegularQuerySpecification(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TransformQuerySpecificationContext ------------------------------------------------------------------

fugue_sqlParser::TransformClauseContext* fugue_sqlParser::TransformQuerySpecificationContext::transformClause() {
  return getRuleContext<fugue_sqlParser::TransformClauseContext>(0);
}

fugue_sqlParser::OptionalFromClauseContext* fugue_sqlParser::TransformQuerySpecificationContext::optionalFromClause() {
  return getRuleContext<fugue_sqlParser::OptionalFromClauseContext>(0);
}

fugue_sqlParser::WhereClauseContext* fugue_sqlParser::TransformQuerySpecificationContext::whereClause() {
  return getRuleContext<fugue_sqlParser::WhereClauseContext>(0);
}

fugue_sqlParser::TransformQuerySpecificationContext::TransformQuerySpecificationContext(QuerySpecificationContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TransformQuerySpecificationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTransformQuerySpecification(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::QuerySpecificationContext* fugue_sqlParser::querySpecification() {
  QuerySpecificationContext *_localctx = _tracker.createInstance<QuerySpecificationContext>(_ctx, getState());
  enterRule(_localctx, 240, fugue_sqlParser::RuleQuerySpecification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(2508);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 325, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TransformQuerySpecificationContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2483);
      transformClause();
      setState(2484);
      optionalFromClause();
      setState(2486);
      _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RegularQuerySpecificationContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2488);
      selectClause();
      setState(2489);
      optionalFromClause();
      setState(2493);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 320, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2490);
          lateralView(); 
        }
        setState(2495);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 320, _ctx);
      }
      setState(2497);
      _errHandler->sync(this);

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 322, _ctx)) {
      case 1: {
        setState(2499);
        aggregationClause();
        break;
      }

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

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 324, _ctx)) {
      case 1: {
        setState(2505);
        windowClause();
        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;
}

//----------------- OptionalFromClauseContext ------------------------------------------------------------------

fugue_sqlParser::OptionalFromClauseContext::OptionalFromClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::FromClauseContext* fugue_sqlParser::OptionalFromClauseContext::fromClause() {
  return getRuleContext<fugue_sqlParser::FromClauseContext>(0);
}


size_t fugue_sqlParser::OptionalFromClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleOptionalFromClause;
}


std::any fugue_sqlParser::OptionalFromClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitOptionalFromClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::OptionalFromClauseContext* fugue_sqlParser::optionalFromClause() {
  OptionalFromClauseContext *_localctx = _tracker.createInstance<OptionalFromClauseContext>(_ctx, getState());
  enterRule(_localctx, 242, fugue_sqlParser::RuleOptionalFromClause);

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

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

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

  return _localctx;
}

//----------------- TransformClauseContext ------------------------------------------------------------------

fugue_sqlParser::TransformClauseContext::TransformClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::TransformClauseContext::STRING() {
  return getTokens(fugue_sqlParser::STRING);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::STRING(size_t i) {
  return getToken(fugue_sqlParser::STRING, i);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::SELECT() {
  return getToken(fugue_sqlParser::SELECT, 0);
}

fugue_sqlParser::NamedExpressionSeqContext* fugue_sqlParser::TransformClauseContext::namedExpressionSeq() {
  return getRuleContext<fugue_sqlParser::NamedExpressionSeqContext>(0);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::TRANSFORM() {
  return getToken(fugue_sqlParser::TRANSFORM, 0);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::MAP() {
  return getToken(fugue_sqlParser::MAP, 0);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::REDUCE() {
  return getToken(fugue_sqlParser::REDUCE, 0);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::RECORDWRITER() {
  return getToken(fugue_sqlParser::RECORDWRITER, 0);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

tree::TerminalNode* fugue_sqlParser::TransformClauseContext::RECORDREADER() {
  return getToken(fugue_sqlParser::RECORDREADER, 0);
}

std::vector<fugue_sqlParser::RowFormatContext *> fugue_sqlParser::TransformClauseContext::rowFormat() {
  return getRuleContexts<fugue_sqlParser::RowFormatContext>();
}

fugue_sqlParser::RowFormatContext* fugue_sqlParser::TransformClauseContext::rowFormat(size_t i) {
  return getRuleContext<fugue_sqlParser::RowFormatContext>(i);
}

fugue_sqlParser::IdentifierSeqContext* fugue_sqlParser::TransformClauseContext::identifierSeq() {
  return getRuleContext<fugue_sqlParser::IdentifierSeqContext>(0);
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::TransformClauseContext::colTypeList() {
  return getRuleContext<fugue_sqlParser::ColTypeListContext>(0);
}


size_t fugue_sqlParser::TransformClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTransformClause;
}


std::any fugue_sqlParser::TransformClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTransformClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TransformClauseContext* fugue_sqlParser::transformClause() {
  TransformClauseContext *_localctx = _tracker.createInstance<TransformClauseContext>(_ctx, getState());
  enterRule(_localctx, 244, fugue_sqlParser::RuleTransformClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2523);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::SELECT: {
        setState(2513);
        match(fugue_sqlParser::SELECT);
        setState(2514);
        antlrcpp::downCast<TransformClauseContext *>(_localctx)->kind = match(fugue_sqlParser::TRANSFORM);
        setState(2515);
        match(fugue_sqlParser::T__2);
        setState(2516);
        namedExpressionSeq();
        setState(2517);
        match(fugue_sqlParser::T__3);
        break;
      }

      case fugue_sqlParser::MAP: {
        setState(2519);
        antlrcpp::downCast<TransformClauseContext *>(_localctx)->kind = match(fugue_sqlParser::MAP);
        setState(2520);
        namedExpressionSeq();
        break;
      }

      case fugue_sqlParser::REDUCE: {
        setState(2521);
        antlrcpp::downCast<TransformClauseContext *>(_localctx)->kind = match(fugue_sqlParser::REDUCE);
        setState(2522);
        namedExpressionSeq();
        break;
      }

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::ROW) {
      setState(2525);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->inRowFormat = rowFormat();
    }
    setState(2530);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::RECORDWRITER) {
      setState(2528);
      match(fugue_sqlParser::RECORDWRITER);
      setState(2529);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->recordWriter = match(fugue_sqlParser::STRING);
    }
    setState(2532);
    match(fugue_sqlParser::USING);
    setState(2533);
    antlrcpp::downCast<TransformClauseContext *>(_localctx)->script = match(fugue_sqlParser::STRING);
    setState(2546);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 332, _ctx)) {
    case 1: {
      setState(2534);
      match(fugue_sqlParser::AS);
      setState(2544);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 331, _ctx)) {
      case 1: {
        setState(2535);
        identifierSeq();
        break;
      }

      case 2: {
        setState(2536);
        colTypeList();
        break;
      }

      case 3: {
        setState(2537);
        match(fugue_sqlParser::T__2);
        setState(2540);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 330, _ctx)) {
        case 1: {
          setState(2538);
          identifierSeq();
          break;
        }

        case 2: {
          setState(2539);
          colTypeList();
          break;
        }

        default:
          break;
        }
        setState(2542);
        match(fugue_sqlParser::T__3);
        break;
      }

      default:
        break;
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 333, _ctx)) {
    case 1: {
      setState(2548);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->outRowFormat = rowFormat();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 334, _ctx)) {
    case 1: {
      setState(2551);
      match(fugue_sqlParser::RECORDREADER);
      setState(2552);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->recordReader = match(fugue_sqlParser::STRING);
      break;
    }

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

  return _localctx;
}

//----------------- SelectClauseContext ------------------------------------------------------------------

fugue_sqlParser::SelectClauseContext::SelectClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::SelectClauseContext::SELECT() {
  return getToken(fugue_sqlParser::SELECT, 0);
}

fugue_sqlParser::NamedExpressionSeqContext* fugue_sqlParser::SelectClauseContext::namedExpressionSeq() {
  return getRuleContext<fugue_sqlParser::NamedExpressionSeqContext>(0);
}

fugue_sqlParser::SetQuantifierContext* fugue_sqlParser::SelectClauseContext::setQuantifier() {
  return getRuleContext<fugue_sqlParser::SetQuantifierContext>(0);
}

std::vector<fugue_sqlParser::HintContext *> fugue_sqlParser::SelectClauseContext::hint() {
  return getRuleContexts<fugue_sqlParser::HintContext>();
}

fugue_sqlParser::HintContext* fugue_sqlParser::SelectClauseContext::hint(size_t i) {
  return getRuleContext<fugue_sqlParser::HintContext>(i);
}


size_t fugue_sqlParser::SelectClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSelectClause;
}


std::any fugue_sqlParser::SelectClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSelectClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SelectClauseContext* fugue_sqlParser::selectClause() {
  SelectClauseContext *_localctx = _tracker.createInstance<SelectClauseContext>(_ctx, getState());
  enterRule(_localctx, 246, fugue_sqlParser::RuleSelectClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2555);
    match(fugue_sqlParser::SELECT);
    setState(2559);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__13) {
      setState(2556);
      antlrcpp::downCast<SelectClauseContext *>(_localctx)->hintContext = hint();
      antlrcpp::downCast<SelectClauseContext *>(_localctx)->hints.push_back(antlrcpp::downCast<SelectClauseContext *>(_localctx)->hintContext);
      setState(2561);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2563);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 336, _ctx)) {
    case 1: {
      setState(2562);
      setQuantifier();
      break;
    }

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

  return _localctx;
}

//----------------- SetClauseContext ------------------------------------------------------------------

fugue_sqlParser::SetClauseContext::SetClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::SetClauseContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

fugue_sqlParser::AssignmentListContext* fugue_sqlParser::SetClauseContext::assignmentList() {
  return getRuleContext<fugue_sqlParser::AssignmentListContext>(0);
}


size_t fugue_sqlParser::SetClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSetClause;
}


std::any fugue_sqlParser::SetClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SetClauseContext* fugue_sqlParser::setClause() {
  SetClauseContext *_localctx = _tracker.createInstance<SetClauseContext>(_ctx, getState());
  enterRule(_localctx, 248, fugue_sqlParser::RuleSetClause);

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

  return _localctx;
}

//----------------- MatchedClauseContext ------------------------------------------------------------------

fugue_sqlParser::MatchedClauseContext::MatchedClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::MatchedClauseContext::WHEN() {
  return getToken(fugue_sqlParser::WHEN, 0);
}

tree::TerminalNode* fugue_sqlParser::MatchedClauseContext::MATCHED() {
  return getToken(fugue_sqlParser::MATCHED, 0);
}

tree::TerminalNode* fugue_sqlParser::MatchedClauseContext::THEN() {
  return getToken(fugue_sqlParser::THEN, 0);
}

fugue_sqlParser::MatchedActionContext* fugue_sqlParser::MatchedClauseContext::matchedAction() {
  return getRuleContext<fugue_sqlParser::MatchedActionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::MatchedClauseContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::MatchedClauseContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}


size_t fugue_sqlParser::MatchedClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleMatchedClause;
}


std::any fugue_sqlParser::MatchedClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMatchedClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::MatchedClauseContext* fugue_sqlParser::matchedClause() {
  MatchedClauseContext *_localctx = _tracker.createInstance<MatchedClauseContext>(_ctx, getState());
  enterRule(_localctx, 250, fugue_sqlParser::RuleMatchedClause);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AND) {
      setState(2572);
      match(fugue_sqlParser::AND);
      setState(2573);
      antlrcpp::downCast<MatchedClauseContext *>(_localctx)->matchedCond = booleanExpression(0);
    }
    setState(2576);
    match(fugue_sqlParser::THEN);
    setState(2577);
    matchedAction();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NotMatchedClauseContext ------------------------------------------------------------------

fugue_sqlParser::NotMatchedClauseContext::NotMatchedClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::NotMatchedClauseContext::WHEN() {
  return getToken(fugue_sqlParser::WHEN, 0);
}

tree::TerminalNode* fugue_sqlParser::NotMatchedClauseContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::NotMatchedClauseContext::MATCHED() {
  return getToken(fugue_sqlParser::MATCHED, 0);
}

tree::TerminalNode* fugue_sqlParser::NotMatchedClauseContext::THEN() {
  return getToken(fugue_sqlParser::THEN, 0);
}

fugue_sqlParser::NotMatchedActionContext* fugue_sqlParser::NotMatchedClauseContext::notMatchedAction() {
  return getRuleContext<fugue_sqlParser::NotMatchedActionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::NotMatchedClauseContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::NotMatchedClauseContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}


size_t fugue_sqlParser::NotMatchedClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNotMatchedClause;
}


std::any fugue_sqlParser::NotMatchedClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNotMatchedClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NotMatchedClauseContext* fugue_sqlParser::notMatchedClause() {
  NotMatchedClauseContext *_localctx = _tracker.createInstance<NotMatchedClauseContext>(_ctx, getState());
  enterRule(_localctx, 252, fugue_sqlParser::RuleNotMatchedClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2579);
    match(fugue_sqlParser::WHEN);
    setState(2580);
    match(fugue_sqlParser::NOT);
    setState(2581);
    match(fugue_sqlParser::MATCHED);
    setState(2584);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AND) {
      setState(2582);
      match(fugue_sqlParser::AND);
      setState(2583);
      antlrcpp::downCast<NotMatchedClauseContext *>(_localctx)->notMatchedCond = booleanExpression(0);
    }
    setState(2586);
    match(fugue_sqlParser::THEN);
    setState(2587);
    notMatchedAction();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- MatchedActionContext ------------------------------------------------------------------

fugue_sqlParser::MatchedActionContext::MatchedActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::MatchedActionContext::DELETE() {
  return getToken(fugue_sqlParser::DELETE, 0);
}

tree::TerminalNode* fugue_sqlParser::MatchedActionContext::UPDATE() {
  return getToken(fugue_sqlParser::UPDATE, 0);
}

tree::TerminalNode* fugue_sqlParser::MatchedActionContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::MatchedActionContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}

fugue_sqlParser::AssignmentListContext* fugue_sqlParser::MatchedActionContext::assignmentList() {
  return getRuleContext<fugue_sqlParser::AssignmentListContext>(0);
}


size_t fugue_sqlParser::MatchedActionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleMatchedAction;
}


std::any fugue_sqlParser::MatchedActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMatchedAction(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::MatchedActionContext* fugue_sqlParser::matchedAction() {
  MatchedActionContext *_localctx = _tracker.createInstance<MatchedActionContext>(_ctx, getState());
  enterRule(_localctx, 254, fugue_sqlParser::RuleMatchedAction);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2590);
      match(fugue_sqlParser::UPDATE);
      setState(2591);
      match(fugue_sqlParser::SET);
      setState(2592);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2593);
      match(fugue_sqlParser::UPDATE);
      setState(2594);
      match(fugue_sqlParser::SET);
      setState(2595);
      assignmentList();
      break;
    }

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

  return _localctx;
}

//----------------- NotMatchedActionContext ------------------------------------------------------------------

fugue_sqlParser::NotMatchedActionContext::NotMatchedActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::NotMatchedActionContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::NotMatchedActionContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}

tree::TerminalNode* fugue_sqlParser::NotMatchedActionContext::VALUES() {
  return getToken(fugue_sqlParser::VALUES, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::NotMatchedActionContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::NotMatchedActionContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

fugue_sqlParser::MultipartIdentifierListContext* fugue_sqlParser::NotMatchedActionContext::multipartIdentifierList() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierListContext>(0);
}


size_t fugue_sqlParser::NotMatchedActionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNotMatchedAction;
}


std::any fugue_sqlParser::NotMatchedActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNotMatchedAction(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NotMatchedActionContext* fugue_sqlParser::notMatchedAction() {
  NotMatchedActionContext *_localctx = _tracker.createInstance<NotMatchedActionContext>(_ctx, getState());
  enterRule(_localctx, 256, fugue_sqlParser::RuleNotMatchedAction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2616);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 341, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2598);
      match(fugue_sqlParser::INSERT);
      setState(2599);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2600);
      match(fugue_sqlParser::INSERT);
      setState(2601);
      match(fugue_sqlParser::T__2);
      setState(2602);
      antlrcpp::downCast<NotMatchedActionContext *>(_localctx)->columns = multipartIdentifierList();
      setState(2603);
      match(fugue_sqlParser::T__3);
      setState(2604);
      match(fugue_sqlParser::VALUES);
      setState(2605);
      match(fugue_sqlParser::T__2);
      setState(2606);
      expression();
      setState(2611);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(2607);
        match(fugue_sqlParser::T__0);
        setState(2608);
        expression();
        setState(2613);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2614);
      match(fugue_sqlParser::T__3);
      break;
    }

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

  return _localctx;
}

//----------------- AssignmentListContext ------------------------------------------------------------------

fugue_sqlParser::AssignmentListContext::AssignmentListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::AssignmentContext *> fugue_sqlParser::AssignmentListContext::assignment() {
  return getRuleContexts<fugue_sqlParser::AssignmentContext>();
}

fugue_sqlParser::AssignmentContext* fugue_sqlParser::AssignmentListContext::assignment(size_t i) {
  return getRuleContext<fugue_sqlParser::AssignmentContext>(i);
}


size_t fugue_sqlParser::AssignmentListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleAssignmentList;
}


std::any fugue_sqlParser::AssignmentListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAssignmentList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::AssignmentListContext* fugue_sqlParser::assignmentList() {
  AssignmentListContext *_localctx = _tracker.createInstance<AssignmentListContext>(_ctx, getState());
  enterRule(_localctx, 258, fugue_sqlParser::RuleAssignmentList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2618);
    assignment();
    setState(2623);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2619);
      match(fugue_sqlParser::T__0);
      setState(2620);
      assignment();
      setState(2625);
      _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;
}

//----------------- AssignmentContext ------------------------------------------------------------------

fugue_sqlParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::AssignmentContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::AssignmentContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::AssignmentContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}


size_t fugue_sqlParser::AssignmentContext::getRuleIndex() const {
  return fugue_sqlParser::RuleAssignment;
}


std::any fugue_sqlParser::AssignmentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAssignment(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::AssignmentContext* fugue_sqlParser::assignment() {
  AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());
  enterRule(_localctx, 260, fugue_sqlParser::RuleAssignment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2626);
    antlrcpp::downCast<AssignmentContext *>(_localctx)->key = multipartIdentifier();
    setState(2627);
    match(fugue_sqlParser::EQUAL);
    setState(2628);
    antlrcpp::downCast<AssignmentContext *>(_localctx)->value = expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WhereClauseContext ------------------------------------------------------------------

fugue_sqlParser::WhereClauseContext::WhereClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::WhereClauseContext::WHERE() {
  return getToken(fugue_sqlParser::WHERE, 0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::WhereClauseContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}


size_t fugue_sqlParser::WhereClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleWhereClause;
}


std::any fugue_sqlParser::WhereClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitWhereClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::WhereClauseContext* fugue_sqlParser::whereClause() {
  WhereClauseContext *_localctx = _tracker.createInstance<WhereClauseContext>(_ctx, getState());
  enterRule(_localctx, 262, fugue_sqlParser::RuleWhereClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2630);
    match(fugue_sqlParser::WHERE);
    setState(2631);
    booleanExpression(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HavingClauseContext ------------------------------------------------------------------

fugue_sqlParser::HavingClauseContext::HavingClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::HavingClauseContext::HAVING() {
  return getToken(fugue_sqlParser::HAVING, 0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::HavingClauseContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}


size_t fugue_sqlParser::HavingClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleHavingClause;
}


std::any fugue_sqlParser::HavingClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitHavingClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::HavingClauseContext* fugue_sqlParser::havingClause() {
  HavingClauseContext *_localctx = _tracker.createInstance<HavingClauseContext>(_ctx, getState());
  enterRule(_localctx, 264, fugue_sqlParser::RuleHavingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2633);
    match(fugue_sqlParser::HAVING);
    setState(2634);
    booleanExpression(0);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HintContext ------------------------------------------------------------------

fugue_sqlParser::HintContext::HintContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::HintStatementContext *> fugue_sqlParser::HintContext::hintStatement() {
  return getRuleContexts<fugue_sqlParser::HintStatementContext>();
}

fugue_sqlParser::HintStatementContext* fugue_sqlParser::HintContext::hintStatement(size_t i) {
  return getRuleContext<fugue_sqlParser::HintStatementContext>(i);
}


size_t fugue_sqlParser::HintContext::getRuleIndex() const {
  return fugue_sqlParser::RuleHint;
}


std::any fugue_sqlParser::HintContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitHint(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::HintContext* fugue_sqlParser::hint() {
  HintContext *_localctx = _tracker.createInstance<HintContext>(_ctx, getState());
  enterRule(_localctx, 266, fugue_sqlParser::RuleHint);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2636);
    match(fugue_sqlParser::T__13);
    setState(2637);
    antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext = hintStatement();
    antlrcpp::downCast<HintContext *>(_localctx)->hintStatements.push_back(antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext);
    setState(2644);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__0)
      | (1ULL << fugue_sqlParser::ADD)
      | (1ULL << fugue_sqlParser::AFTER)
      | (1ULL << fugue_sqlParser::ALL)
      | (1ULL << fugue_sqlParser::ALTER)
      | (1ULL << fugue_sqlParser::ANALYZE)
      | (1ULL << fugue_sqlParser::AND)
      | (1ULL << fugue_sqlParser::ANTI)
      | (1ULL << fugue_sqlParser::ANY)
      | (1ULL << fugue_sqlParser::ARCHIVE)
      | (1ULL << fugue_sqlParser::ARRAY)
      | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
      | (1ULL << (fugue_sqlParser::AT - 64))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
      | (1ULL << (fugue_sqlParser::BETWEEN - 64))
      | (1ULL << (fugue_sqlParser::BOTH - 64))
      | (1ULL << (fugue_sqlParser::BUCKET - 64))
      | (1ULL << (fugue_sqlParser::BUCKETS - 64))
      | (1ULL << (fugue_sqlParser::BY - 64))
      | (1ULL << (fugue_sqlParser::CACHE - 64))
      | (1ULL << (fugue_sqlParser::CASCADE - 64))
      | (1ULL << (fugue_sqlParser::CASE - 64))
      | (1ULL << (fugue_sqlParser::CAST - 64))
      | (1ULL << (fugue_sqlParser::CHANGE - 64))
      | (1ULL << (fugue_sqlParser::CHECK - 64))
      | (1ULL << (fugue_sqlParser::CLEAR - 64))
      | (1ULL << (fugue_sqlParser::CLUSTER - 64))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
      | (1ULL << (fugue_sqlParser::CODEGEN - 64))
      | (1ULL << (fugue_sqlParser::COLLATE - 64))
      | (1ULL << (fugue_sqlParser::COLLECTION - 64))
      | (1ULL << (fugue_sqlParser::COLUMN - 64))
      | (1ULL << (fugue_sqlParser::COLUMNS - 64))
      | (1ULL << (fugue_sqlParser::COMMENT - 64))
      | (1ULL << (fugue_sqlParser::COMMIT - 64))
      | (1ULL << (fugue_sqlParser::COMPACT - 64))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
      | (1ULL << (fugue_sqlParser::COMPUTE - 64))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
      | (1ULL << (fugue_sqlParser::COST - 64))
      | (1ULL << (fugue_sqlParser::CREATE - 64))
      | (1ULL << (fugue_sqlParser::CROSS - 64))
      | (1ULL << (fugue_sqlParser::CUBE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
      | (1ULL << (fugue_sqlParser::DATA - 64))
      | (1ULL << (fugue_sqlParser::DATABASE - 64))
      | (1ULL << (fugue_sqlParser::DATABASES - 64))
      | (1ULL << (fugue_sqlParser::DAY - 64))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
      | (1ULL << (fugue_sqlParser::DEFINED - 64))
      | (1ULL << (fugue_sqlParser::DELETE - 64))
      | (1ULL << (fugue_sqlParser::DELIMITED - 64))
      | (1ULL << (fugue_sqlParser::DESC - 64))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
      | (1ULL << (fugue_sqlParser::DFS - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
      | (1ULL << (fugue_sqlParser::DISTINCT - 64))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
      | (1ULL << (fugue_sqlParser::DROP - 64))
      | (1ULL << (fugue_sqlParser::ELSE - 64))
      | (1ULL << (fugue_sqlParser::END - 64))
      | (1ULL << (fugue_sqlParser::ESCAPE - 64))
      | (1ULL << (fugue_sqlParser::ESCAPED - 64))
      | (1ULL << (fugue_sqlParser::EXCEPT - 64))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
      | (1ULL << (fugue_sqlParser::EXISTS - 64))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
      | (1ULL << (fugue_sqlParser::EXPORT - 64))
      | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
      | (1ULL << (fugue_sqlParser::EXTRACT - 128))
      | (1ULL << (fugue_sqlParser::FALSE - 128))
      | (1ULL << (fugue_sqlParser::FETCH - 128))
      | (1ULL << (fugue_sqlParser::FIELDS - 128))
      | (1ULL << (fugue_sqlParser::FILTER - 128))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
      | (1ULL << (fugue_sqlParser::FIRST - 128))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
      | (1ULL << (fugue_sqlParser::FOR - 128))
      | (1ULL << (fugue_sqlParser::FOREIGN - 128))
      | (1ULL << (fugue_sqlParser::FORMAT - 128))
      | (1ULL << (fugue_sqlParser::FORMATTED - 128))
      | (1ULL << (fugue_sqlParser::FROM - 128))
      | (1ULL << (fugue_sqlParser::FULL - 128))
      | (1ULL << (fugue_sqlParser::FUNCTION - 128))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
      | (1ULL << (fugue_sqlParser::GLOBAL - 128))
      | (1ULL << (fugue_sqlParser::GRANT - 128))
      | (1ULL << (fugue_sqlParser::GROUP - 128))
      | (1ULL << (fugue_sqlParser::GROUPING - 128))
      | (1ULL << (fugue_sqlParser::HAVING - 128))
      | (1ULL << (fugue_sqlParser::HOUR - 128))
      | (1ULL << (fugue_sqlParser::IF - 128))
      | (1ULL << (fugue_sqlParser::IGNORE - 128))
      | (1ULL << (fugue_sqlParser::IMPORT - 128))
      | (1ULL << (fugue_sqlParser::IN - 128))
      | (1ULL << (fugue_sqlParser::INDEX - 128))
      | (1ULL << (fugue_sqlParser::INDEXES - 128))
      | (1ULL << (fugue_sqlParser::INNER - 128))
      | (1ULL << (fugue_sqlParser::INPATH - 128))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
      | (1ULL << (fugue_sqlParser::INSERT - 128))
      | (1ULL << (fugue_sqlParser::INTERSECT - 128))
      | (1ULL << (fugue_sqlParser::INTERVAL - 128))
      | (1ULL << (fugue_sqlParser::INTO - 128))
      | (1ULL << (fugue_sqlParser::IS - 128))
      | (1ULL << (fugue_sqlParser::ITEMS - 128))
      | (1ULL << (fugue_sqlParser::JOIN - 128))
      | (1ULL << (fugue_sqlParser::KEYS - 128))
      | (1ULL << (fugue_sqlParser::LAST - 128))
      | (1ULL << (fugue_sqlParser::LATERAL - 128))
      | (1ULL << (fugue_sqlParser::LAZY - 128))
      | (1ULL << (fugue_sqlParser::LEADING - 128))
      | (1ULL << (fugue_sqlParser::LEFT - 128))
      | (1ULL << (fugue_sqlParser::LIKE - 128))
      | (1ULL << (fugue_sqlParser::LIMIT - 128))
      | (1ULL << (fugue_sqlParser::LINES - 128))
      | (1ULL << (fugue_sqlParser::LIST - 128))
      | (1ULL << (fugue_sqlParser::LOAD - 128))
      | (1ULL << (fugue_sqlParser::LOCAL - 128))
      | (1ULL << (fugue_sqlParser::LOCATION - 128))
      | (1ULL << (fugue_sqlParser::LOCK - 128))
      | (1ULL << (fugue_sqlParser::LOCKS - 128))
      | (1ULL << (fugue_sqlParser::LOGICAL - 128))
      | (1ULL << (fugue_sqlParser::MACRO - 128))
      | (1ULL << (fugue_sqlParser::MAP - 128))
      | (1ULL << (fugue_sqlParser::MATCHED - 128))
      | (1ULL << (fugue_sqlParser::MERGE - 128))
      | (1ULL << (fugue_sqlParser::MINUTE - 128))
      | (1ULL << (fugue_sqlParser::MONTH - 128))
      | (1ULL << (fugue_sqlParser::MSCK - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
      | (1ULL << (fugue_sqlParser::NO - 192))
      | (1ULL << (fugue_sqlParser::NOT - 192))
      | (1ULL << (fugue_sqlParser::THENULL - 192))
      | (1ULL << (fugue_sqlParser::THENULLS - 192))
      | (1ULL << (fugue_sqlParser::OF - 192))
      | (1ULL << (fugue_sqlParser::ON - 192))
      | (1ULL << (fugue_sqlParser::ONLY - 192))
      | (1ULL << (fugue_sqlParser::OPTION - 192))
      | (1ULL << (fugue_sqlParser::OPTIONS - 192))
      | (1ULL << (fugue_sqlParser::OR - 192))
      | (1ULL << (fugue_sqlParser::ORDER - 192))
      | (1ULL << (fugue_sqlParser::OUT - 192))
      | (1ULL << (fugue_sqlParser::OUTER - 192))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
      | (1ULL << (fugue_sqlParser::OVER - 192))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
      | (1ULL << (fugue_sqlParser::OVERLAY - 192))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
      | (1ULL << (fugue_sqlParser::PARTITION - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
      | (1ULL << (fugue_sqlParser::PIVOT - 192))
      | (1ULL << (fugue_sqlParser::PLACING - 192))
      | (1ULL << (fugue_sqlParser::POSITION - 192))
      | (1ULL << (fugue_sqlParser::PRECEDING - 192))
      | (1ULL << (fugue_sqlParser::PRIMARY - 192))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::PURGE - 192))
      | (1ULL << (fugue_sqlParser::QUERY - 192))
      | (1ULL << (fugue_sqlParser::RANGE - 192))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
      | (1ULL << (fugue_sqlParser::RECOVER - 192))
      | (1ULL << (fugue_sqlParser::REDUCE - 192))
      | (1ULL << (fugue_sqlParser::REFERENCES - 192))
      | (1ULL << (fugue_sqlParser::REFRESH - 192))
      | (1ULL << (fugue_sqlParser::RENAME - 192))
      | (1ULL << (fugue_sqlParser::REPAIR - 192))
      | (1ULL << (fugue_sqlParser::REPLACE - 192))
      | (1ULL << (fugue_sqlParser::RESET - 192))
      | (1ULL << (fugue_sqlParser::RESTRICT - 192))
      | (1ULL << (fugue_sqlParser::REVOKE - 192))
      | (1ULL << (fugue_sqlParser::RIGHT - 192))
      | (1ULL << (fugue_sqlParser::RLIKE - 192))
      | (1ULL << (fugue_sqlParser::ROLE - 192))
      | (1ULL << (fugue_sqlParser::ROLES - 192))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
      | (1ULL << (fugue_sqlParser::ROLLUP - 192))
      | (1ULL << (fugue_sqlParser::ROW - 192))
      | (1ULL << (fugue_sqlParser::ROWS - 192))
      | (1ULL << (fugue_sqlParser::SCHEMA - 192))
      | (1ULL << (fugue_sqlParser::SECOND - 192))
      | (1ULL << (fugue_sqlParser::SELECT - 192))
      | (1ULL << (fugue_sqlParser::SEMI - 192))
      | (1ULL << (fugue_sqlParser::SEPARATED - 192))
      | (1ULL << (fugue_sqlParser::SERDE - 192))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
      | (1ULL << (fugue_sqlParser::SET - 192))
      | (1ULL << (fugue_sqlParser::SETMINUS - 192))
      | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
      | (1ULL << (fugue_sqlParser::SKEWED - 256))
      | (1ULL << (fugue_sqlParser::SOME - 256))
      | (1ULL << (fugue_sqlParser::SORT - 256))
      | (1ULL << (fugue_sqlParser::SORTED - 256))
      | (1ULL << (fugue_sqlParser::START - 256))
      | (1ULL << (fugue_sqlParser::STATISTICS - 256))
      | (1ULL << (fugue_sqlParser::STORED - 256))
      | (1ULL << (fugue_sqlParser::STRATIFY - 256))
      | (1ULL << (fugue_sqlParser::STRUCT - 256))
      | (1ULL << (fugue_sqlParser::SUBSTR - 256))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
      | (1ULL << (fugue_sqlParser::TABLE - 256))
      | (1ULL << (fugue_sqlParser::TABLES - 256))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
      | (1ULL << (fugue_sqlParser::TERMINATED - 256))
      | (1ULL << (fugue_sqlParser::THEN - 256))
      | (1ULL << (fugue_sqlParser::TO - 256))
      | (1ULL << (fugue_sqlParser::TOUCH - 256))
      | (1ULL << (fugue_sqlParser::TRAILING - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
      | (1ULL << (fugue_sqlParser::TRIM - 256))
      | (1ULL << (fugue_sqlParser::TRUE - 256))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
      | (1ULL << (fugue_sqlParser::TYPE - 256))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
      | (1ULL << (fugue_sqlParser::UNCACHE - 256))
      | (1ULL << (fugue_sqlParser::UNION - 256))
      | (1ULL << (fugue_sqlParser::UNIQUE - 256))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
      | (1ULL << (fugue_sqlParser::UNLOCK - 256))
      | (1ULL << (fugue_sqlParser::UNSET - 256))
      | (1ULL << (fugue_sqlParser::UPDATE - 256))
      | (1ULL << (fugue_sqlParser::USE - 256))
      | (1ULL << (fugue_sqlParser::USER - 256))
      | (1ULL << (fugue_sqlParser::USING - 256))
      | (1ULL << (fugue_sqlParser::VALUES - 256))
      | (1ULL << (fugue_sqlParser::VIEW - 256))
      | (1ULL << (fugue_sqlParser::VIEWS - 256))
      | (1ULL << (fugue_sqlParser::WHEN - 256))
      | (1ULL << (fugue_sqlParser::WHERE - 256))
      | (1ULL << (fugue_sqlParser::WINDOW - 256))
      | (1ULL << (fugue_sqlParser::WITH - 256))
      | (1ULL << (fugue_sqlParser::YEAR - 256))
      | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || _la == fugue_sqlParser::IDENTIFIER

    || _la == fugue_sqlParser::BACKQUOTED_IDENTIFIER) {
      setState(2639);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__0) {
        setState(2638);
        match(fugue_sqlParser::T__0);
      }
      setState(2641);
      antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext = hintStatement();
      antlrcpp::downCast<HintContext *>(_localctx)->hintStatements.push_back(antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext);
      setState(2646);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2647);
    match(fugue_sqlParser::T__14);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- HintStatementContext ------------------------------------------------------------------

fugue_sqlParser::HintStatementContext::HintStatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::HintStatementContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

std::vector<fugue_sqlParser::PrimaryExpressionContext *> fugue_sqlParser::HintStatementContext::primaryExpression() {
  return getRuleContexts<fugue_sqlParser::PrimaryExpressionContext>();
}

fugue_sqlParser::PrimaryExpressionContext* fugue_sqlParser::HintStatementContext::primaryExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::PrimaryExpressionContext>(i);
}


size_t fugue_sqlParser::HintStatementContext::getRuleIndex() const {
  return fugue_sqlParser::RuleHintStatement;
}


std::any fugue_sqlParser::HintStatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitHintStatement(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::HintStatementContext* fugue_sqlParser::hintStatement() {
  HintStatementContext *_localctx = _tracker.createInstance<HintStatementContext>(_ctx, getState());
  enterRule(_localctx, 268, fugue_sqlParser::RuleHintStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2662);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 346, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2649);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->hintName = identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2650);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->hintName = identifier();
      setState(2651);
      match(fugue_sqlParser::T__2);
      setState(2652);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext = primaryExpression(0);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->parameters.push_back(antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext);
      setState(2657);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(2653);
        match(fugue_sqlParser::T__0);
        setState(2654);
        antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext = primaryExpression(0);
        antlrcpp::downCast<HintStatementContext *>(_localctx)->parameters.push_back(antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext);
        setState(2659);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2660);
      match(fugue_sqlParser::T__3);
      break;
    }

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

  return _localctx;
}

//----------------- FromClauseContext ------------------------------------------------------------------

fugue_sqlParser::FromClauseContext::FromClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FromClauseContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

std::vector<fugue_sqlParser::RelationContext *> fugue_sqlParser::FromClauseContext::relation() {
  return getRuleContexts<fugue_sqlParser::RelationContext>();
}

fugue_sqlParser::RelationContext* fugue_sqlParser::FromClauseContext::relation(size_t i) {
  return getRuleContext<fugue_sqlParser::RelationContext>(i);
}

std::vector<fugue_sqlParser::LateralViewContext *> fugue_sqlParser::FromClauseContext::lateralView() {
  return getRuleContexts<fugue_sqlParser::LateralViewContext>();
}

fugue_sqlParser::LateralViewContext* fugue_sqlParser::FromClauseContext::lateralView(size_t i) {
  return getRuleContext<fugue_sqlParser::LateralViewContext>(i);
}

fugue_sqlParser::PivotClauseContext* fugue_sqlParser::FromClauseContext::pivotClause() {
  return getRuleContext<fugue_sqlParser::PivotClauseContext>(0);
}


size_t fugue_sqlParser::FromClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFromClause;
}


std::any fugue_sqlParser::FromClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFromClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FromClauseContext* fugue_sqlParser::fromClause() {
  FromClauseContext *_localctx = _tracker.createInstance<FromClauseContext>(_ctx, getState());
  enterRule(_localctx, 270, fugue_sqlParser::RuleFromClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2664);
    match(fugue_sqlParser::FROM);
    setState(2665);
    relation();
    setState(2670);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 347, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2666);
        match(fugue_sqlParser::T__0);
        setState(2667);
        relation(); 
      }
      setState(2672);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 347, _ctx);
    }
    setState(2676);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 348, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2673);
        lateralView(); 
      }
      setState(2678);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 348, _ctx);
    }
    setState(2680);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 349, _ctx)) {
    case 1: {
      setState(2679);
      pivotClause();
      break;
    }

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

  return _localctx;
}

//----------------- AggregationClauseContext ------------------------------------------------------------------

fugue_sqlParser::AggregationClauseContext::AggregationClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::GROUP() {
  return getToken(fugue_sqlParser::GROUP, 0);
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::AggregationClauseContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::AggregationClauseContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::WITH() {
  return getToken(fugue_sqlParser::WITH, 0);
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::SETS() {
  return getToken(fugue_sqlParser::SETS, 0);
}

std::vector<fugue_sqlParser::GroupingSetContext *> fugue_sqlParser::AggregationClauseContext::groupingSet() {
  return getRuleContexts<fugue_sqlParser::GroupingSetContext>();
}

fugue_sqlParser::GroupingSetContext* fugue_sqlParser::AggregationClauseContext::groupingSet(size_t i) {
  return getRuleContext<fugue_sqlParser::GroupingSetContext>(i);
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::ROLLUP() {
  return getToken(fugue_sqlParser::ROLLUP, 0);
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::CUBE() {
  return getToken(fugue_sqlParser::CUBE, 0);
}

tree::TerminalNode* fugue_sqlParser::AggregationClauseContext::GROUPING() {
  return getToken(fugue_sqlParser::GROUPING, 0);
}


size_t fugue_sqlParser::AggregationClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleAggregationClause;
}


std::any fugue_sqlParser::AggregationClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAggregationClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::AggregationClauseContext* fugue_sqlParser::aggregationClause() {
  AggregationClauseContext *_localctx = _tracker.createInstance<AggregationClauseContext>(_ctx, getState());
  enterRule(_localctx, 272, fugue_sqlParser::RuleAggregationClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(2726);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 354, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2682);
      match(fugue_sqlParser::GROUP);
      setState(2683);
      match(fugue_sqlParser::BY);
      setState(2684);
      antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext = expression();
      antlrcpp::downCast<AggregationClauseContext *>(_localctx)->groupingExpressions.push_back(antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext);
      setState(2689);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 350, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2685);
          match(fugue_sqlParser::T__0);
          setState(2686);
          antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<AggregationClauseContext *>(_localctx)->groupingExpressions.push_back(antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext); 
        }
        setState(2691);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 350, _ctx);
      }
      setState(2709);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 352, _ctx)) {
      case 1: {
        setState(2692);
        match(fugue_sqlParser::WITH);
        setState(2693);
        antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::ROLLUP);
        break;
      }

      case 2: {
        setState(2694);
        match(fugue_sqlParser::WITH);
        setState(2695);
        antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::CUBE);
        break;
      }

      case 3: {
        setState(2696);
        antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::GROUPING);
        setState(2697);
        match(fugue_sqlParser::SETS);
        setState(2698);
        match(fugue_sqlParser::T__2);
        setState(2699);
        groupingSet();
        setState(2704);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(2700);
          match(fugue_sqlParser::T__0);
          setState(2701);
          groupingSet();
          setState(2706);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2707);
        match(fugue_sqlParser::T__3);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2711);
      match(fugue_sqlParser::GROUP);
      setState(2712);
      match(fugue_sqlParser::BY);
      setState(2713);
      antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::GROUPING);
      setState(2714);
      match(fugue_sqlParser::SETS);
      setState(2715);
      match(fugue_sqlParser::T__2);
      setState(2716);
      groupingSet();
      setState(2721);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(2717);
        match(fugue_sqlParser::T__0);
        setState(2718);
        groupingSet();
        setState(2723);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2724);
      match(fugue_sqlParser::T__3);
      break;
    }

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

  return _localctx;
}

//----------------- GroupingSetContext ------------------------------------------------------------------

fugue_sqlParser::GroupingSetContext::GroupingSetContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::GroupingSetContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::GroupingSetContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}


size_t fugue_sqlParser::GroupingSetContext::getRuleIndex() const {
  return fugue_sqlParser::RuleGroupingSet;
}


std::any fugue_sqlParser::GroupingSetContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitGroupingSet(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::GroupingSetContext* fugue_sqlParser::groupingSet() {
  GroupingSetContext *_localctx = _tracker.createInstance<GroupingSetContext>(_ctx, getState());
  enterRule(_localctx, 274, fugue_sqlParser::RuleGroupingSet);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
        | (1ULL << fugue_sqlParser::ADD)
        | (1ULL << fugue_sqlParser::AFTER)
        | (1ULL << fugue_sqlParser::ALL)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::ANALYZE)
        | (1ULL << fugue_sqlParser::AND)
        | (1ULL << fugue_sqlParser::ANTI)
        | (1ULL << fugue_sqlParser::ANY)
        | (1ULL << fugue_sqlParser::ARCHIVE)
        | (1ULL << fugue_sqlParser::ARRAY)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
        | (1ULL << (fugue_sqlParser::AT - 64))
        | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
        | (1ULL << (fugue_sqlParser::BETWEEN - 64))
        | (1ULL << (fugue_sqlParser::BOTH - 64))
        | (1ULL << (fugue_sqlParser::BUCKET - 64))
        | (1ULL << (fugue_sqlParser::BUCKETS - 64))
        | (1ULL << (fugue_sqlParser::BY - 64))
        | (1ULL << (fugue_sqlParser::CACHE - 64))
        | (1ULL << (fugue_sqlParser::CASCADE - 64))
        | (1ULL << (fugue_sqlParser::CASE - 64))
        | (1ULL << (fugue_sqlParser::CAST - 64))
        | (1ULL << (fugue_sqlParser::CHANGE - 64))
        | (1ULL << (fugue_sqlParser::CHECK - 64))
        | (1ULL << (fugue_sqlParser::CLEAR - 64))
        | (1ULL << (fugue_sqlParser::CLUSTER - 64))
        | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
        | (1ULL << (fugue_sqlParser::CODEGEN - 64))
        | (1ULL << (fugue_sqlParser::COLLATE - 64))
        | (1ULL << (fugue_sqlParser::COLLECTION - 64))
        | (1ULL << (fugue_sqlParser::COLUMN - 64))
        | (1ULL << (fugue_sqlParser::COLUMNS - 64))
        | (1ULL << (fugue_sqlParser::COMMENT - 64))
        | (1ULL << (fugue_sqlParser::COMMIT - 64))
        | (1ULL << (fugue_sqlParser::COMPACT - 64))
        | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
        | (1ULL << (fugue_sqlParser::COMPUTE - 64))
        | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
        | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
        | (1ULL << (fugue_sqlParser::COST - 64))
        | (1ULL << (fugue_sqlParser::CREATE - 64))
        | (1ULL << (fugue_sqlParser::CROSS - 64))
        | (1ULL << (fugue_sqlParser::CUBE - 64))
        | (1ULL << (fugue_sqlParser::CURRENT - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
        | (1ULL << (fugue_sqlParser::DATA - 64))
        | (1ULL << (fugue_sqlParser::DATABASE - 64))
        | (1ULL << (fugue_sqlParser::DATABASES - 64))
        | (1ULL << (fugue_sqlParser::DAY - 64))
        | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
        | (1ULL << (fugue_sqlParser::DEFINED - 64))
        | (1ULL << (fugue_sqlParser::DELETE - 64))
        | (1ULL << (fugue_sqlParser::DELIMITED - 64))
        | (1ULL << (fugue_sqlParser::DESC - 64))
        | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
        | (1ULL << (fugue_sqlParser::DFS - 64))
        | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
        | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
        | (1ULL << (fugue_sqlParser::DISTINCT - 64))
        | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
        | (1ULL << (fugue_sqlParser::DROP - 64))
        | (1ULL << (fugue_sqlParser::ELSE - 64))
        | (1ULL << (fugue_sqlParser::END - 64))
        | (1ULL << (fugue_sqlParser::ESCAPE - 64))
        | (1ULL << (fugue_sqlParser::ESCAPED - 64))
        | (1ULL << (fugue_sqlParser::EXCEPT - 64))
        | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
        | (1ULL << (fugue_sqlParser::EXISTS - 64))
        | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
        | (1ULL << (fugue_sqlParser::EXPORT - 64))
        | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
        | (1ULL << (fugue_sqlParser::EXTRACT - 128))
        | (1ULL << (fugue_sqlParser::FALSE - 128))
        | (1ULL << (fugue_sqlParser::FETCH - 128))
        | (1ULL << (fugue_sqlParser::FIELDS - 128))
        | (1ULL << (fugue_sqlParser::FILTER - 128))
        | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
        | (1ULL << (fugue_sqlParser::FIRST - 128))
        | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
        | (1ULL << (fugue_sqlParser::FOR - 128))
        | (1ULL << (fugue_sqlParser::FOREIGN - 128))
        | (1ULL << (fugue_sqlParser::FORMAT - 128))
        | (1ULL << (fugue_sqlParser::FORMATTED - 128))
        | (1ULL << (fugue_sqlParser::FROM - 128))
        | (1ULL << (fugue_sqlParser::FULL - 128))
        | (1ULL << (fugue_sqlParser::FUNCTION - 128))
        | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
        | (1ULL << (fugue_sqlParser::GLOBAL - 128))
        | (1ULL << (fugue_sqlParser::GRANT - 128))
        | (1ULL << (fugue_sqlParser::GROUP - 128))
        | (1ULL << (fugue_sqlParser::GROUPING - 128))
        | (1ULL << (fugue_sqlParser::HAVING - 128))
        | (1ULL << (fugue_sqlParser::HOUR - 128))
        | (1ULL << (fugue_sqlParser::IF - 128))
        | (1ULL << (fugue_sqlParser::IGNORE - 128))
        | (1ULL << (fugue_sqlParser::IMPORT - 128))
        | (1ULL << (fugue_sqlParser::IN - 128))
        | (1ULL << (fugue_sqlParser::INDEX - 128))
        | (1ULL << (fugue_sqlParser::INDEXES - 128))
        | (1ULL << (fugue_sqlParser::INNER - 128))
        | (1ULL << (fugue_sqlParser::INPATH - 128))
        | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
        | (1ULL << (fugue_sqlParser::INSERT - 128))
        | (1ULL << (fugue_sqlParser::INTERSECT - 128))
        | (1ULL << (fugue_sqlParser::INTERVAL - 128))
        | (1ULL << (fugue_sqlParser::INTO - 128))
        | (1ULL << (fugue_sqlParser::IS - 128))
        | (1ULL << (fugue_sqlParser::ITEMS - 128))
        | (1ULL << (fugue_sqlParser::JOIN - 128))
        | (1ULL << (fugue_sqlParser::KEYS - 128))
        | (1ULL << (fugue_sqlParser::LAST - 128))
        | (1ULL << (fugue_sqlParser::LATERAL - 128))
        | (1ULL << (fugue_sqlParser::LAZY - 128))
        | (1ULL << (fugue_sqlParser::LEADING - 128))
        | (1ULL << (fugue_sqlParser::LEFT - 128))
        | (1ULL << (fugue_sqlParser::LIKE - 128))
        | (1ULL << (fugue_sqlParser::LIMIT - 128))
        | (1ULL << (fugue_sqlParser::LINES - 128))
        | (1ULL << (fugue_sqlParser::LIST - 128))
        | (1ULL << (fugue_sqlParser::LOAD - 128))
        | (1ULL << (fugue_sqlParser::LOCAL - 128))
        | (1ULL << (fugue_sqlParser::LOCATION - 128))
        | (1ULL << (fugue_sqlParser::LOCK - 128))
        | (1ULL << (fugue_sqlParser::LOCKS - 128))
        | (1ULL << (fugue_sqlParser::LOGICAL - 128))
        | (1ULL << (fugue_sqlParser::MACRO - 128))
        | (1ULL << (fugue_sqlParser::MAP - 128))
        | (1ULL << (fugue_sqlParser::MATCHED - 128))
        | (1ULL << (fugue_sqlParser::MERGE - 128))
        | (1ULL << (fugue_sqlParser::MINUTE - 128))
        | (1ULL << (fugue_sqlParser::MONTH - 128))
        | (1ULL << (fugue_sqlParser::MSCK - 128))
        | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
        | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
        | (1ULL << (fugue_sqlParser::NO - 192))
        | (1ULL << (fugue_sqlParser::NOT - 192))
        | (1ULL << (fugue_sqlParser::THENULL - 192))
        | (1ULL << (fugue_sqlParser::THENULLS - 192))
        | (1ULL << (fugue_sqlParser::OF - 192))
        | (1ULL << (fugue_sqlParser::ON - 192))
        | (1ULL << (fugue_sqlParser::ONLY - 192))
        | (1ULL << (fugue_sqlParser::OPTION - 192))
        | (1ULL << (fugue_sqlParser::OPTIONS - 192))
        | (1ULL << (fugue_sqlParser::OR - 192))
        | (1ULL << (fugue_sqlParser::ORDER - 192))
        | (1ULL << (fugue_sqlParser::OUT - 192))
        | (1ULL << (fugue_sqlParser::OUTER - 192))
        | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
        | (1ULL << (fugue_sqlParser::OVER - 192))
        | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
        | (1ULL << (fugue_sqlParser::OVERLAY - 192))
        | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
        | (1ULL << (fugue_sqlParser::PARTITION - 192))
        | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
        | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
        | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
        | (1ULL << (fugue_sqlParser::PIVOT - 192))
        | (1ULL << (fugue_sqlParser::PLACING - 192))
        | (1ULL << (fugue_sqlParser::POSITION - 192))
        | (1ULL << (fugue_sqlParser::PRECEDING - 192))
        | (1ULL << (fugue_sqlParser::PRIMARY - 192))
        | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
        | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
        | (1ULL << (fugue_sqlParser::PURGE - 192))
        | (1ULL << (fugue_sqlParser::QUERY - 192))
        | (1ULL << (fugue_sqlParser::RANGE - 192))
        | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
        | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
        | (1ULL << (fugue_sqlParser::RECOVER - 192))
        | (1ULL << (fugue_sqlParser::REDUCE - 192))
        | (1ULL << (fugue_sqlParser::REFERENCES - 192))
        | (1ULL << (fugue_sqlParser::REFRESH - 192))
        | (1ULL << (fugue_sqlParser::RENAME - 192))
        | (1ULL << (fugue_sqlParser::REPAIR - 192))
        | (1ULL << (fugue_sqlParser::REPLACE - 192))
        | (1ULL << (fugue_sqlParser::RESET - 192))
        | (1ULL << (fugue_sqlParser::RESTRICT - 192))
        | (1ULL << (fugue_sqlParser::REVOKE - 192))
        | (1ULL << (fugue_sqlParser::RIGHT - 192))
        | (1ULL << (fugue_sqlParser::RLIKE - 192))
        | (1ULL << (fugue_sqlParser::ROLE - 192))
        | (1ULL << (fugue_sqlParser::ROLES - 192))
        | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
        | (1ULL << (fugue_sqlParser::ROLLUP - 192))
        | (1ULL << (fugue_sqlParser::ROW - 192))
        | (1ULL << (fugue_sqlParser::ROWS - 192))
        | (1ULL << (fugue_sqlParser::SCHEMA - 192))
        | (1ULL << (fugue_sqlParser::SECOND - 192))
        | (1ULL << (fugue_sqlParser::SELECT - 192))
        | (1ULL << (fugue_sqlParser::SEMI - 192))
        | (1ULL << (fugue_sqlParser::SEPARATED - 192))
        | (1ULL << (fugue_sqlParser::SERDE - 192))
        | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
        | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
        | (1ULL << (fugue_sqlParser::SET - 192))
        | (1ULL << (fugue_sqlParser::SETMINUS - 192))
        | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
        | (1ULL << (fugue_sqlParser::SKEWED - 256))
        | (1ULL << (fugue_sqlParser::SOME - 256))
        | (1ULL << (fugue_sqlParser::SORT - 256))
        | (1ULL << (fugue_sqlParser::SORTED - 256))
        | (1ULL << (fugue_sqlParser::START - 256))
        | (1ULL << (fugue_sqlParser::STATISTICS - 256))
        | (1ULL << (fugue_sqlParser::STORED - 256))
        | (1ULL << (fugue_sqlParser::STRATIFY - 256))
        | (1ULL << (fugue_sqlParser::STRUCT - 256))
        | (1ULL << (fugue_sqlParser::SUBSTR - 256))
        | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
        | (1ULL << (fugue_sqlParser::TABLE - 256))
        | (1ULL << (fugue_sqlParser::TABLES - 256))
        | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
        | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
        | (1ULL << (fugue_sqlParser::TERMINATED - 256))
        | (1ULL << (fugue_sqlParser::THEN - 256))
        | (1ULL << (fugue_sqlParser::TO - 256))
        | (1ULL << (fugue_sqlParser::TOUCH - 256))
        | (1ULL << (fugue_sqlParser::TRAILING - 256))
        | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
        | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
        | (1ULL << (fugue_sqlParser::TRIM - 256))
        | (1ULL << (fugue_sqlParser::TRUE - 256))
        | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
        | (1ULL << (fugue_sqlParser::TYPE - 256))
        | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
        | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
        | (1ULL << (fugue_sqlParser::UNCACHE - 256))
        | (1ULL << (fugue_sqlParser::UNION - 256))
        | (1ULL << (fugue_sqlParser::UNIQUE - 256))
        | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
        | (1ULL << (fugue_sqlParser::UNLOCK - 256))
        | (1ULL << (fugue_sqlParser::UNSET - 256))
        | (1ULL << (fugue_sqlParser::UPDATE - 256))
        | (1ULL << (fugue_sqlParser::USE - 256))
        | (1ULL << (fugue_sqlParser::USER - 256))
        | (1ULL << (fugue_sqlParser::USING - 256))
        | (1ULL << (fugue_sqlParser::VALUES - 256))
        | (1ULL << (fugue_sqlParser::VIEW - 256))
        | (1ULL << (fugue_sqlParser::VIEWS - 256))
        | (1ULL << (fugue_sqlParser::WHEN - 256))
        | (1ULL << (fugue_sqlParser::WHERE - 256))
        | (1ULL << (fugue_sqlParser::WINDOW - 256))
        | (1ULL << (fugue_sqlParser::WITH - 256))
        | (1ULL << (fugue_sqlParser::YEAR - 256))
        | (1ULL << (fugue_sqlParser::PLUS - 256))
        | (1ULL << (fugue_sqlParser::MINUS - 256))
        | (1ULL << (fugue_sqlParser::ASTERISK - 256))
        | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || ((((_la - 320) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 320)) & ((1ULL << (fugue_sqlParser::TILDE - 320))
        | (1ULL << (fugue_sqlParser::STRING - 320))
        | (1ULL << (fugue_sqlParser::BIGINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::SMALLINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::TINYINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 320))
        | (1ULL << (fugue_sqlParser::EXPONENT_VALUE - 320))
        | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 320))
        | (1ULL << (fugue_sqlParser::DOUBLE_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::BIGDECIMAL_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::IDENTIFIER - 320))
        | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 320)))) != 0)) {
        setState(2729);
        expression();
        setState(2734);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(2730);
          match(fugue_sqlParser::T__0);
          setState(2731);
          expression();
          setState(2736);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(2739);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2740);
      expression();
      break;
    }

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

  return _localctx;
}

//----------------- PivotClauseContext ------------------------------------------------------------------

fugue_sqlParser::PivotClauseContext::PivotClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::PivotClauseContext::PIVOT() {
  return getToken(fugue_sqlParser::PIVOT, 0);
}

tree::TerminalNode* fugue_sqlParser::PivotClauseContext::FOR() {
  return getToken(fugue_sqlParser::FOR, 0);
}

fugue_sqlParser::PivotColumnContext* fugue_sqlParser::PivotClauseContext::pivotColumn() {
  return getRuleContext<fugue_sqlParser::PivotColumnContext>(0);
}

tree::TerminalNode* fugue_sqlParser::PivotClauseContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

fugue_sqlParser::NamedExpressionSeqContext* fugue_sqlParser::PivotClauseContext::namedExpressionSeq() {
  return getRuleContext<fugue_sqlParser::NamedExpressionSeqContext>(0);
}

std::vector<fugue_sqlParser::PivotValueContext *> fugue_sqlParser::PivotClauseContext::pivotValue() {
  return getRuleContexts<fugue_sqlParser::PivotValueContext>();
}

fugue_sqlParser::PivotValueContext* fugue_sqlParser::PivotClauseContext::pivotValue(size_t i) {
  return getRuleContext<fugue_sqlParser::PivotValueContext>(i);
}


size_t fugue_sqlParser::PivotClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RulePivotClause;
}


std::any fugue_sqlParser::PivotClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPivotClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PivotClauseContext* fugue_sqlParser::pivotClause() {
  PivotClauseContext *_localctx = _tracker.createInstance<PivotClauseContext>(_ctx, getState());
  enterRule(_localctx, 276, fugue_sqlParser::RulePivotClause);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2743);
    match(fugue_sqlParser::PIVOT);
    setState(2744);
    match(fugue_sqlParser::T__2);
    setState(2745);
    antlrcpp::downCast<PivotClauseContext *>(_localctx)->aggregates = namedExpressionSeq();
    setState(2746);
    match(fugue_sqlParser::FOR);
    setState(2747);
    pivotColumn();
    setState(2748);
    match(fugue_sqlParser::IN);
    setState(2749);
    match(fugue_sqlParser::T__2);
    setState(2750);
    antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext = pivotValue();
    antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValues.push_back(antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext);
    setState(2755);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2751);
      match(fugue_sqlParser::T__0);
      setState(2752);
      antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext = pivotValue();
      antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValues.push_back(antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext);
      setState(2757);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2758);
    match(fugue_sqlParser::T__3);
    setState(2759);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PivotColumnContext ------------------------------------------------------------------

fugue_sqlParser::PivotColumnContext::PivotColumnContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::PivotColumnContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::PivotColumnContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}


size_t fugue_sqlParser::PivotColumnContext::getRuleIndex() const {
  return fugue_sqlParser::RulePivotColumn;
}


std::any fugue_sqlParser::PivotColumnContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPivotColumn(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PivotColumnContext* fugue_sqlParser::pivotColumn() {
  PivotColumnContext *_localctx = _tracker.createInstance<PivotColumnContext>(_ctx, getState());
  enterRule(_localctx, 278, fugue_sqlParser::RulePivotColumn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2773);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::USING:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        enterOuterAlt(_localctx, 1);
        setState(2761);
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext = identifier();
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifiers.push_back(antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext);
        break;
      }

      case fugue_sqlParser::T__2: {
        enterOuterAlt(_localctx, 2);
        setState(2762);
        match(fugue_sqlParser::T__2);
        setState(2763);
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext = identifier();
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifiers.push_back(antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext);
        setState(2768);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(2764);
          match(fugue_sqlParser::T__0);
          setState(2765);
          antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext = identifier();
          antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifiers.push_back(antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext);
          setState(2770);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2771);
        match(fugue_sqlParser::T__3);
        break;
      }

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

  return _localctx;
}

//----------------- PivotValueContext ------------------------------------------------------------------

fugue_sqlParser::PivotValueContext::PivotValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::PivotValueContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::PivotValueContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::PivotValueContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}


size_t fugue_sqlParser::PivotValueContext::getRuleIndex() const {
  return fugue_sqlParser::RulePivotValue;
}


std::any fugue_sqlParser::PivotValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPivotValue(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PivotValueContext* fugue_sqlParser::pivotValue() {
  PivotValueContext *_localctx = _tracker.createInstance<PivotValueContext>(_ctx, getState());
  enterRule(_localctx, 280, fugue_sqlParser::RulePivotValue);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (((((_la - 53) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 53)) & ((1ULL << (fugue_sqlParser::ADD - 53))
      | (1ULL << (fugue_sqlParser::AFTER - 53))
      | (1ULL << (fugue_sqlParser::ALL - 53))
      | (1ULL << (fugue_sqlParser::ALTER - 53))
      | (1ULL << (fugue_sqlParser::ANALYZE - 53))
      | (1ULL << (fugue_sqlParser::AND - 53))
      | (1ULL << (fugue_sqlParser::ANTI - 53))
      | (1ULL << (fugue_sqlParser::ANY - 53))
      | (1ULL << (fugue_sqlParser::ARCHIVE - 53))
      | (1ULL << (fugue_sqlParser::ARRAY - 53))
      | (1ULL << (fugue_sqlParser::AS - 53))
      | (1ULL << (fugue_sqlParser::ASC - 53))
      | (1ULL << (fugue_sqlParser::AT - 53))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 53))
      | (1ULL << (fugue_sqlParser::BETWEEN - 53))
      | (1ULL << (fugue_sqlParser::BOTH - 53))
      | (1ULL << (fugue_sqlParser::BUCKET - 53))
      | (1ULL << (fugue_sqlParser::BUCKETS - 53))
      | (1ULL << (fugue_sqlParser::BY - 53))
      | (1ULL << (fugue_sqlParser::CACHE - 53))
      | (1ULL << (fugue_sqlParser::CASCADE - 53))
      | (1ULL << (fugue_sqlParser::CASE - 53))
      | (1ULL << (fugue_sqlParser::CAST - 53))
      | (1ULL << (fugue_sqlParser::CHANGE - 53))
      | (1ULL << (fugue_sqlParser::CHECK - 53))
      | (1ULL << (fugue_sqlParser::CLEAR - 53))
      | (1ULL << (fugue_sqlParser::CLUSTER - 53))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 53))
      | (1ULL << (fugue_sqlParser::CODEGEN - 53))
      | (1ULL << (fugue_sqlParser::COLLATE - 53))
      | (1ULL << (fugue_sqlParser::COLLECTION - 53))
      | (1ULL << (fugue_sqlParser::COLUMN - 53))
      | (1ULL << (fugue_sqlParser::COLUMNS - 53))
      | (1ULL << (fugue_sqlParser::COMMENT - 53))
      | (1ULL << (fugue_sqlParser::COMMIT - 53))
      | (1ULL << (fugue_sqlParser::COMPACT - 53))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 53))
      | (1ULL << (fugue_sqlParser::COMPUTE - 53))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 53))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 53))
      | (1ULL << (fugue_sqlParser::COST - 53))
      | (1ULL << (fugue_sqlParser::CREATE - 53))
      | (1ULL << (fugue_sqlParser::CROSS - 53))
      | (1ULL << (fugue_sqlParser::CUBE - 53))
      | (1ULL << (fugue_sqlParser::CURRENT - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 53))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 53))
      | (1ULL << (fugue_sqlParser::DATA - 53))
      | (1ULL << (fugue_sqlParser::DATABASE - 53))
      | (1ULL << (fugue_sqlParser::DATABASES - 53))
      | (1ULL << (fugue_sqlParser::DAY - 53))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 53))
      | (1ULL << (fugue_sqlParser::DEFINED - 53))
      | (1ULL << (fugue_sqlParser::DELETE - 53))
      | (1ULL << (fugue_sqlParser::DELIMITED - 53))
      | (1ULL << (fugue_sqlParser::DESC - 53))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 53))
      | (1ULL << (fugue_sqlParser::DFS - 53))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 53))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 53))
      | (1ULL << (fugue_sqlParser::DISTINCT - 53))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 53)))) != 0) || ((((_la - 117) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 117)) & ((1ULL << (fugue_sqlParser::DROP - 117))
      | (1ULL << (fugue_sqlParser::ELSE - 117))
      | (1ULL << (fugue_sqlParser::END - 117))
      | (1ULL << (fugue_sqlParser::ESCAPE - 117))
      | (1ULL << (fugue_sqlParser::ESCAPED - 117))
      | (1ULL << (fugue_sqlParser::EXCEPT - 117))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 117))
      | (1ULL << (fugue_sqlParser::EXISTS - 117))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 117))
      | (1ULL << (fugue_sqlParser::EXPORT - 117))
      | (1ULL << (fugue_sqlParser::EXTENDED - 117))
      | (1ULL << (fugue_sqlParser::EXTERNAL - 117))
      | (1ULL << (fugue_sqlParser::EXTRACT - 117))
      | (1ULL << (fugue_sqlParser::FALSE - 117))
      | (1ULL << (fugue_sqlParser::FETCH - 117))
      | (1ULL << (fugue_sqlParser::FIELDS - 117))
      | (1ULL << (fugue_sqlParser::FILTER - 117))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 117))
      | (1ULL << (fugue_sqlParser::FIRST - 117))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 117))
      | (1ULL << (fugue_sqlParser::FOR - 117))
      | (1ULL << (fugue_sqlParser::FOREIGN - 117))
      | (1ULL << (fugue_sqlParser::FORMAT - 117))
      | (1ULL << (fugue_sqlParser::FORMATTED - 117))
      | (1ULL << (fugue_sqlParser::FROM - 117))
      | (1ULL << (fugue_sqlParser::FULL - 117))
      | (1ULL << (fugue_sqlParser::FUNCTION - 117))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 117))
      | (1ULL << (fugue_sqlParser::GLOBAL - 117))
      | (1ULL << (fugue_sqlParser::GRANT - 117))
      | (1ULL << (fugue_sqlParser::GROUP - 117))
      | (1ULL << (fugue_sqlParser::GROUPING - 117))
      | (1ULL << (fugue_sqlParser::HAVING - 117))
      | (1ULL << (fugue_sqlParser::HOUR - 117))
      | (1ULL << (fugue_sqlParser::IF - 117))
      | (1ULL << (fugue_sqlParser::IGNORE - 117))
      | (1ULL << (fugue_sqlParser::IMPORT - 117))
      | (1ULL << (fugue_sqlParser::IN - 117))
      | (1ULL << (fugue_sqlParser::INDEX - 117))
      | (1ULL << (fugue_sqlParser::INDEXES - 117))
      | (1ULL << (fugue_sqlParser::INNER - 117))
      | (1ULL << (fugue_sqlParser::INPATH - 117))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 117))
      | (1ULL << (fugue_sqlParser::INSERT - 117))
      | (1ULL << (fugue_sqlParser::INTERSECT - 117))
      | (1ULL << (fugue_sqlParser::INTERVAL - 117))
      | (1ULL << (fugue_sqlParser::INTO - 117))
      | (1ULL << (fugue_sqlParser::IS - 117))
      | (1ULL << (fugue_sqlParser::ITEMS - 117))
      | (1ULL << (fugue_sqlParser::JOIN - 117))
      | (1ULL << (fugue_sqlParser::KEYS - 117))
      | (1ULL << (fugue_sqlParser::LAST - 117))
      | (1ULL << (fugue_sqlParser::LATERAL - 117))
      | (1ULL << (fugue_sqlParser::LAZY - 117))
      | (1ULL << (fugue_sqlParser::LEADING - 117))
      | (1ULL << (fugue_sqlParser::LEFT - 117))
      | (1ULL << (fugue_sqlParser::LIKE - 117))
      | (1ULL << (fugue_sqlParser::LIMIT - 117))
      | (1ULL << (fugue_sqlParser::LINES - 117))
      | (1ULL << (fugue_sqlParser::LIST - 117))
      | (1ULL << (fugue_sqlParser::LOAD - 117))
      | (1ULL << (fugue_sqlParser::LOCAL - 117))
      | (1ULL << (fugue_sqlParser::LOCATION - 117))
      | (1ULL << (fugue_sqlParser::LOCK - 117)))) != 0) || ((((_la - 181) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 181)) & ((1ULL << (fugue_sqlParser::LOCKS - 181))
      | (1ULL << (fugue_sqlParser::LOGICAL - 181))
      | (1ULL << (fugue_sqlParser::MACRO - 181))
      | (1ULL << (fugue_sqlParser::MAP - 181))
      | (1ULL << (fugue_sqlParser::MATCHED - 181))
      | (1ULL << (fugue_sqlParser::MERGE - 181))
      | (1ULL << (fugue_sqlParser::MINUTE - 181))
      | (1ULL << (fugue_sqlParser::MONTH - 181))
      | (1ULL << (fugue_sqlParser::MSCK - 181))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 181))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 181))
      | (1ULL << (fugue_sqlParser::NATURAL - 181))
      | (1ULL << (fugue_sqlParser::NO - 181))
      | (1ULL << (fugue_sqlParser::NOT - 181))
      | (1ULL << (fugue_sqlParser::THENULL - 181))
      | (1ULL << (fugue_sqlParser::THENULLS - 181))
      | (1ULL << (fugue_sqlParser::OF - 181))
      | (1ULL << (fugue_sqlParser::ON - 181))
      | (1ULL << (fugue_sqlParser::ONLY - 181))
      | (1ULL << (fugue_sqlParser::OPTION - 181))
      | (1ULL << (fugue_sqlParser::OPTIONS - 181))
      | (1ULL << (fugue_sqlParser::OR - 181))
      | (1ULL << (fugue_sqlParser::ORDER - 181))
      | (1ULL << (fugue_sqlParser::OUT - 181))
      | (1ULL << (fugue_sqlParser::OUTER - 181))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 181))
      | (1ULL << (fugue_sqlParser::OVER - 181))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 181))
      | (1ULL << (fugue_sqlParser::OVERLAY - 181))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 181))
      | (1ULL << (fugue_sqlParser::PARTITION - 181))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 181))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 181))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 181))
      | (1ULL << (fugue_sqlParser::PIVOT - 181))
      | (1ULL << (fugue_sqlParser::PLACING - 181))
      | (1ULL << (fugue_sqlParser::POSITION - 181))
      | (1ULL << (fugue_sqlParser::PRECEDING - 181))
      | (1ULL << (fugue_sqlParser::PRIMARY - 181))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 181))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 181))
      | (1ULL << (fugue_sqlParser::PURGE - 181))
      | (1ULL << (fugue_sqlParser::QUERY - 181))
      | (1ULL << (fugue_sqlParser::RANGE - 181))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 181))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 181))
      | (1ULL << (fugue_sqlParser::RECOVER - 181))
      | (1ULL << (fugue_sqlParser::REDUCE - 181))
      | (1ULL << (fugue_sqlParser::REFERENCES - 181))
      | (1ULL << (fugue_sqlParser::REFRESH - 181))
      | (1ULL << (fugue_sqlParser::RENAME - 181))
      | (1ULL << (fugue_sqlParser::REPAIR - 181))
      | (1ULL << (fugue_sqlParser::REPLACE - 181))
      | (1ULL << (fugue_sqlParser::RESET - 181))
      | (1ULL << (fugue_sqlParser::RESTRICT - 181))
      | (1ULL << (fugue_sqlParser::REVOKE - 181))
      | (1ULL << (fugue_sqlParser::RIGHT - 181))
      | (1ULL << (fugue_sqlParser::RLIKE - 181))
      | (1ULL << (fugue_sqlParser::ROLE - 181))
      | (1ULL << (fugue_sqlParser::ROLES - 181))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 181))
      | (1ULL << (fugue_sqlParser::ROLLUP - 181))
      | (1ULL << (fugue_sqlParser::ROW - 181))
      | (1ULL << (fugue_sqlParser::ROWS - 181)))) != 0) || ((((_la - 245) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 245)) & ((1ULL << (fugue_sqlParser::SCHEMA - 245))
      | (1ULL << (fugue_sqlParser::SECOND - 245))
      | (1ULL << (fugue_sqlParser::SELECT - 245))
      | (1ULL << (fugue_sqlParser::SEMI - 245))
      | (1ULL << (fugue_sqlParser::SEPARATED - 245))
      | (1ULL << (fugue_sqlParser::SERDE - 245))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 245))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 245))
      | (1ULL << (fugue_sqlParser::SET - 245))
      | (1ULL << (fugue_sqlParser::SETMINUS - 245))
      | (1ULL << (fugue_sqlParser::SETS - 245))
      | (1ULL << (fugue_sqlParser::SHOW - 245))
      | (1ULL << (fugue_sqlParser::SKEWED - 245))
      | (1ULL << (fugue_sqlParser::SOME - 245))
      | (1ULL << (fugue_sqlParser::SORT - 245))
      | (1ULL << (fugue_sqlParser::SORTED - 245))
      | (1ULL << (fugue_sqlParser::START - 245))
      | (1ULL << (fugue_sqlParser::STATISTICS - 245))
      | (1ULL << (fugue_sqlParser::STORED - 245))
      | (1ULL << (fugue_sqlParser::STRATIFY - 245))
      | (1ULL << (fugue_sqlParser::STRUCT - 245))
      | (1ULL << (fugue_sqlParser::SUBSTR - 245))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 245))
      | (1ULL << (fugue_sqlParser::TABLE - 245))
      | (1ULL << (fugue_sqlParser::TABLES - 245))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 245))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 245))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 245))
      | (1ULL << (fugue_sqlParser::TERMINATED - 245))
      | (1ULL << (fugue_sqlParser::THEN - 245))
      | (1ULL << (fugue_sqlParser::TO - 245))
      | (1ULL << (fugue_sqlParser::TOUCH - 245))
      | (1ULL << (fugue_sqlParser::TRAILING - 245))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 245))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 245))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 245))
      | (1ULL << (fugue_sqlParser::TRIM - 245))
      | (1ULL << (fugue_sqlParser::TRUE - 245))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 245))
      | (1ULL << (fugue_sqlParser::TYPE - 245))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 245))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 245))
      | (1ULL << (fugue_sqlParser::UNCACHE - 245))
      | (1ULL << (fugue_sqlParser::UNION - 245))
      | (1ULL << (fugue_sqlParser::UNIQUE - 245))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 245))
      | (1ULL << (fugue_sqlParser::UNLOCK - 245))
      | (1ULL << (fugue_sqlParser::UNSET - 245))
      | (1ULL << (fugue_sqlParser::UPDATE - 245))
      | (1ULL << (fugue_sqlParser::USE - 245))
      | (1ULL << (fugue_sqlParser::USER - 245))
      | (1ULL << (fugue_sqlParser::USING - 245))
      | (1ULL << (fugue_sqlParser::VALUES - 245))
      | (1ULL << (fugue_sqlParser::VIEW - 245))
      | (1ULL << (fugue_sqlParser::VIEWS - 245))
      | (1ULL << (fugue_sqlParser::WHEN - 245))
      | (1ULL << (fugue_sqlParser::WHERE - 245))
      | (1ULL << (fugue_sqlParser::WINDOW - 245))
      | (1ULL << (fugue_sqlParser::WITH - 245))
      | (1ULL << (fugue_sqlParser::YEAR - 245)))) != 0) || ((((_la - 319) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 319)) & ((1ULL << (fugue_sqlParser::DIV - 319))
      | (1ULL << (fugue_sqlParser::IDENTIFIER - 319))
      | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 319)))) != 0)) {
      setState(2777);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 361, _ctx)) {
      case 1: {
        setState(2776);
        match(fugue_sqlParser::AS);
        break;
      }

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

  return _localctx;
}

//----------------- LateralViewContext ------------------------------------------------------------------

fugue_sqlParser::LateralViewContext::LateralViewContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::LateralViewContext::LATERAL() {
  return getToken(fugue_sqlParser::LATERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::LateralViewContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::LateralViewContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::LateralViewContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::LateralViewContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}

tree::TerminalNode* fugue_sqlParser::LateralViewContext::OUTER() {
  return getToken(fugue_sqlParser::OUTER, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::LateralViewContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::LateralViewContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::LateralViewContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}


size_t fugue_sqlParser::LateralViewContext::getRuleIndex() const {
  return fugue_sqlParser::RuleLateralView;
}


std::any fugue_sqlParser::LateralViewContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLateralView(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::LateralViewContext* fugue_sqlParser::lateralView() {
  LateralViewContext *_localctx = _tracker.createInstance<LateralViewContext>(_ctx, getState());
  enterRule(_localctx, 282, fugue_sqlParser::RuleLateralView);
  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(2782);
    match(fugue_sqlParser::LATERAL);
    setState(2783);
    match(fugue_sqlParser::VIEW);
    setState(2785);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 363, _ctx)) {
    case 1: {
      setState(2784);
      match(fugue_sqlParser::OUTER);
      break;
    }

    default:
      break;
    }
    setState(2787);
    qualifiedName();
    setState(2788);
    match(fugue_sqlParser::T__2);
    setState(2797);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::ADD)
      | (1ULL << fugue_sqlParser::AFTER)
      | (1ULL << fugue_sqlParser::ALL)
      | (1ULL << fugue_sqlParser::ALTER)
      | (1ULL << fugue_sqlParser::ANALYZE)
      | (1ULL << fugue_sqlParser::AND)
      | (1ULL << fugue_sqlParser::ANTI)
      | (1ULL << fugue_sqlParser::ANY)
      | (1ULL << fugue_sqlParser::ARCHIVE)
      | (1ULL << fugue_sqlParser::ARRAY)
      | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
      | (1ULL << (fugue_sqlParser::AT - 64))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
      | (1ULL << (fugue_sqlParser::BETWEEN - 64))
      | (1ULL << (fugue_sqlParser::BOTH - 64))
      | (1ULL << (fugue_sqlParser::BUCKET - 64))
      | (1ULL << (fugue_sqlParser::BUCKETS - 64))
      | (1ULL << (fugue_sqlParser::BY - 64))
      | (1ULL << (fugue_sqlParser::CACHE - 64))
      | (1ULL << (fugue_sqlParser::CASCADE - 64))
      | (1ULL << (fugue_sqlParser::CASE - 64))
      | (1ULL << (fugue_sqlParser::CAST - 64))
      | (1ULL << (fugue_sqlParser::CHANGE - 64))
      | (1ULL << (fugue_sqlParser::CHECK - 64))
      | (1ULL << (fugue_sqlParser::CLEAR - 64))
      | (1ULL << (fugue_sqlParser::CLUSTER - 64))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
      | (1ULL << (fugue_sqlParser::CODEGEN - 64))
      | (1ULL << (fugue_sqlParser::COLLATE - 64))
      | (1ULL << (fugue_sqlParser::COLLECTION - 64))
      | (1ULL << (fugue_sqlParser::COLUMN - 64))
      | (1ULL << (fugue_sqlParser::COLUMNS - 64))
      | (1ULL << (fugue_sqlParser::COMMENT - 64))
      | (1ULL << (fugue_sqlParser::COMMIT - 64))
      | (1ULL << (fugue_sqlParser::COMPACT - 64))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
      | (1ULL << (fugue_sqlParser::COMPUTE - 64))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
      | (1ULL << (fugue_sqlParser::COST - 64))
      | (1ULL << (fugue_sqlParser::CREATE - 64))
      | (1ULL << (fugue_sqlParser::CROSS - 64))
      | (1ULL << (fugue_sqlParser::CUBE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
      | (1ULL << (fugue_sqlParser::DATA - 64))
      | (1ULL << (fugue_sqlParser::DATABASE - 64))
      | (1ULL << (fugue_sqlParser::DATABASES - 64))
      | (1ULL << (fugue_sqlParser::DAY - 64))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
      | (1ULL << (fugue_sqlParser::DEFINED - 64))
      | (1ULL << (fugue_sqlParser::DELETE - 64))
      | (1ULL << (fugue_sqlParser::DELIMITED - 64))
      | (1ULL << (fugue_sqlParser::DESC - 64))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
      | (1ULL << (fugue_sqlParser::DFS - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
      | (1ULL << (fugue_sqlParser::DISTINCT - 64))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
      | (1ULL << (fugue_sqlParser::DROP - 64))
      | (1ULL << (fugue_sqlParser::ELSE - 64))
      | (1ULL << (fugue_sqlParser::END - 64))
      | (1ULL << (fugue_sqlParser::ESCAPE - 64))
      | (1ULL << (fugue_sqlParser::ESCAPED - 64))
      | (1ULL << (fugue_sqlParser::EXCEPT - 64))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
      | (1ULL << (fugue_sqlParser::EXISTS - 64))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
      | (1ULL << (fugue_sqlParser::EXPORT - 64))
      | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
      | (1ULL << (fugue_sqlParser::EXTRACT - 128))
      | (1ULL << (fugue_sqlParser::FALSE - 128))
      | (1ULL << (fugue_sqlParser::FETCH - 128))
      | (1ULL << (fugue_sqlParser::FIELDS - 128))
      | (1ULL << (fugue_sqlParser::FILTER - 128))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
      | (1ULL << (fugue_sqlParser::FIRST - 128))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
      | (1ULL << (fugue_sqlParser::FOR - 128))
      | (1ULL << (fugue_sqlParser::FOREIGN - 128))
      | (1ULL << (fugue_sqlParser::FORMAT - 128))
      | (1ULL << (fugue_sqlParser::FORMATTED - 128))
      | (1ULL << (fugue_sqlParser::FROM - 128))
      | (1ULL << (fugue_sqlParser::FULL - 128))
      | (1ULL << (fugue_sqlParser::FUNCTION - 128))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
      | (1ULL << (fugue_sqlParser::GLOBAL - 128))
      | (1ULL << (fugue_sqlParser::GRANT - 128))
      | (1ULL << (fugue_sqlParser::GROUP - 128))
      | (1ULL << (fugue_sqlParser::GROUPING - 128))
      | (1ULL << (fugue_sqlParser::HAVING - 128))
      | (1ULL << (fugue_sqlParser::HOUR - 128))
      | (1ULL << (fugue_sqlParser::IF - 128))
      | (1ULL << (fugue_sqlParser::IGNORE - 128))
      | (1ULL << (fugue_sqlParser::IMPORT - 128))
      | (1ULL << (fugue_sqlParser::IN - 128))
      | (1ULL << (fugue_sqlParser::INDEX - 128))
      | (1ULL << (fugue_sqlParser::INDEXES - 128))
      | (1ULL << (fugue_sqlParser::INNER - 128))
      | (1ULL << (fugue_sqlParser::INPATH - 128))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
      | (1ULL << (fugue_sqlParser::INSERT - 128))
      | (1ULL << (fugue_sqlParser::INTERSECT - 128))
      | (1ULL << (fugue_sqlParser::INTERVAL - 128))
      | (1ULL << (fugue_sqlParser::INTO - 128))
      | (1ULL << (fugue_sqlParser::IS - 128))
      | (1ULL << (fugue_sqlParser::ITEMS - 128))
      | (1ULL << (fugue_sqlParser::JOIN - 128))
      | (1ULL << (fugue_sqlParser::KEYS - 128))
      | (1ULL << (fugue_sqlParser::LAST - 128))
      | (1ULL << (fugue_sqlParser::LATERAL - 128))
      | (1ULL << (fugue_sqlParser::LAZY - 128))
      | (1ULL << (fugue_sqlParser::LEADING - 128))
      | (1ULL << (fugue_sqlParser::LEFT - 128))
      | (1ULL << (fugue_sqlParser::LIKE - 128))
      | (1ULL << (fugue_sqlParser::LIMIT - 128))
      | (1ULL << (fugue_sqlParser::LINES - 128))
      | (1ULL << (fugue_sqlParser::LIST - 128))
      | (1ULL << (fugue_sqlParser::LOAD - 128))
      | (1ULL << (fugue_sqlParser::LOCAL - 128))
      | (1ULL << (fugue_sqlParser::LOCATION - 128))
      | (1ULL << (fugue_sqlParser::LOCK - 128))
      | (1ULL << (fugue_sqlParser::LOCKS - 128))
      | (1ULL << (fugue_sqlParser::LOGICAL - 128))
      | (1ULL << (fugue_sqlParser::MACRO - 128))
      | (1ULL << (fugue_sqlParser::MAP - 128))
      | (1ULL << (fugue_sqlParser::MATCHED - 128))
      | (1ULL << (fugue_sqlParser::MERGE - 128))
      | (1ULL << (fugue_sqlParser::MINUTE - 128))
      | (1ULL << (fugue_sqlParser::MONTH - 128))
      | (1ULL << (fugue_sqlParser::MSCK - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
      | (1ULL << (fugue_sqlParser::NO - 192))
      | (1ULL << (fugue_sqlParser::NOT - 192))
      | (1ULL << (fugue_sqlParser::THENULL - 192))
      | (1ULL << (fugue_sqlParser::THENULLS - 192))
      | (1ULL << (fugue_sqlParser::OF - 192))
      | (1ULL << (fugue_sqlParser::ON - 192))
      | (1ULL << (fugue_sqlParser::ONLY - 192))
      | (1ULL << (fugue_sqlParser::OPTION - 192))
      | (1ULL << (fugue_sqlParser::OPTIONS - 192))
      | (1ULL << (fugue_sqlParser::OR - 192))
      | (1ULL << (fugue_sqlParser::ORDER - 192))
      | (1ULL << (fugue_sqlParser::OUT - 192))
      | (1ULL << (fugue_sqlParser::OUTER - 192))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
      | (1ULL << (fugue_sqlParser::OVER - 192))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
      | (1ULL << (fugue_sqlParser::OVERLAY - 192))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
      | (1ULL << (fugue_sqlParser::PARTITION - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
      | (1ULL << (fugue_sqlParser::PIVOT - 192))
      | (1ULL << (fugue_sqlParser::PLACING - 192))
      | (1ULL << (fugue_sqlParser::POSITION - 192))
      | (1ULL << (fugue_sqlParser::PRECEDING - 192))
      | (1ULL << (fugue_sqlParser::PRIMARY - 192))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::PURGE - 192))
      | (1ULL << (fugue_sqlParser::QUERY - 192))
      | (1ULL << (fugue_sqlParser::RANGE - 192))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
      | (1ULL << (fugue_sqlParser::RECOVER - 192))
      | (1ULL << (fugue_sqlParser::REDUCE - 192))
      | (1ULL << (fugue_sqlParser::REFERENCES - 192))
      | (1ULL << (fugue_sqlParser::REFRESH - 192))
      | (1ULL << (fugue_sqlParser::RENAME - 192))
      | (1ULL << (fugue_sqlParser::REPAIR - 192))
      | (1ULL << (fugue_sqlParser::REPLACE - 192))
      | (1ULL << (fugue_sqlParser::RESET - 192))
      | (1ULL << (fugue_sqlParser::RESTRICT - 192))
      | (1ULL << (fugue_sqlParser::REVOKE - 192))
      | (1ULL << (fugue_sqlParser::RIGHT - 192))
      | (1ULL << (fugue_sqlParser::RLIKE - 192))
      | (1ULL << (fugue_sqlParser::ROLE - 192))
      | (1ULL << (fugue_sqlParser::ROLES - 192))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
      | (1ULL << (fugue_sqlParser::ROLLUP - 192))
      | (1ULL << (fugue_sqlParser::ROW - 192))
      | (1ULL << (fugue_sqlParser::ROWS - 192))
      | (1ULL << (fugue_sqlParser::SCHEMA - 192))
      | (1ULL << (fugue_sqlParser::SECOND - 192))
      | (1ULL << (fugue_sqlParser::SELECT - 192))
      | (1ULL << (fugue_sqlParser::SEMI - 192))
      | (1ULL << (fugue_sqlParser::SEPARATED - 192))
      | (1ULL << (fugue_sqlParser::SERDE - 192))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
      | (1ULL << (fugue_sqlParser::SET - 192))
      | (1ULL << (fugue_sqlParser::SETMINUS - 192))
      | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
      | (1ULL << (fugue_sqlParser::SKEWED - 256))
      | (1ULL << (fugue_sqlParser::SOME - 256))
      | (1ULL << (fugue_sqlParser::SORT - 256))
      | (1ULL << (fugue_sqlParser::SORTED - 256))
      | (1ULL << (fugue_sqlParser::START - 256))
      | (1ULL << (fugue_sqlParser::STATISTICS - 256))
      | (1ULL << (fugue_sqlParser::STORED - 256))
      | (1ULL << (fugue_sqlParser::STRATIFY - 256))
      | (1ULL << (fugue_sqlParser::STRUCT - 256))
      | (1ULL << (fugue_sqlParser::SUBSTR - 256))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
      | (1ULL << (fugue_sqlParser::TABLE - 256))
      | (1ULL << (fugue_sqlParser::TABLES - 256))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
      | (1ULL << (fugue_sqlParser::TERMINATED - 256))
      | (1ULL << (fugue_sqlParser::THEN - 256))
      | (1ULL << (fugue_sqlParser::TO - 256))
      | (1ULL << (fugue_sqlParser::TOUCH - 256))
      | (1ULL << (fugue_sqlParser::TRAILING - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
      | (1ULL << (fugue_sqlParser::TRIM - 256))
      | (1ULL << (fugue_sqlParser::TRUE - 256))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
      | (1ULL << (fugue_sqlParser::TYPE - 256))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
      | (1ULL << (fugue_sqlParser::UNCACHE - 256))
      | (1ULL << (fugue_sqlParser::UNION - 256))
      | (1ULL << (fugue_sqlParser::UNIQUE - 256))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
      | (1ULL << (fugue_sqlParser::UNLOCK - 256))
      | (1ULL << (fugue_sqlParser::UNSET - 256))
      | (1ULL << (fugue_sqlParser::UPDATE - 256))
      | (1ULL << (fugue_sqlParser::USE - 256))
      | (1ULL << (fugue_sqlParser::USER - 256))
      | (1ULL << (fugue_sqlParser::USING - 256))
      | (1ULL << (fugue_sqlParser::VALUES - 256))
      | (1ULL << (fugue_sqlParser::VIEW - 256))
      | (1ULL << (fugue_sqlParser::VIEWS - 256))
      | (1ULL << (fugue_sqlParser::WHEN - 256))
      | (1ULL << (fugue_sqlParser::WHERE - 256))
      | (1ULL << (fugue_sqlParser::WINDOW - 256))
      | (1ULL << (fugue_sqlParser::WITH - 256))
      | (1ULL << (fugue_sqlParser::YEAR - 256))
      | (1ULL << (fugue_sqlParser::PLUS - 256))
      | (1ULL << (fugue_sqlParser::MINUS - 256))
      | (1ULL << (fugue_sqlParser::ASTERISK - 256))
      | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || ((((_la - 320) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 320)) & ((1ULL << (fugue_sqlParser::TILDE - 320))
      | (1ULL << (fugue_sqlParser::STRING - 320))
      | (1ULL << (fugue_sqlParser::BIGINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::SMALLINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::TINYINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 320))
      | (1ULL << (fugue_sqlParser::EXPONENT_VALUE - 320))
      | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 320))
      | (1ULL << (fugue_sqlParser::DOUBLE_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::BIGDECIMAL_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::IDENTIFIER - 320))
      | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 320)))) != 0)) {
      setState(2789);
      expression();
      setState(2794);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(2790);
        match(fugue_sqlParser::T__0);
        setState(2791);
        expression();
        setState(2796);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(2799);
    match(fugue_sqlParser::T__3);
    setState(2800);
    antlrcpp::downCast<LateralViewContext *>(_localctx)->tblName = identifier();
    setState(2812);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 368, _ctx)) {
    case 1: {
      setState(2802);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _ctx)) {
      case 1: {
        setState(2801);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(2804);
      antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext = identifier();
      antlrcpp::downCast<LateralViewContext *>(_localctx)->colName.push_back(antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext);
      setState(2809);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 367, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2805);
          match(fugue_sqlParser::T__0);
          setState(2806);
          antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext = identifier();
          antlrcpp::downCast<LateralViewContext *>(_localctx)->colName.push_back(antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext); 
        }
        setState(2811);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 367, _ctx);
      }
      break;
    }

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

  return _localctx;
}

//----------------- SetQuantifierContext ------------------------------------------------------------------

fugue_sqlParser::SetQuantifierContext::SetQuantifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::SetQuantifierContext::DISTINCT() {
  return getToken(fugue_sqlParser::DISTINCT, 0);
}

tree::TerminalNode* fugue_sqlParser::SetQuantifierContext::ALL() {
  return getToken(fugue_sqlParser::ALL, 0);
}


size_t fugue_sqlParser::SetQuantifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSetQuantifier;
}


std::any fugue_sqlParser::SetQuantifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSetQuantifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SetQuantifierContext* fugue_sqlParser::setQuantifier() {
  SetQuantifierContext *_localctx = _tracker.createInstance<SetQuantifierContext>(_ctx, getState());
  enterRule(_localctx, 284, fugue_sqlParser::RuleSetQuantifier);
  size_t _la = 0;

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

    || _la == fugue_sqlParser::DISTINCT)) {
    _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;
}

//----------------- RelationContext ------------------------------------------------------------------

fugue_sqlParser::RelationContext::RelationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::RelationPrimaryContext* fugue_sqlParser::RelationContext::relationPrimary() {
  return getRuleContext<fugue_sqlParser::RelationPrimaryContext>(0);
}

std::vector<fugue_sqlParser::JoinRelationContext *> fugue_sqlParser::RelationContext::joinRelation() {
  return getRuleContexts<fugue_sqlParser::JoinRelationContext>();
}

fugue_sqlParser::JoinRelationContext* fugue_sqlParser::RelationContext::joinRelation(size_t i) {
  return getRuleContext<fugue_sqlParser::JoinRelationContext>(i);
}


size_t fugue_sqlParser::RelationContext::getRuleIndex() const {
  return fugue_sqlParser::RuleRelation;
}


std::any fugue_sqlParser::RelationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRelation(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::RelationContext* fugue_sqlParser::relation() {
  RelationContext *_localctx = _tracker.createInstance<RelationContext>(_ctx, getState());
  enterRule(_localctx, 286, fugue_sqlParser::RuleRelation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2816);
    relationPrimary();
    setState(2820);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2817);
        joinRelation(); 
      }
      setState(2822);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 369, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- JoinRelationContext ------------------------------------------------------------------

fugue_sqlParser::JoinRelationContext::JoinRelationContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::JoinTypeContext* fugue_sqlParser::JoinRelationContext::joinType() {
  return getRuleContext<fugue_sqlParser::JoinTypeContext>(0);
}

tree::TerminalNode* fugue_sqlParser::JoinRelationContext::JOIN() {
  return getToken(fugue_sqlParser::JOIN, 0);
}

fugue_sqlParser::RelationPrimaryContext* fugue_sqlParser::JoinRelationContext::relationPrimary() {
  return getRuleContext<fugue_sqlParser::RelationPrimaryContext>(0);
}

fugue_sqlParser::JoinCriteriaContext* fugue_sqlParser::JoinRelationContext::joinCriteria() {
  return getRuleContext<fugue_sqlParser::JoinCriteriaContext>(0);
}

tree::TerminalNode* fugue_sqlParser::JoinRelationContext::NATURAL() {
  return getToken(fugue_sqlParser::NATURAL, 0);
}


size_t fugue_sqlParser::JoinRelationContext::getRuleIndex() const {
  return fugue_sqlParser::RuleJoinRelation;
}


std::any fugue_sqlParser::JoinRelationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitJoinRelation(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::JoinRelationContext* fugue_sqlParser::joinRelation() {
  JoinRelationContext *_localctx = _tracker.createInstance<JoinRelationContext>(_ctx, getState());
  enterRule(_localctx, 288, fugue_sqlParser::RuleJoinRelation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2834);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::SEMI: {
        enterOuterAlt(_localctx, 1);
        setState(2823);
        joinType();
        setState(2824);
        match(fugue_sqlParser::JOIN);
        setState(2825);
        antlrcpp::downCast<JoinRelationContext *>(_localctx)->right = relationPrimary();
        setState(2827);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 370, _ctx)) {
        case 1: {
          setState(2826);
          joinCriteria();
          break;
        }

        default:
          break;
        }
        break;
      }

      case fugue_sqlParser::NATURAL: {
        enterOuterAlt(_localctx, 2);
        setState(2829);
        match(fugue_sqlParser::NATURAL);
        setState(2830);
        joinType();
        setState(2831);
        match(fugue_sqlParser::JOIN);
        setState(2832);
        antlrcpp::downCast<JoinRelationContext *>(_localctx)->right = relationPrimary();
        break;
      }

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

  return _localctx;
}

//----------------- JoinTypeContext ------------------------------------------------------------------

fugue_sqlParser::JoinTypeContext::JoinTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::INNER() {
  return getToken(fugue_sqlParser::INNER, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::CROSS() {
  return getToken(fugue_sqlParser::CROSS, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::LEFT() {
  return getToken(fugue_sqlParser::LEFT, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::OUTER() {
  return getToken(fugue_sqlParser::OUTER, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::SEMI() {
  return getToken(fugue_sqlParser::SEMI, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::RIGHT() {
  return getToken(fugue_sqlParser::RIGHT, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::FULL() {
  return getToken(fugue_sqlParser::FULL, 0);
}

tree::TerminalNode* fugue_sqlParser::JoinTypeContext::ANTI() {
  return getToken(fugue_sqlParser::ANTI, 0);
}


size_t fugue_sqlParser::JoinTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleJoinType;
}


std::any fugue_sqlParser::JoinTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitJoinType(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::JoinTypeContext* fugue_sqlParser::joinType() {
  JoinTypeContext *_localctx = _tracker.createInstance<JoinTypeContext>(_ctx, getState());
  enterRule(_localctx, 290, fugue_sqlParser::RuleJoinType);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::INNER) {
        setState(2836);
        match(fugue_sqlParser::INNER);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2839);
      match(fugue_sqlParser::CROSS);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2840);
      match(fugue_sqlParser::LEFT);
      setState(2842);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OUTER) {
        setState(2841);
        match(fugue_sqlParser::OUTER);
      }
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LEFT) {
        setState(2844);
        match(fugue_sqlParser::LEFT);
      }
      setState(2847);
      match(fugue_sqlParser::SEMI);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2848);
      match(fugue_sqlParser::RIGHT);
      setState(2850);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OUTER) {
        setState(2849);
        match(fugue_sqlParser::OUTER);
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2852);
      match(fugue_sqlParser::FULL);
      setState(2854);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OUTER) {
        setState(2853);
        match(fugue_sqlParser::OUTER);
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2857);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LEFT) {
        setState(2856);
        match(fugue_sqlParser::LEFT);
      }
      setState(2859);
      match(fugue_sqlParser::ANTI);
      break;
    }

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

  return _localctx;
}

//----------------- JoinCriteriaContext ------------------------------------------------------------------

fugue_sqlParser::JoinCriteriaContext::JoinCriteriaContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::JoinCriteriaContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::JoinCriteriaContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::JoinCriteriaContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::JoinCriteriaContext::identifierList() {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(0);
}


size_t fugue_sqlParser::JoinCriteriaContext::getRuleIndex() const {
  return fugue_sqlParser::RuleJoinCriteria;
}


std::any fugue_sqlParser::JoinCriteriaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitJoinCriteria(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::JoinCriteriaContext* fugue_sqlParser::joinCriteria() {
  JoinCriteriaContext *_localctx = _tracker.createInstance<JoinCriteriaContext>(_ctx, getState());
  enterRule(_localctx, 292, fugue_sqlParser::RuleJoinCriteria);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2866);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ON: {
        enterOuterAlt(_localctx, 1);
        setState(2862);
        match(fugue_sqlParser::ON);
        setState(2863);
        booleanExpression(0);
        break;
      }

      case fugue_sqlParser::USING: {
        enterOuterAlt(_localctx, 2);
        setState(2864);
        match(fugue_sqlParser::USING);
        setState(2865);
        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;
}

//----------------- SampleContext ------------------------------------------------------------------

fugue_sqlParser::SampleContext::SampleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::SampleContext::TABLESAMPLE() {
  return getToken(fugue_sqlParser::TABLESAMPLE, 0);
}

fugue_sqlParser::SampleMethodContext* fugue_sqlParser::SampleContext::sampleMethod() {
  return getRuleContext<fugue_sqlParser::SampleMethodContext>(0);
}


size_t fugue_sqlParser::SampleContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSample;
}


std::any fugue_sqlParser::SampleContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSample(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::SampleContext* fugue_sqlParser::sample() {
  SampleContext *_localctx = _tracker.createInstance<SampleContext>(_ctx, getState());
  enterRule(_localctx, 294, fugue_sqlParser::RuleSample);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2868);
    match(fugue_sqlParser::TABLESAMPLE);
    setState(2869);
    match(fugue_sqlParser::T__2);
    setState(2871);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::ADD)
      | (1ULL << fugue_sqlParser::AFTER)
      | (1ULL << fugue_sqlParser::ALL)
      | (1ULL << fugue_sqlParser::ALTER)
      | (1ULL << fugue_sqlParser::ANALYZE)
      | (1ULL << fugue_sqlParser::AND)
      | (1ULL << fugue_sqlParser::ANTI)
      | (1ULL << fugue_sqlParser::ANY)
      | (1ULL << fugue_sqlParser::ARCHIVE)
      | (1ULL << fugue_sqlParser::ARRAY)
      | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
      | (1ULL << (fugue_sqlParser::AT - 64))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
      | (1ULL << (fugue_sqlParser::BETWEEN - 64))
      | (1ULL << (fugue_sqlParser::BOTH - 64))
      | (1ULL << (fugue_sqlParser::BUCKET - 64))
      | (1ULL << (fugue_sqlParser::BUCKETS - 64))
      | (1ULL << (fugue_sqlParser::BY - 64))
      | (1ULL << (fugue_sqlParser::CACHE - 64))
      | (1ULL << (fugue_sqlParser::CASCADE - 64))
      | (1ULL << (fugue_sqlParser::CASE - 64))
      | (1ULL << (fugue_sqlParser::CAST - 64))
      | (1ULL << (fugue_sqlParser::CHANGE - 64))
      | (1ULL << (fugue_sqlParser::CHECK - 64))
      | (1ULL << (fugue_sqlParser::CLEAR - 64))
      | (1ULL << (fugue_sqlParser::CLUSTER - 64))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
      | (1ULL << (fugue_sqlParser::CODEGEN - 64))
      | (1ULL << (fugue_sqlParser::COLLATE - 64))
      | (1ULL << (fugue_sqlParser::COLLECTION - 64))
      | (1ULL << (fugue_sqlParser::COLUMN - 64))
      | (1ULL << (fugue_sqlParser::COLUMNS - 64))
      | (1ULL << (fugue_sqlParser::COMMENT - 64))
      | (1ULL << (fugue_sqlParser::COMMIT - 64))
      | (1ULL << (fugue_sqlParser::COMPACT - 64))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
      | (1ULL << (fugue_sqlParser::COMPUTE - 64))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
      | (1ULL << (fugue_sqlParser::COST - 64))
      | (1ULL << (fugue_sqlParser::CREATE - 64))
      | (1ULL << (fugue_sqlParser::CROSS - 64))
      | (1ULL << (fugue_sqlParser::CUBE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
      | (1ULL << (fugue_sqlParser::DATA - 64))
      | (1ULL << (fugue_sqlParser::DATABASE - 64))
      | (1ULL << (fugue_sqlParser::DATABASES - 64))
      | (1ULL << (fugue_sqlParser::DAY - 64))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
      | (1ULL << (fugue_sqlParser::DEFINED - 64))
      | (1ULL << (fugue_sqlParser::DELETE - 64))
      | (1ULL << (fugue_sqlParser::DELIMITED - 64))
      | (1ULL << (fugue_sqlParser::DESC - 64))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
      | (1ULL << (fugue_sqlParser::DFS - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
      | (1ULL << (fugue_sqlParser::DISTINCT - 64))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
      | (1ULL << (fugue_sqlParser::DROP - 64))
      | (1ULL << (fugue_sqlParser::ELSE - 64))
      | (1ULL << (fugue_sqlParser::END - 64))
      | (1ULL << (fugue_sqlParser::ESCAPE - 64))
      | (1ULL << (fugue_sqlParser::ESCAPED - 64))
      | (1ULL << (fugue_sqlParser::EXCEPT - 64))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
      | (1ULL << (fugue_sqlParser::EXISTS - 64))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
      | (1ULL << (fugue_sqlParser::EXPORT - 64))
      | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
      | (1ULL << (fugue_sqlParser::EXTRACT - 128))
      | (1ULL << (fugue_sqlParser::FALSE - 128))
      | (1ULL << (fugue_sqlParser::FETCH - 128))
      | (1ULL << (fugue_sqlParser::FIELDS - 128))
      | (1ULL << (fugue_sqlParser::FILTER - 128))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
      | (1ULL << (fugue_sqlParser::FIRST - 128))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
      | (1ULL << (fugue_sqlParser::FOR - 128))
      | (1ULL << (fugue_sqlParser::FOREIGN - 128))
      | (1ULL << (fugue_sqlParser::FORMAT - 128))
      | (1ULL << (fugue_sqlParser::FORMATTED - 128))
      | (1ULL << (fugue_sqlParser::FROM - 128))
      | (1ULL << (fugue_sqlParser::FULL - 128))
      | (1ULL << (fugue_sqlParser::FUNCTION - 128))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
      | (1ULL << (fugue_sqlParser::GLOBAL - 128))
      | (1ULL << (fugue_sqlParser::GRANT - 128))
      | (1ULL << (fugue_sqlParser::GROUP - 128))
      | (1ULL << (fugue_sqlParser::GROUPING - 128))
      | (1ULL << (fugue_sqlParser::HAVING - 128))
      | (1ULL << (fugue_sqlParser::HOUR - 128))
      | (1ULL << (fugue_sqlParser::IF - 128))
      | (1ULL << (fugue_sqlParser::IGNORE - 128))
      | (1ULL << (fugue_sqlParser::IMPORT - 128))
      | (1ULL << (fugue_sqlParser::IN - 128))
      | (1ULL << (fugue_sqlParser::INDEX - 128))
      | (1ULL << (fugue_sqlParser::INDEXES - 128))
      | (1ULL << (fugue_sqlParser::INNER - 128))
      | (1ULL << (fugue_sqlParser::INPATH - 128))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
      | (1ULL << (fugue_sqlParser::INSERT - 128))
      | (1ULL << (fugue_sqlParser::INTERSECT - 128))
      | (1ULL << (fugue_sqlParser::INTERVAL - 128))
      | (1ULL << (fugue_sqlParser::INTO - 128))
      | (1ULL << (fugue_sqlParser::IS - 128))
      | (1ULL << (fugue_sqlParser::ITEMS - 128))
      | (1ULL << (fugue_sqlParser::JOIN - 128))
      | (1ULL << (fugue_sqlParser::KEYS - 128))
      | (1ULL << (fugue_sqlParser::LAST - 128))
      | (1ULL << (fugue_sqlParser::LATERAL - 128))
      | (1ULL << (fugue_sqlParser::LAZY - 128))
      | (1ULL << (fugue_sqlParser::LEADING - 128))
      | (1ULL << (fugue_sqlParser::LEFT - 128))
      | (1ULL << (fugue_sqlParser::LIKE - 128))
      | (1ULL << (fugue_sqlParser::LIMIT - 128))
      | (1ULL << (fugue_sqlParser::LINES - 128))
      | (1ULL << (fugue_sqlParser::LIST - 128))
      | (1ULL << (fugue_sqlParser::LOAD - 128))
      | (1ULL << (fugue_sqlParser::LOCAL - 128))
      | (1ULL << (fugue_sqlParser::LOCATION - 128))
      | (1ULL << (fugue_sqlParser::LOCK - 128))
      | (1ULL << (fugue_sqlParser::LOCKS - 128))
      | (1ULL << (fugue_sqlParser::LOGICAL - 128))
      | (1ULL << (fugue_sqlParser::MACRO - 128))
      | (1ULL << (fugue_sqlParser::MAP - 128))
      | (1ULL << (fugue_sqlParser::MATCHED - 128))
      | (1ULL << (fugue_sqlParser::MERGE - 128))
      | (1ULL << (fugue_sqlParser::MINUTE - 128))
      | (1ULL << (fugue_sqlParser::MONTH - 128))
      | (1ULL << (fugue_sqlParser::MSCK - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
      | (1ULL << (fugue_sqlParser::NO - 192))
      | (1ULL << (fugue_sqlParser::NOT - 192))
      | (1ULL << (fugue_sqlParser::THENULL - 192))
      | (1ULL << (fugue_sqlParser::THENULLS - 192))
      | (1ULL << (fugue_sqlParser::OF - 192))
      | (1ULL << (fugue_sqlParser::ON - 192))
      | (1ULL << (fugue_sqlParser::ONLY - 192))
      | (1ULL << (fugue_sqlParser::OPTION - 192))
      | (1ULL << (fugue_sqlParser::OPTIONS - 192))
      | (1ULL << (fugue_sqlParser::OR - 192))
      | (1ULL << (fugue_sqlParser::ORDER - 192))
      | (1ULL << (fugue_sqlParser::OUT - 192))
      | (1ULL << (fugue_sqlParser::OUTER - 192))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
      | (1ULL << (fugue_sqlParser::OVER - 192))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
      | (1ULL << (fugue_sqlParser::OVERLAY - 192))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
      | (1ULL << (fugue_sqlParser::PARTITION - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
      | (1ULL << (fugue_sqlParser::PIVOT - 192))
      | (1ULL << (fugue_sqlParser::PLACING - 192))
      | (1ULL << (fugue_sqlParser::POSITION - 192))
      | (1ULL << (fugue_sqlParser::PRECEDING - 192))
      | (1ULL << (fugue_sqlParser::PRIMARY - 192))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::PURGE - 192))
      | (1ULL << (fugue_sqlParser::QUERY - 192))
      | (1ULL << (fugue_sqlParser::RANGE - 192))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
      | (1ULL << (fugue_sqlParser::RECOVER - 192))
      | (1ULL << (fugue_sqlParser::REDUCE - 192))
      | (1ULL << (fugue_sqlParser::REFERENCES - 192))
      | (1ULL << (fugue_sqlParser::REFRESH - 192))
      | (1ULL << (fugue_sqlParser::RENAME - 192))
      | (1ULL << (fugue_sqlParser::REPAIR - 192))
      | (1ULL << (fugue_sqlParser::REPLACE - 192))
      | (1ULL << (fugue_sqlParser::RESET - 192))
      | (1ULL << (fugue_sqlParser::RESTRICT - 192))
      | (1ULL << (fugue_sqlParser::REVOKE - 192))
      | (1ULL << (fugue_sqlParser::RIGHT - 192))
      | (1ULL << (fugue_sqlParser::RLIKE - 192))
      | (1ULL << (fugue_sqlParser::ROLE - 192))
      | (1ULL << (fugue_sqlParser::ROLES - 192))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
      | (1ULL << (fugue_sqlParser::ROLLUP - 192))
      | (1ULL << (fugue_sqlParser::ROW - 192))
      | (1ULL << (fugue_sqlParser::ROWS - 192))
      | (1ULL << (fugue_sqlParser::SCHEMA - 192))
      | (1ULL << (fugue_sqlParser::SECOND - 192))
      | (1ULL << (fugue_sqlParser::SELECT - 192))
      | (1ULL << (fugue_sqlParser::SEMI - 192))
      | (1ULL << (fugue_sqlParser::SEPARATED - 192))
      | (1ULL << (fugue_sqlParser::SERDE - 192))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
      | (1ULL << (fugue_sqlParser::SET - 192))
      | (1ULL << (fugue_sqlParser::SETMINUS - 192))
      | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
      | (1ULL << (fugue_sqlParser::SKEWED - 256))
      | (1ULL << (fugue_sqlParser::SOME - 256))
      | (1ULL << (fugue_sqlParser::SORT - 256))
      | (1ULL << (fugue_sqlParser::SORTED - 256))
      | (1ULL << (fugue_sqlParser::START - 256))
      | (1ULL << (fugue_sqlParser::STATISTICS - 256))
      | (1ULL << (fugue_sqlParser::STORED - 256))
      | (1ULL << (fugue_sqlParser::STRATIFY - 256))
      | (1ULL << (fugue_sqlParser::STRUCT - 256))
      | (1ULL << (fugue_sqlParser::SUBSTR - 256))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
      | (1ULL << (fugue_sqlParser::TABLE - 256))
      | (1ULL << (fugue_sqlParser::TABLES - 256))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
      | (1ULL << (fugue_sqlParser::TERMINATED - 256))
      | (1ULL << (fugue_sqlParser::THEN - 256))
      | (1ULL << (fugue_sqlParser::TO - 256))
      | (1ULL << (fugue_sqlParser::TOUCH - 256))
      | (1ULL << (fugue_sqlParser::TRAILING - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
      | (1ULL << (fugue_sqlParser::TRIM - 256))
      | (1ULL << (fugue_sqlParser::TRUE - 256))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
      | (1ULL << (fugue_sqlParser::TYPE - 256))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
      | (1ULL << (fugue_sqlParser::UNCACHE - 256))
      | (1ULL << (fugue_sqlParser::UNION - 256))
      | (1ULL << (fugue_sqlParser::UNIQUE - 256))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
      | (1ULL << (fugue_sqlParser::UNLOCK - 256))
      | (1ULL << (fugue_sqlParser::UNSET - 256))
      | (1ULL << (fugue_sqlParser::UPDATE - 256))
      | (1ULL << (fugue_sqlParser::USE - 256))
      | (1ULL << (fugue_sqlParser::USER - 256))
      | (1ULL << (fugue_sqlParser::USING - 256))
      | (1ULL << (fugue_sqlParser::VALUES - 256))
      | (1ULL << (fugue_sqlParser::VIEW - 256))
      | (1ULL << (fugue_sqlParser::VIEWS - 256))
      | (1ULL << (fugue_sqlParser::WHEN - 256))
      | (1ULL << (fugue_sqlParser::WHERE - 256))
      | (1ULL << (fugue_sqlParser::WINDOW - 256))
      | (1ULL << (fugue_sqlParser::WITH - 256))
      | (1ULL << (fugue_sqlParser::YEAR - 256))
      | (1ULL << (fugue_sqlParser::PLUS - 256))
      | (1ULL << (fugue_sqlParser::MINUS - 256))
      | (1ULL << (fugue_sqlParser::ASTERISK - 256))
      | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || ((((_la - 320) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 320)) & ((1ULL << (fugue_sqlParser::TILDE - 320))
      | (1ULL << (fugue_sqlParser::STRING - 320))
      | (1ULL << (fugue_sqlParser::BIGINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::SMALLINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::TINYINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 320))
      | (1ULL << (fugue_sqlParser::EXPONENT_VALUE - 320))
      | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 320))
      | (1ULL << (fugue_sqlParser::DOUBLE_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::BIGDECIMAL_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::IDENTIFIER - 320))
      | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 320)))) != 0)) {
      setState(2870);
      sampleMethod();
    }
    setState(2873);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- SampleMethodContext ------------------------------------------------------------------

fugue_sqlParser::SampleMethodContext::SampleMethodContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::SampleMethodContext::getRuleIndex() const {
  return fugue_sqlParser::RuleSampleMethod;
}

void fugue_sqlParser::SampleMethodContext::copyFrom(SampleMethodContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- SampleByRowsContext ------------------------------------------------------------------

fugue_sqlParser::ExpressionContext* fugue_sqlParser::SampleByRowsContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::SampleByRowsContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

fugue_sqlParser::SampleByRowsContext::SampleByRowsContext(SampleMethodContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SampleByRowsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSampleByRows(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SampleByPercentileContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SampleByPercentileContext::PERCENTLIT() {
  return getToken(fugue_sqlParser::PERCENTLIT, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleByPercentileContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleByPercentileContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleByPercentileContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::SampleByPercentileContext::SampleByPercentileContext(SampleMethodContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SampleByPercentileContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSampleByPercentile(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SampleByBucketContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SampleByBucketContext::OUT() {
  return getToken(fugue_sqlParser::OUT, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleByBucketContext::OF() {
  return getToken(fugue_sqlParser::OF, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleByBucketContext::BUCKET() {
  return getToken(fugue_sqlParser::BUCKET, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::SampleByBucketContext::INTEGER_VALUE() {
  return getTokens(fugue_sqlParser::INTEGER_VALUE);
}

tree::TerminalNode* fugue_sqlParser::SampleByBucketContext::INTEGER_VALUE(size_t i) {
  return getToken(fugue_sqlParser::INTEGER_VALUE, i);
}

tree::TerminalNode* fugue_sqlParser::SampleByBucketContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::SampleByBucketContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::SampleByBucketContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

fugue_sqlParser::SampleByBucketContext::SampleByBucketContext(SampleMethodContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SampleByBucketContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSampleByBucket(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SampleByBytesContext ------------------------------------------------------------------

fugue_sqlParser::ExpressionContext* fugue_sqlParser::SampleByBytesContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

fugue_sqlParser::SampleByBytesContext::SampleByBytesContext(SampleMethodContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SampleByBytesContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSampleByBytes(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::SampleMethodContext* fugue_sqlParser::sampleMethod() {
  SampleMethodContext *_localctx = _tracker.createInstance<SampleMethodContext>(_ctx, getState());
  enterRule(_localctx, 296, fugue_sqlParser::RuleSampleMethod);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2899);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 384, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByPercentileContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2876);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(2875);
        antlrcpp::downCast<SampleByPercentileContext *>(_localctx)->negativeSign = match(fugue_sqlParser::MINUS);
      }
      setState(2878);
      antlrcpp::downCast<SampleByPercentileContext *>(_localctx)->percentage = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::INTEGER_VALUE

      || _la == fugue_sqlParser::DECIMAL_VALUE)) {
        antlrcpp::downCast<SampleByPercentileContext *>(_localctx)->percentage = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(2879);
      match(fugue_sqlParser::PERCENTLIT);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByRowsContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2880);
      expression();
      setState(2881);
      match(fugue_sqlParser::ROWS);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByBucketContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(2883);
      antlrcpp::downCast<SampleByBucketContext *>(_localctx)->sampleType = match(fugue_sqlParser::BUCKET);
      setState(2884);
      antlrcpp::downCast<SampleByBucketContext *>(_localctx)->numerator = match(fugue_sqlParser::INTEGER_VALUE);
      setState(2885);
      match(fugue_sqlParser::OUT);
      setState(2886);
      match(fugue_sqlParser::OF);
      setState(2887);
      antlrcpp::downCast<SampleByBucketContext *>(_localctx)->denominator = match(fugue_sqlParser::INTEGER_VALUE);
      setState(2896);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ON) {
        setState(2888);
        match(fugue_sqlParser::ON);
        setState(2894);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 382, _ctx)) {
        case 1: {
          setState(2889);
          identifier();
          break;
        }

        case 2: {
          setState(2890);
          qualifiedName();
          setState(2891);
          match(fugue_sqlParser::T__2);
          setState(2892);
          match(fugue_sqlParser::T__3);
          break;
        }

        default:
          break;
        }
      }
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByBytesContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(2898);
      antlrcpp::downCast<SampleByBytesContext *>(_localctx)->bytes = expression();
      break;
    }

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

  return _localctx;
}

//----------------- IdentifierListContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierListContext::IdentifierListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierSeqContext* fugue_sqlParser::IdentifierListContext::identifierSeq() {
  return getRuleContext<fugue_sqlParser::IdentifierSeqContext>(0);
}


size_t fugue_sqlParser::IdentifierListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIdentifierList;
}


std::any fugue_sqlParser::IdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIdentifierList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::identifierList() {
  IdentifierListContext *_localctx = _tracker.createInstance<IdentifierListContext>(_ctx, getState());
  enterRule(_localctx, 298, fugue_sqlParser::RuleIdentifierList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2901);
    match(fugue_sqlParser::T__2);
    setState(2902);
    identifierSeq();
    setState(2903);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierSeqContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierSeqContext::IdentifierSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ErrorCapturingIdentifierContext *> fugue_sqlParser::IdentifierSeqContext::errorCapturingIdentifier() {
  return getRuleContexts<fugue_sqlParser::ErrorCapturingIdentifierContext>();
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::IdentifierSeqContext::errorCapturingIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(i);
}


size_t fugue_sqlParser::IdentifierSeqContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIdentifierSeq;
}


std::any fugue_sqlParser::IdentifierSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIdentifierSeq(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IdentifierSeqContext* fugue_sqlParser::identifierSeq() {
  IdentifierSeqContext *_localctx = _tracker.createInstance<IdentifierSeqContext>(_ctx, getState());
  enterRule(_localctx, 300, fugue_sqlParser::RuleIdentifierSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2905);
    antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
    antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->ident.push_back(antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext);
    setState(2910);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 385, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2906);
        match(fugue_sqlParser::T__0);
        setState(2907);
        antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
        antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->ident.push_back(antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext); 
      }
      setState(2912);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 385, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OrderedIdentifierListContext ------------------------------------------------------------------

fugue_sqlParser::OrderedIdentifierListContext::OrderedIdentifierListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::OrderedIdentifierContext *> fugue_sqlParser::OrderedIdentifierListContext::orderedIdentifier() {
  return getRuleContexts<fugue_sqlParser::OrderedIdentifierContext>();
}

fugue_sqlParser::OrderedIdentifierContext* fugue_sqlParser::OrderedIdentifierListContext::orderedIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::OrderedIdentifierContext>(i);
}


size_t fugue_sqlParser::OrderedIdentifierListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleOrderedIdentifierList;
}


std::any fugue_sqlParser::OrderedIdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitOrderedIdentifierList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::OrderedIdentifierListContext* fugue_sqlParser::orderedIdentifierList() {
  OrderedIdentifierListContext *_localctx = _tracker.createInstance<OrderedIdentifierListContext>(_ctx, getState());
  enterRule(_localctx, 302, fugue_sqlParser::RuleOrderedIdentifierList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2913);
    match(fugue_sqlParser::T__2);
    setState(2914);
    orderedIdentifier();
    setState(2919);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2915);
      match(fugue_sqlParser::T__0);
      setState(2916);
      orderedIdentifier();
      setState(2921);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2922);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- OrderedIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::OrderedIdentifierContext::OrderedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::OrderedIdentifierContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::OrderedIdentifierContext::ASC() {
  return getToken(fugue_sqlParser::ASC, 0);
}

tree::TerminalNode* fugue_sqlParser::OrderedIdentifierContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}


size_t fugue_sqlParser::OrderedIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleOrderedIdentifier;
}


std::any fugue_sqlParser::OrderedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitOrderedIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::OrderedIdentifierContext* fugue_sqlParser::orderedIdentifier() {
  OrderedIdentifierContext *_localctx = _tracker.createInstance<OrderedIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 304, fugue_sqlParser::RuleOrderedIdentifier);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2924);
    antlrcpp::downCast<OrderedIdentifierContext *>(_localctx)->ident = errorCapturingIdentifier();
    setState(2926);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::ASC

    || _la == fugue_sqlParser::DESC) {
      setState(2925);
      antlrcpp::downCast<OrderedIdentifierContext *>(_localctx)->ordering = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ASC

      || _la == fugue_sqlParser::DESC)) {
        antlrcpp::downCast<OrderedIdentifierContext *>(_localctx)->ordering = _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;
}

//----------------- IdentifierCommentListContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierCommentListContext::IdentifierCommentListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::IdentifierCommentContext *> fugue_sqlParser::IdentifierCommentListContext::identifierComment() {
  return getRuleContexts<fugue_sqlParser::IdentifierCommentContext>();
}

fugue_sqlParser::IdentifierCommentContext* fugue_sqlParser::IdentifierCommentListContext::identifierComment(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierCommentContext>(i);
}


size_t fugue_sqlParser::IdentifierCommentListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIdentifierCommentList;
}


std::any fugue_sqlParser::IdentifierCommentListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIdentifierCommentList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IdentifierCommentListContext* fugue_sqlParser::identifierCommentList() {
  IdentifierCommentListContext *_localctx = _tracker.createInstance<IdentifierCommentListContext>(_ctx, getState());
  enterRule(_localctx, 306, fugue_sqlParser::RuleIdentifierCommentList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2928);
    match(fugue_sqlParser::T__2);
    setState(2929);
    identifierComment();
    setState(2934);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(2930);
      match(fugue_sqlParser::T__0);
      setState(2931);
      identifierComment();
      setState(2936);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2937);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierCommentContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierCommentContext::IdentifierCommentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::IdentifierCommentContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::IdentifierCommentContext::commentSpec() {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(0);
}


size_t fugue_sqlParser::IdentifierCommentContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIdentifierComment;
}


std::any fugue_sqlParser::IdentifierCommentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIdentifierComment(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IdentifierCommentContext* fugue_sqlParser::identifierComment() {
  IdentifierCommentContext *_localctx = _tracker.createInstance<IdentifierCommentContext>(_ctx, getState());
  enterRule(_localctx, 308, fugue_sqlParser::RuleIdentifierComment);
  size_t _la = 0;

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::COMMENT) {
      setState(2940);
      commentSpec();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- RelationPrimaryContext ------------------------------------------------------------------

fugue_sqlParser::RelationPrimaryContext::RelationPrimaryContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::RelationPrimaryContext::getRuleIndex() const {
  return fugue_sqlParser::RuleRelationPrimary;
}

void fugue_sqlParser::RelationPrimaryContext::copyFrom(RelationPrimaryContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- TableValuedFunctionContext ------------------------------------------------------------------

fugue_sqlParser::FunctionTableContext* fugue_sqlParser::TableValuedFunctionContext::functionTable() {
  return getRuleContext<fugue_sqlParser::FunctionTableContext>(0);
}

fugue_sqlParser::TableValuedFunctionContext::TableValuedFunctionContext(RelationPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TableValuedFunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableValuedFunction(this);
  else
    return visitor->visitChildren(this);
}
//----------------- InlineTableDefault2Context ------------------------------------------------------------------

fugue_sqlParser::InlineTableContext* fugue_sqlParser::InlineTableDefault2Context::inlineTable() {
  return getRuleContext<fugue_sqlParser::InlineTableContext>(0);
}

fugue_sqlParser::InlineTableDefault2Context::InlineTableDefault2Context(RelationPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::InlineTableDefault2Context::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInlineTableDefault2(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AliasedRelationContext ------------------------------------------------------------------

fugue_sqlParser::RelationContext* fugue_sqlParser::AliasedRelationContext::relation() {
  return getRuleContext<fugue_sqlParser::RelationContext>(0);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::AliasedRelationContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}

fugue_sqlParser::SampleContext* fugue_sqlParser::AliasedRelationContext::sample() {
  return getRuleContext<fugue_sqlParser::SampleContext>(0);
}

fugue_sqlParser::AliasedRelationContext::AliasedRelationContext(RelationPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AliasedRelationContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAliasedRelation(this);
  else
    return visitor->visitChildren(this);
}
//----------------- AliasedQueryContext ------------------------------------------------------------------

fugue_sqlParser::QueryContext* fugue_sqlParser::AliasedQueryContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::AliasedQueryContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}

fugue_sqlParser::SampleContext* fugue_sqlParser::AliasedQueryContext::sample() {
  return getRuleContext<fugue_sqlParser::SampleContext>(0);
}

fugue_sqlParser::AliasedQueryContext::AliasedQueryContext(RelationPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::AliasedQueryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAliasedQuery(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TableNameContext ------------------------------------------------------------------

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::TableNameContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::TableNameContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}

fugue_sqlParser::FugueDataFrameMemberContext* fugue_sqlParser::TableNameContext::fugueDataFrameMember() {
  return getRuleContext<fugue_sqlParser::FugueDataFrameMemberContext>(0);
}

fugue_sqlParser::SampleContext* fugue_sqlParser::TableNameContext::sample() {
  return getRuleContext<fugue_sqlParser::SampleContext>(0);
}

fugue_sqlParser::TableNameContext::TableNameContext(RelationPrimaryContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TableNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableName(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::RelationPrimaryContext* fugue_sqlParser::relationPrimary() {
  RelationPrimaryContext *_localctx = _tracker.createInstance<RelationPrimaryContext>(_ctx, getState());
  enterRule(_localctx, 310, fugue_sqlParser::RuleRelationPrimary);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2970);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 394, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TableNameContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2943);
      multipartIdentifier();
      setState(2945);
      _errHandler->sync(this);

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

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

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

      default:
        break;
      }
      setState(2950);
      tableAlias();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AliasedQueryContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2952);
      match(fugue_sqlParser::T__2);
      setState(2953);
      query();
      setState(2954);
      match(fugue_sqlParser::T__3);
      setState(2956);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 392, _ctx)) {
      case 1: {
        setState(2955);
        sample();
        break;
      }

      default:
        break;
      }
      setState(2958);
      tableAlias();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AliasedRelationContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(2960);
      match(fugue_sqlParser::T__2);
      setState(2961);
      relation();
      setState(2962);
      match(fugue_sqlParser::T__3);
      setState(2964);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 393, _ctx)) {
      case 1: {
        setState(2963);
        sample();
        break;
      }

      default:
        break;
      }
      setState(2966);
      tableAlias();
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InlineTableDefault2Context>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(2968);
      inlineTable();
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TableValuedFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(2969);
      functionTable();
      break;
    }

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

  return _localctx;
}

//----------------- InlineTableContext ------------------------------------------------------------------

fugue_sqlParser::InlineTableContext::InlineTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::InlineTableContext::VALUES() {
  return getToken(fugue_sqlParser::VALUES, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::InlineTableContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::InlineTableContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::InlineTableContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}


size_t fugue_sqlParser::InlineTableContext::getRuleIndex() const {
  return fugue_sqlParser::RuleInlineTable;
}


std::any fugue_sqlParser::InlineTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInlineTable(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::InlineTableContext* fugue_sqlParser::inlineTable() {
  InlineTableContext *_localctx = _tracker.createInstance<InlineTableContext>(_ctx, getState());
  enterRule(_localctx, 312, fugue_sqlParser::RuleInlineTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2972);
    match(fugue_sqlParser::VALUES);
    setState(2973);
    expression();
    setState(2978);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 395, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2974);
        match(fugue_sqlParser::T__0);
        setState(2975);
        expression(); 
      }
      setState(2980);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 395, _ctx);
    }
    setState(2981);
    tableAlias();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionTableContext ------------------------------------------------------------------

fugue_sqlParser::FunctionTableContext::FunctionTableContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::FunctionTableContext::tableAlias() {
  return getRuleContext<fugue_sqlParser::TableAliasContext>(0);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::FunctionTableContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::FunctionTableContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::FunctionTableContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}


size_t fugue_sqlParser::FunctionTableContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFunctionTable;
}


std::any fugue_sqlParser::FunctionTableContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFunctionTable(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FunctionTableContext* fugue_sqlParser::functionTable() {
  FunctionTableContext *_localctx = _tracker.createInstance<FunctionTableContext>(_ctx, getState());
  enterRule(_localctx, 314, fugue_sqlParser::RuleFunctionTable);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2983);
    antlrcpp::downCast<FunctionTableContext *>(_localctx)->funcName = errorCapturingIdentifier();
    setState(2984);
    match(fugue_sqlParser::T__2);
    setState(2993);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
      | (1ULL << fugue_sqlParser::ADD)
      | (1ULL << fugue_sqlParser::AFTER)
      | (1ULL << fugue_sqlParser::ALL)
      | (1ULL << fugue_sqlParser::ALTER)
      | (1ULL << fugue_sqlParser::ANALYZE)
      | (1ULL << fugue_sqlParser::AND)
      | (1ULL << fugue_sqlParser::ANTI)
      | (1ULL << fugue_sqlParser::ANY)
      | (1ULL << fugue_sqlParser::ARCHIVE)
      | (1ULL << fugue_sqlParser::ARRAY)
      | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
      | (1ULL << (fugue_sqlParser::AT - 64))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
      | (1ULL << (fugue_sqlParser::BETWEEN - 64))
      | (1ULL << (fugue_sqlParser::BOTH - 64))
      | (1ULL << (fugue_sqlParser::BUCKET - 64))
      | (1ULL << (fugue_sqlParser::BUCKETS - 64))
      | (1ULL << (fugue_sqlParser::BY - 64))
      | (1ULL << (fugue_sqlParser::CACHE - 64))
      | (1ULL << (fugue_sqlParser::CASCADE - 64))
      | (1ULL << (fugue_sqlParser::CASE - 64))
      | (1ULL << (fugue_sqlParser::CAST - 64))
      | (1ULL << (fugue_sqlParser::CHANGE - 64))
      | (1ULL << (fugue_sqlParser::CHECK - 64))
      | (1ULL << (fugue_sqlParser::CLEAR - 64))
      | (1ULL << (fugue_sqlParser::CLUSTER - 64))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
      | (1ULL << (fugue_sqlParser::CODEGEN - 64))
      | (1ULL << (fugue_sqlParser::COLLATE - 64))
      | (1ULL << (fugue_sqlParser::COLLECTION - 64))
      | (1ULL << (fugue_sqlParser::COLUMN - 64))
      | (1ULL << (fugue_sqlParser::COLUMNS - 64))
      | (1ULL << (fugue_sqlParser::COMMENT - 64))
      | (1ULL << (fugue_sqlParser::COMMIT - 64))
      | (1ULL << (fugue_sqlParser::COMPACT - 64))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
      | (1ULL << (fugue_sqlParser::COMPUTE - 64))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
      | (1ULL << (fugue_sqlParser::COST - 64))
      | (1ULL << (fugue_sqlParser::CREATE - 64))
      | (1ULL << (fugue_sqlParser::CROSS - 64))
      | (1ULL << (fugue_sqlParser::CUBE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
      | (1ULL << (fugue_sqlParser::DATA - 64))
      | (1ULL << (fugue_sqlParser::DATABASE - 64))
      | (1ULL << (fugue_sqlParser::DATABASES - 64))
      | (1ULL << (fugue_sqlParser::DAY - 64))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
      | (1ULL << (fugue_sqlParser::DEFINED - 64))
      | (1ULL << (fugue_sqlParser::DELETE - 64))
      | (1ULL << (fugue_sqlParser::DELIMITED - 64))
      | (1ULL << (fugue_sqlParser::DESC - 64))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
      | (1ULL << (fugue_sqlParser::DFS - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
      | (1ULL << (fugue_sqlParser::DISTINCT - 64))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
      | (1ULL << (fugue_sqlParser::DROP - 64))
      | (1ULL << (fugue_sqlParser::ELSE - 64))
      | (1ULL << (fugue_sqlParser::END - 64))
      | (1ULL << (fugue_sqlParser::ESCAPE - 64))
      | (1ULL << (fugue_sqlParser::ESCAPED - 64))
      | (1ULL << (fugue_sqlParser::EXCEPT - 64))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
      | (1ULL << (fugue_sqlParser::EXISTS - 64))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
      | (1ULL << (fugue_sqlParser::EXPORT - 64))
      | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
      | (1ULL << (fugue_sqlParser::EXTRACT - 128))
      | (1ULL << (fugue_sqlParser::FALSE - 128))
      | (1ULL << (fugue_sqlParser::FETCH - 128))
      | (1ULL << (fugue_sqlParser::FIELDS - 128))
      | (1ULL << (fugue_sqlParser::FILTER - 128))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
      | (1ULL << (fugue_sqlParser::FIRST - 128))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
      | (1ULL << (fugue_sqlParser::FOR - 128))
      | (1ULL << (fugue_sqlParser::FOREIGN - 128))
      | (1ULL << (fugue_sqlParser::FORMAT - 128))
      | (1ULL << (fugue_sqlParser::FORMATTED - 128))
      | (1ULL << (fugue_sqlParser::FROM - 128))
      | (1ULL << (fugue_sqlParser::FULL - 128))
      | (1ULL << (fugue_sqlParser::FUNCTION - 128))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
      | (1ULL << (fugue_sqlParser::GLOBAL - 128))
      | (1ULL << (fugue_sqlParser::GRANT - 128))
      | (1ULL << (fugue_sqlParser::GROUP - 128))
      | (1ULL << (fugue_sqlParser::GROUPING - 128))
      | (1ULL << (fugue_sqlParser::HAVING - 128))
      | (1ULL << (fugue_sqlParser::HOUR - 128))
      | (1ULL << (fugue_sqlParser::IF - 128))
      | (1ULL << (fugue_sqlParser::IGNORE - 128))
      | (1ULL << (fugue_sqlParser::IMPORT - 128))
      | (1ULL << (fugue_sqlParser::IN - 128))
      | (1ULL << (fugue_sqlParser::INDEX - 128))
      | (1ULL << (fugue_sqlParser::INDEXES - 128))
      | (1ULL << (fugue_sqlParser::INNER - 128))
      | (1ULL << (fugue_sqlParser::INPATH - 128))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
      | (1ULL << (fugue_sqlParser::INSERT - 128))
      | (1ULL << (fugue_sqlParser::INTERSECT - 128))
      | (1ULL << (fugue_sqlParser::INTERVAL - 128))
      | (1ULL << (fugue_sqlParser::INTO - 128))
      | (1ULL << (fugue_sqlParser::IS - 128))
      | (1ULL << (fugue_sqlParser::ITEMS - 128))
      | (1ULL << (fugue_sqlParser::JOIN - 128))
      | (1ULL << (fugue_sqlParser::KEYS - 128))
      | (1ULL << (fugue_sqlParser::LAST - 128))
      | (1ULL << (fugue_sqlParser::LATERAL - 128))
      | (1ULL << (fugue_sqlParser::LAZY - 128))
      | (1ULL << (fugue_sqlParser::LEADING - 128))
      | (1ULL << (fugue_sqlParser::LEFT - 128))
      | (1ULL << (fugue_sqlParser::LIKE - 128))
      | (1ULL << (fugue_sqlParser::LIMIT - 128))
      | (1ULL << (fugue_sqlParser::LINES - 128))
      | (1ULL << (fugue_sqlParser::LIST - 128))
      | (1ULL << (fugue_sqlParser::LOAD - 128))
      | (1ULL << (fugue_sqlParser::LOCAL - 128))
      | (1ULL << (fugue_sqlParser::LOCATION - 128))
      | (1ULL << (fugue_sqlParser::LOCK - 128))
      | (1ULL << (fugue_sqlParser::LOCKS - 128))
      | (1ULL << (fugue_sqlParser::LOGICAL - 128))
      | (1ULL << (fugue_sqlParser::MACRO - 128))
      | (1ULL << (fugue_sqlParser::MAP - 128))
      | (1ULL << (fugue_sqlParser::MATCHED - 128))
      | (1ULL << (fugue_sqlParser::MERGE - 128))
      | (1ULL << (fugue_sqlParser::MINUTE - 128))
      | (1ULL << (fugue_sqlParser::MONTH - 128))
      | (1ULL << (fugue_sqlParser::MSCK - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
      | (1ULL << (fugue_sqlParser::NO - 192))
      | (1ULL << (fugue_sqlParser::NOT - 192))
      | (1ULL << (fugue_sqlParser::THENULL - 192))
      | (1ULL << (fugue_sqlParser::THENULLS - 192))
      | (1ULL << (fugue_sqlParser::OF - 192))
      | (1ULL << (fugue_sqlParser::ON - 192))
      | (1ULL << (fugue_sqlParser::ONLY - 192))
      | (1ULL << (fugue_sqlParser::OPTION - 192))
      | (1ULL << (fugue_sqlParser::OPTIONS - 192))
      | (1ULL << (fugue_sqlParser::OR - 192))
      | (1ULL << (fugue_sqlParser::ORDER - 192))
      | (1ULL << (fugue_sqlParser::OUT - 192))
      | (1ULL << (fugue_sqlParser::OUTER - 192))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
      | (1ULL << (fugue_sqlParser::OVER - 192))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
      | (1ULL << (fugue_sqlParser::OVERLAY - 192))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
      | (1ULL << (fugue_sqlParser::PARTITION - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
      | (1ULL << (fugue_sqlParser::PIVOT - 192))
      | (1ULL << (fugue_sqlParser::PLACING - 192))
      | (1ULL << (fugue_sqlParser::POSITION - 192))
      | (1ULL << (fugue_sqlParser::PRECEDING - 192))
      | (1ULL << (fugue_sqlParser::PRIMARY - 192))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::PURGE - 192))
      | (1ULL << (fugue_sqlParser::QUERY - 192))
      | (1ULL << (fugue_sqlParser::RANGE - 192))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
      | (1ULL << (fugue_sqlParser::RECOVER - 192))
      | (1ULL << (fugue_sqlParser::REDUCE - 192))
      | (1ULL << (fugue_sqlParser::REFERENCES - 192))
      | (1ULL << (fugue_sqlParser::REFRESH - 192))
      | (1ULL << (fugue_sqlParser::RENAME - 192))
      | (1ULL << (fugue_sqlParser::REPAIR - 192))
      | (1ULL << (fugue_sqlParser::REPLACE - 192))
      | (1ULL << (fugue_sqlParser::RESET - 192))
      | (1ULL << (fugue_sqlParser::RESTRICT - 192))
      | (1ULL << (fugue_sqlParser::REVOKE - 192))
      | (1ULL << (fugue_sqlParser::RIGHT - 192))
      | (1ULL << (fugue_sqlParser::RLIKE - 192))
      | (1ULL << (fugue_sqlParser::ROLE - 192))
      | (1ULL << (fugue_sqlParser::ROLES - 192))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
      | (1ULL << (fugue_sqlParser::ROLLUP - 192))
      | (1ULL << (fugue_sqlParser::ROW - 192))
      | (1ULL << (fugue_sqlParser::ROWS - 192))
      | (1ULL << (fugue_sqlParser::SCHEMA - 192))
      | (1ULL << (fugue_sqlParser::SECOND - 192))
      | (1ULL << (fugue_sqlParser::SELECT - 192))
      | (1ULL << (fugue_sqlParser::SEMI - 192))
      | (1ULL << (fugue_sqlParser::SEPARATED - 192))
      | (1ULL << (fugue_sqlParser::SERDE - 192))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
      | (1ULL << (fugue_sqlParser::SET - 192))
      | (1ULL << (fugue_sqlParser::SETMINUS - 192))
      | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
      | (1ULL << (fugue_sqlParser::SKEWED - 256))
      | (1ULL << (fugue_sqlParser::SOME - 256))
      | (1ULL << (fugue_sqlParser::SORT - 256))
      | (1ULL << (fugue_sqlParser::SORTED - 256))
      | (1ULL << (fugue_sqlParser::START - 256))
      | (1ULL << (fugue_sqlParser::STATISTICS - 256))
      | (1ULL << (fugue_sqlParser::STORED - 256))
      | (1ULL << (fugue_sqlParser::STRATIFY - 256))
      | (1ULL << (fugue_sqlParser::STRUCT - 256))
      | (1ULL << (fugue_sqlParser::SUBSTR - 256))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
      | (1ULL << (fugue_sqlParser::TABLE - 256))
      | (1ULL << (fugue_sqlParser::TABLES - 256))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
      | (1ULL << (fugue_sqlParser::TERMINATED - 256))
      | (1ULL << (fugue_sqlParser::THEN - 256))
      | (1ULL << (fugue_sqlParser::TO - 256))
      | (1ULL << (fugue_sqlParser::TOUCH - 256))
      | (1ULL << (fugue_sqlParser::TRAILING - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
      | (1ULL << (fugue_sqlParser::TRIM - 256))
      | (1ULL << (fugue_sqlParser::TRUE - 256))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
      | (1ULL << (fugue_sqlParser::TYPE - 256))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
      | (1ULL << (fugue_sqlParser::UNCACHE - 256))
      | (1ULL << (fugue_sqlParser::UNION - 256))
      | (1ULL << (fugue_sqlParser::UNIQUE - 256))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
      | (1ULL << (fugue_sqlParser::UNLOCK - 256))
      | (1ULL << (fugue_sqlParser::UNSET - 256))
      | (1ULL << (fugue_sqlParser::UPDATE - 256))
      | (1ULL << (fugue_sqlParser::USE - 256))
      | (1ULL << (fugue_sqlParser::USER - 256))
      | (1ULL << (fugue_sqlParser::USING - 256))
      | (1ULL << (fugue_sqlParser::VALUES - 256))
      | (1ULL << (fugue_sqlParser::VIEW - 256))
      | (1ULL << (fugue_sqlParser::VIEWS - 256))
      | (1ULL << (fugue_sqlParser::WHEN - 256))
      | (1ULL << (fugue_sqlParser::WHERE - 256))
      | (1ULL << (fugue_sqlParser::WINDOW - 256))
      | (1ULL << (fugue_sqlParser::WITH - 256))
      | (1ULL << (fugue_sqlParser::YEAR - 256))
      | (1ULL << (fugue_sqlParser::PLUS - 256))
      | (1ULL << (fugue_sqlParser::MINUS - 256))
      | (1ULL << (fugue_sqlParser::ASTERISK - 256))
      | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || ((((_la - 320) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 320)) & ((1ULL << (fugue_sqlParser::TILDE - 320))
      | (1ULL << (fugue_sqlParser::STRING - 320))
      | (1ULL << (fugue_sqlParser::BIGINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::SMALLINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::TINYINT_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 320))
      | (1ULL << (fugue_sqlParser::EXPONENT_VALUE - 320))
      | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 320))
      | (1ULL << (fugue_sqlParser::DOUBLE_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::BIGDECIMAL_LITERAL - 320))
      | (1ULL << (fugue_sqlParser::IDENTIFIER - 320))
      | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 320)))) != 0)) {
      setState(2985);
      expression();
      setState(2990);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(2986);
        match(fugue_sqlParser::T__0);
        setState(2987);
        expression();
        setState(2992);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(2995);
    match(fugue_sqlParser::T__3);
    setState(2996);
    tableAlias();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableAliasContext ------------------------------------------------------------------

fugue_sqlParser::TableAliasContext::TableAliasContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::StrictIdentifierContext* fugue_sqlParser::TableAliasContext::strictIdentifier() {
  return getRuleContext<fugue_sqlParser::StrictIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::TableAliasContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::TableAliasContext::identifierList() {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(0);
}


size_t fugue_sqlParser::TableAliasContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTableAlias;
}


std::any fugue_sqlParser::TableAliasContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableAlias(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TableAliasContext* fugue_sqlParser::tableAlias() {
  TableAliasContext *_localctx = _tracker.createInstance<TableAliasContext>(_ctx, getState());
  enterRule(_localctx, 316, fugue_sqlParser::RuleTableAlias);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 400, _ctx)) {
    case 1: {
      setState(2999);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 398, _ctx)) {
      case 1: {
        setState(2998);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(3001);
      strictIdentifier();
      setState(3003);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 399, _ctx)) {
      case 1: {
        setState(3002);
        identifierList();
        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;
}

//----------------- RowFormatContext ------------------------------------------------------------------

fugue_sqlParser::RowFormatContext::RowFormatContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::RowFormatContext::getRuleIndex() const {
  return fugue_sqlParser::RuleRowFormat;
}

void fugue_sqlParser::RowFormatContext::copyFrom(RowFormatContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- RowFormatSerdeContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RowFormatSerdeContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatSerdeContext::FORMAT() {
  return getToken(fugue_sqlParser::FORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatSerdeContext::SERDE() {
  return getToken(fugue_sqlParser::SERDE, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatSerdeContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatSerdeContext::WITH() {
  return getToken(fugue_sqlParser::WITH, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatSerdeContext::SERDEPROPERTIES() {
  return getToken(fugue_sqlParser::SERDEPROPERTIES, 0);
}

fugue_sqlParser::TablePropertyListContext* fugue_sqlParser::RowFormatSerdeContext::tablePropertyList() {
  return getRuleContext<fugue_sqlParser::TablePropertyListContext>(0);
}

fugue_sqlParser::RowFormatSerdeContext::RowFormatSerdeContext(RowFormatContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RowFormatSerdeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRowFormatSerde(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RowFormatDelimitedContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::FORMAT() {
  return getToken(fugue_sqlParser::FORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::DELIMITED() {
  return getToken(fugue_sqlParser::DELIMITED, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::FIELDS() {
  return getToken(fugue_sqlParser::FIELDS, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::RowFormatDelimitedContext::TERMINATED() {
  return getTokens(fugue_sqlParser::TERMINATED);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::TERMINATED(size_t i) {
  return getToken(fugue_sqlParser::TERMINATED, i);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::RowFormatDelimitedContext::BY() {
  return getTokens(fugue_sqlParser::BY);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::BY(size_t i) {
  return getToken(fugue_sqlParser::BY, i);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::COLLECTION() {
  return getToken(fugue_sqlParser::COLLECTION, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::ITEMS() {
  return getToken(fugue_sqlParser::ITEMS, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::MAP() {
  return getToken(fugue_sqlParser::MAP, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::KEYS() {
  return getToken(fugue_sqlParser::KEYS, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::LINES() {
  return getToken(fugue_sqlParser::LINES, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::DEFINED() {
  return getToken(fugue_sqlParser::DEFINED, 0);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::RowFormatDelimitedContext::STRING() {
  return getTokens(fugue_sqlParser::STRING);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::STRING(size_t i) {
  return getToken(fugue_sqlParser::STRING, i);
}

tree::TerminalNode* fugue_sqlParser::RowFormatDelimitedContext::ESCAPED() {
  return getToken(fugue_sqlParser::ESCAPED, 0);
}

fugue_sqlParser::RowFormatDelimitedContext::RowFormatDelimitedContext(RowFormatContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RowFormatDelimitedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRowFormatDelimited(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::RowFormatContext* fugue_sqlParser::rowFormat() {
  RowFormatContext *_localctx = _tracker.createInstance<RowFormatContext>(_ctx, getState());
  enterRule(_localctx, 318, fugue_sqlParser::RuleRowFormat);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3056);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 408, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RowFormatSerdeContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3007);
      match(fugue_sqlParser::ROW);
      setState(3008);
      match(fugue_sqlParser::FORMAT);
      setState(3009);
      match(fugue_sqlParser::SERDE);
      setState(3010);
      antlrcpp::downCast<RowFormatSerdeContext *>(_localctx)->name = match(fugue_sqlParser::STRING);
      setState(3014);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 401, _ctx)) {
      case 1: {
        setState(3011);
        match(fugue_sqlParser::WITH);
        setState(3012);
        match(fugue_sqlParser::SERDEPROPERTIES);
        setState(3013);
        antlrcpp::downCast<RowFormatSerdeContext *>(_localctx)->props = tablePropertyList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RowFormatDelimitedContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3016);
      match(fugue_sqlParser::ROW);
      setState(3017);
      match(fugue_sqlParser::FORMAT);
      setState(3018);
      match(fugue_sqlParser::DELIMITED);
      setState(3028);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 403, _ctx)) {
      case 1: {
        setState(3019);
        match(fugue_sqlParser::FIELDS);
        setState(3020);
        match(fugue_sqlParser::TERMINATED);
        setState(3021);
        match(fugue_sqlParser::BY);
        setState(3022);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->fieldsTerminatedBy = match(fugue_sqlParser::STRING);
        setState(3026);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 402, _ctx)) {
        case 1: {
          setState(3023);
          match(fugue_sqlParser::ESCAPED);
          setState(3024);
          match(fugue_sqlParser::BY);
          setState(3025);
          antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->escapedBy = match(fugue_sqlParser::STRING);
          break;
        }

        default:
          break;
        }
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 404, _ctx)) {
      case 1: {
        setState(3030);
        match(fugue_sqlParser::COLLECTION);
        setState(3031);
        match(fugue_sqlParser::ITEMS);
        setState(3032);
        match(fugue_sqlParser::TERMINATED);
        setState(3033);
        match(fugue_sqlParser::BY);
        setState(3034);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->collectionItemsTerminatedBy = match(fugue_sqlParser::STRING);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 405, _ctx)) {
      case 1: {
        setState(3037);
        match(fugue_sqlParser::MAP);
        setState(3038);
        match(fugue_sqlParser::KEYS);
        setState(3039);
        match(fugue_sqlParser::TERMINATED);
        setState(3040);
        match(fugue_sqlParser::BY);
        setState(3041);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->keysTerminatedBy = match(fugue_sqlParser::STRING);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx)) {
      case 1: {
        setState(3044);
        match(fugue_sqlParser::LINES);
        setState(3045);
        match(fugue_sqlParser::TERMINATED);
        setState(3046);
        match(fugue_sqlParser::BY);
        setState(3047);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->linesSeparatedBy = match(fugue_sqlParser::STRING);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 407, _ctx)) {
      case 1: {
        setState(3050);
        match(fugue_sqlParser::THENULL);
        setState(3051);
        match(fugue_sqlParser::DEFINED);
        setState(3052);
        match(fugue_sqlParser::AS);
        setState(3053);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->nullDefinedAs = match(fugue_sqlParser::STRING);
        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;
}

//----------------- MultipartIdentifierListContext ------------------------------------------------------------------

fugue_sqlParser::MultipartIdentifierListContext::MultipartIdentifierListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::MultipartIdentifierContext *> fugue_sqlParser::MultipartIdentifierListContext::multipartIdentifier() {
  return getRuleContexts<fugue_sqlParser::MultipartIdentifierContext>();
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::MultipartIdentifierListContext::multipartIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(i);
}


size_t fugue_sqlParser::MultipartIdentifierListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleMultipartIdentifierList;
}


std::any fugue_sqlParser::MultipartIdentifierListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMultipartIdentifierList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::MultipartIdentifierListContext* fugue_sqlParser::multipartIdentifierList() {
  MultipartIdentifierListContext *_localctx = _tracker.createInstance<MultipartIdentifierListContext>(_ctx, getState());
  enterRule(_localctx, 320, fugue_sqlParser::RuleMultipartIdentifierList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3058);
    multipartIdentifier();
    setState(3063);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(3059);
      match(fugue_sqlParser::T__0);
      setState(3060);
      multipartIdentifier();
      setState(3065);
      _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;
}

//----------------- MultipartIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::MultipartIdentifierContext::MultipartIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ErrorCapturingIdentifierContext *> fugue_sqlParser::MultipartIdentifierContext::errorCapturingIdentifier() {
  return getRuleContexts<fugue_sqlParser::ErrorCapturingIdentifierContext>();
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::MultipartIdentifierContext::errorCapturingIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(i);
}


size_t fugue_sqlParser::MultipartIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleMultipartIdentifier;
}


std::any fugue_sqlParser::MultipartIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMultipartIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::multipartIdentifier() {
  MultipartIdentifierContext *_localctx = _tracker.createInstance<MultipartIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 322, fugue_sqlParser::RuleMultipartIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3066);
    antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
    antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->parts.push_back(antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext);
    setState(3071);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 410, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3067);
        match(fugue_sqlParser::T__6);
        setState(3068);
        antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
        antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->parts.push_back(antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext); 
      }
      setState(3073);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 410, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TableIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::TableIdentifierContext::TableIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ErrorCapturingIdentifierContext *> fugue_sqlParser::TableIdentifierContext::errorCapturingIdentifier() {
  return getRuleContexts<fugue_sqlParser::ErrorCapturingIdentifierContext>();
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::TableIdentifierContext::errorCapturingIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(i);
}


size_t fugue_sqlParser::TableIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTableIdentifier;
}


std::any fugue_sqlParser::TableIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTableIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TableIdentifierContext* fugue_sqlParser::tableIdentifier() {
  TableIdentifierContext *_localctx = _tracker.createInstance<TableIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 324, fugue_sqlParser::RuleTableIdentifier);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 411, _ctx)) {
    case 1: {
      setState(3074);
      antlrcpp::downCast<TableIdentifierContext *>(_localctx)->db = errorCapturingIdentifier();
      setState(3075);
      match(fugue_sqlParser::T__6);
      break;
    }

    default:
      break;
    }
    setState(3079);
    antlrcpp::downCast<TableIdentifierContext *>(_localctx)->table = errorCapturingIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::FunctionIdentifierContext::FunctionIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ErrorCapturingIdentifierContext *> fugue_sqlParser::FunctionIdentifierContext::errorCapturingIdentifier() {
  return getRuleContexts<fugue_sqlParser::ErrorCapturingIdentifierContext>();
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::FunctionIdentifierContext::errorCapturingIdentifier(size_t i) {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(i);
}


size_t fugue_sqlParser::FunctionIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFunctionIdentifier;
}


std::any fugue_sqlParser::FunctionIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFunctionIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FunctionIdentifierContext* fugue_sqlParser::functionIdentifier() {
  FunctionIdentifierContext *_localctx = _tracker.createInstance<FunctionIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 326, fugue_sqlParser::RuleFunctionIdentifier);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 412, _ctx)) {
    case 1: {
      setState(3081);
      antlrcpp::downCast<FunctionIdentifierContext *>(_localctx)->db = errorCapturingIdentifier();
      setState(3082);
      match(fugue_sqlParser::T__6);
      break;
    }

    default:
      break;
    }
    setState(3086);
    antlrcpp::downCast<FunctionIdentifierContext *>(_localctx)->function = errorCapturingIdentifier();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NamedExpressionContext ------------------------------------------------------------------

fugue_sqlParser::NamedExpressionContext::NamedExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::NamedExpressionContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

fugue_sqlParser::IdentifierListContext* fugue_sqlParser::NamedExpressionContext::identifierList() {
  return getRuleContext<fugue_sqlParser::IdentifierListContext>(0);
}

tree::TerminalNode* fugue_sqlParser::NamedExpressionContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::NamedExpressionContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}


size_t fugue_sqlParser::NamedExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNamedExpression;
}


std::any fugue_sqlParser::NamedExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNamedExpression(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NamedExpressionContext* fugue_sqlParser::namedExpression() {
  NamedExpressionContext *_localctx = _tracker.createInstance<NamedExpressionContext>(_ctx, getState());
  enterRule(_localctx, 328, fugue_sqlParser::RuleNamedExpression);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 415, _ctx)) {
    case 1: {
      setState(3090);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 413, _ctx)) {
      case 1: {
        setState(3089);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(3094);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::ADD:
        case fugue_sqlParser::AFTER:
        case fugue_sqlParser::ALL:
        case fugue_sqlParser::ALTER:
        case fugue_sqlParser::ANALYZE:
        case fugue_sqlParser::AND:
        case fugue_sqlParser::ANTI:
        case fugue_sqlParser::ANY:
        case fugue_sqlParser::ARCHIVE:
        case fugue_sqlParser::ARRAY:
        case fugue_sqlParser::AS:
        case fugue_sqlParser::ASC:
        case fugue_sqlParser::AT:
        case fugue_sqlParser::AUTHORIZATION:
        case fugue_sqlParser::BETWEEN:
        case fugue_sqlParser::BOTH:
        case fugue_sqlParser::BUCKET:
        case fugue_sqlParser::BUCKETS:
        case fugue_sqlParser::BY:
        case fugue_sqlParser::CACHE:
        case fugue_sqlParser::CASCADE:
        case fugue_sqlParser::CASE:
        case fugue_sqlParser::CAST:
        case fugue_sqlParser::CHANGE:
        case fugue_sqlParser::CHECK:
        case fugue_sqlParser::CLEAR:
        case fugue_sqlParser::CLUSTER:
        case fugue_sqlParser::CLUSTERED:
        case fugue_sqlParser::CODEGEN:
        case fugue_sqlParser::COLLATE:
        case fugue_sqlParser::COLLECTION:
        case fugue_sqlParser::COLUMN:
        case fugue_sqlParser::COLUMNS:
        case fugue_sqlParser::COMMENT:
        case fugue_sqlParser::COMMIT:
        case fugue_sqlParser::COMPACT:
        case fugue_sqlParser::COMPACTIONS:
        case fugue_sqlParser::COMPUTE:
        case fugue_sqlParser::CONCATENATE:
        case fugue_sqlParser::CONSTRAINT:
        case fugue_sqlParser::COST:
        case fugue_sqlParser::CREATE:
        case fugue_sqlParser::CROSS:
        case fugue_sqlParser::CUBE:
        case fugue_sqlParser::CURRENT:
        case fugue_sqlParser::CURRENT_DATE:
        case fugue_sqlParser::CURRENT_TIME:
        case fugue_sqlParser::CURRENT_TIMESTAMP:
        case fugue_sqlParser::CURRENT_USER:
        case fugue_sqlParser::DATA:
        case fugue_sqlParser::DATABASE:
        case fugue_sqlParser::DATABASES:
        case fugue_sqlParser::DAY:
        case fugue_sqlParser::DBPROPERTIES:
        case fugue_sqlParser::DEFINED:
        case fugue_sqlParser::DELETE:
        case fugue_sqlParser::DELIMITED:
        case fugue_sqlParser::DESC:
        case fugue_sqlParser::DESCRIBE:
        case fugue_sqlParser::DFS:
        case fugue_sqlParser::DIRECTORIES:
        case fugue_sqlParser::DIRECTORY:
        case fugue_sqlParser::DISTINCT:
        case fugue_sqlParser::DISTRIBUTE:
        case fugue_sqlParser::DROP:
        case fugue_sqlParser::ELSE:
        case fugue_sqlParser::END:
        case fugue_sqlParser::ESCAPE:
        case fugue_sqlParser::ESCAPED:
        case fugue_sqlParser::EXCEPT:
        case fugue_sqlParser::EXCHANGE:
        case fugue_sqlParser::EXISTS:
        case fugue_sqlParser::EXPLAIN:
        case fugue_sqlParser::EXPORT:
        case fugue_sqlParser::EXTENDED:
        case fugue_sqlParser::EXTERNAL:
        case fugue_sqlParser::EXTRACT:
        case fugue_sqlParser::FALSE:
        case fugue_sqlParser::FETCH:
        case fugue_sqlParser::FIELDS:
        case fugue_sqlParser::FILTER:
        case fugue_sqlParser::FILEFORMAT:
        case fugue_sqlParser::FIRST:
        case fugue_sqlParser::FOLLOWING:
        case fugue_sqlParser::FOR:
        case fugue_sqlParser::FOREIGN:
        case fugue_sqlParser::FORMAT:
        case fugue_sqlParser::FORMATTED:
        case fugue_sqlParser::FROM:
        case fugue_sqlParser::FULL:
        case fugue_sqlParser::FUNCTION:
        case fugue_sqlParser::FUNCTIONS:
        case fugue_sqlParser::GLOBAL:
        case fugue_sqlParser::GRANT:
        case fugue_sqlParser::GROUP:
        case fugue_sqlParser::GROUPING:
        case fugue_sqlParser::HAVING:
        case fugue_sqlParser::HOUR:
        case fugue_sqlParser::IF:
        case fugue_sqlParser::IGNORE:
        case fugue_sqlParser::IMPORT:
        case fugue_sqlParser::IN:
        case fugue_sqlParser::INDEX:
        case fugue_sqlParser::INDEXES:
        case fugue_sqlParser::INNER:
        case fugue_sqlParser::INPATH:
        case fugue_sqlParser::INPUTFORMAT:
        case fugue_sqlParser::INSERT:
        case fugue_sqlParser::INTERSECT:
        case fugue_sqlParser::INTERVAL:
        case fugue_sqlParser::INTO:
        case fugue_sqlParser::IS:
        case fugue_sqlParser::ITEMS:
        case fugue_sqlParser::JOIN:
        case fugue_sqlParser::KEYS:
        case fugue_sqlParser::LAST:
        case fugue_sqlParser::LATERAL:
        case fugue_sqlParser::LAZY:
        case fugue_sqlParser::LEADING:
        case fugue_sqlParser::LEFT:
        case fugue_sqlParser::LIKE:
        case fugue_sqlParser::LIMIT:
        case fugue_sqlParser::LINES:
        case fugue_sqlParser::LIST:
        case fugue_sqlParser::LOAD:
        case fugue_sqlParser::LOCAL:
        case fugue_sqlParser::LOCATION:
        case fugue_sqlParser::LOCK:
        case fugue_sqlParser::LOCKS:
        case fugue_sqlParser::LOGICAL:
        case fugue_sqlParser::MACRO:
        case fugue_sqlParser::MAP:
        case fugue_sqlParser::MATCHED:
        case fugue_sqlParser::MERGE:
        case fugue_sqlParser::MINUTE:
        case fugue_sqlParser::MONTH:
        case fugue_sqlParser::MSCK:
        case fugue_sqlParser::NAMESPACE:
        case fugue_sqlParser::NAMESPACES:
        case fugue_sqlParser::NATURAL:
        case fugue_sqlParser::NO:
        case fugue_sqlParser::NOT:
        case fugue_sqlParser::THENULL:
        case fugue_sqlParser::THENULLS:
        case fugue_sqlParser::OF:
        case fugue_sqlParser::ON:
        case fugue_sqlParser::ONLY:
        case fugue_sqlParser::OPTION:
        case fugue_sqlParser::OPTIONS:
        case fugue_sqlParser::OR:
        case fugue_sqlParser::ORDER:
        case fugue_sqlParser::OUT:
        case fugue_sqlParser::OUTER:
        case fugue_sqlParser::OUTPUTFORMAT:
        case fugue_sqlParser::OVER:
        case fugue_sqlParser::OVERLAPS:
        case fugue_sqlParser::OVERLAY:
        case fugue_sqlParser::OVERWRITE:
        case fugue_sqlParser::PARTITION:
        case fugue_sqlParser::PARTITIONED:
        case fugue_sqlParser::PARTITIONS:
        case fugue_sqlParser::PERCENTLIT:
        case fugue_sqlParser::PIVOT:
        case fugue_sqlParser::PLACING:
        case fugue_sqlParser::POSITION:
        case fugue_sqlParser::PRECEDING:
        case fugue_sqlParser::PRIMARY:
        case fugue_sqlParser::PRINCIPALS:
        case fugue_sqlParser::PROPERTIES:
        case fugue_sqlParser::PURGE:
        case fugue_sqlParser::QUERY:
        case fugue_sqlParser::RANGE:
        case fugue_sqlParser::RECORDREADER:
        case fugue_sqlParser::RECORDWRITER:
        case fugue_sqlParser::RECOVER:
        case fugue_sqlParser::REDUCE:
        case fugue_sqlParser::REFERENCES:
        case fugue_sqlParser::REFRESH:
        case fugue_sqlParser::RENAME:
        case fugue_sqlParser::REPAIR:
        case fugue_sqlParser::REPLACE:
        case fugue_sqlParser::RESET:
        case fugue_sqlParser::RESTRICT:
        case fugue_sqlParser::REVOKE:
        case fugue_sqlParser::RIGHT:
        case fugue_sqlParser::RLIKE:
        case fugue_sqlParser::ROLE:
        case fugue_sqlParser::ROLES:
        case fugue_sqlParser::ROLLBACK:
        case fugue_sqlParser::ROLLUP:
        case fugue_sqlParser::ROW:
        case fugue_sqlParser::ROWS:
        case fugue_sqlParser::SCHEMA:
        case fugue_sqlParser::SECOND:
        case fugue_sqlParser::SELECT:
        case fugue_sqlParser::SEMI:
        case fugue_sqlParser::SEPARATED:
        case fugue_sqlParser::SERDE:
        case fugue_sqlParser::SERDEPROPERTIES:
        case fugue_sqlParser::SESSION_USER:
        case fugue_sqlParser::SET:
        case fugue_sqlParser::SETMINUS:
        case fugue_sqlParser::SETS:
        case fugue_sqlParser::SHOW:
        case fugue_sqlParser::SKEWED:
        case fugue_sqlParser::SOME:
        case fugue_sqlParser::SORT:
        case fugue_sqlParser::SORTED:
        case fugue_sqlParser::START:
        case fugue_sqlParser::STATISTICS:
        case fugue_sqlParser::STORED:
        case fugue_sqlParser::STRATIFY:
        case fugue_sqlParser::STRUCT:
        case fugue_sqlParser::SUBSTR:
        case fugue_sqlParser::SUBSTRING:
        case fugue_sqlParser::TABLE:
        case fugue_sqlParser::TABLES:
        case fugue_sqlParser::TABLESAMPLE:
        case fugue_sqlParser::TBLPROPERTIES:
        case fugue_sqlParser::TEMPORARY:
        case fugue_sqlParser::TERMINATED:
        case fugue_sqlParser::THEN:
        case fugue_sqlParser::TO:
        case fugue_sqlParser::TOUCH:
        case fugue_sqlParser::TRAILING:
        case fugue_sqlParser::TRANSACTION:
        case fugue_sqlParser::TRANSACTIONS:
        case fugue_sqlParser::TRANSFORM:
        case fugue_sqlParser::TRIM:
        case fugue_sqlParser::TRUE:
        case fugue_sqlParser::TRUNCATE:
        case fugue_sqlParser::TYPE:
        case fugue_sqlParser::UNARCHIVE:
        case fugue_sqlParser::UNBOUNDED:
        case fugue_sqlParser::UNCACHE:
        case fugue_sqlParser::UNION:
        case fugue_sqlParser::UNIQUE:
        case fugue_sqlParser::UNKNOWN:
        case fugue_sqlParser::UNLOCK:
        case fugue_sqlParser::UNSET:
        case fugue_sqlParser::UPDATE:
        case fugue_sqlParser::USE:
        case fugue_sqlParser::USER:
        case fugue_sqlParser::USING:
        case fugue_sqlParser::VALUES:
        case fugue_sqlParser::VIEW:
        case fugue_sqlParser::VIEWS:
        case fugue_sqlParser::WHEN:
        case fugue_sqlParser::WHERE:
        case fugue_sqlParser::WINDOW:
        case fugue_sqlParser::WITH:
        case fugue_sqlParser::YEAR:
        case fugue_sqlParser::DIV:
        case fugue_sqlParser::IDENTIFIER:
        case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
          setState(3092);
          antlrcpp::downCast<NamedExpressionContext *>(_localctx)->name = errorCapturingIdentifier();
          break;
        }

        case fugue_sqlParser::T__2: {
          setState(3093);
          identifierList();
          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;
}

//----------------- NamedExpressionSeqContext ------------------------------------------------------------------

fugue_sqlParser::NamedExpressionSeqContext::NamedExpressionSeqContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::NamedExpressionContext *> fugue_sqlParser::NamedExpressionSeqContext::namedExpression() {
  return getRuleContexts<fugue_sqlParser::NamedExpressionContext>();
}

fugue_sqlParser::NamedExpressionContext* fugue_sqlParser::NamedExpressionSeqContext::namedExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::NamedExpressionContext>(i);
}


size_t fugue_sqlParser::NamedExpressionSeqContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNamedExpressionSeq;
}


std::any fugue_sqlParser::NamedExpressionSeqContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNamedExpressionSeq(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NamedExpressionSeqContext* fugue_sqlParser::namedExpressionSeq() {
  NamedExpressionSeqContext *_localctx = _tracker.createInstance<NamedExpressionSeqContext>(_ctx, getState());
  enterRule(_localctx, 330, fugue_sqlParser::RuleNamedExpressionSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3098);
    namedExpression();
    setState(3103);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 416, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3099);
        match(fugue_sqlParser::T__0);
        setState(3100);
        namedExpression(); 
      }
      setState(3105);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 416, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TransformListContext ------------------------------------------------------------------

fugue_sqlParser::TransformListContext::TransformListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::TransformContext *> fugue_sqlParser::TransformListContext::transform() {
  return getRuleContexts<fugue_sqlParser::TransformContext>();
}

fugue_sqlParser::TransformContext* fugue_sqlParser::TransformListContext::transform(size_t i) {
  return getRuleContext<fugue_sqlParser::TransformContext>(i);
}


size_t fugue_sqlParser::TransformListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTransformList;
}


std::any fugue_sqlParser::TransformListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTransformList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TransformListContext* fugue_sqlParser::transformList() {
  TransformListContext *_localctx = _tracker.createInstance<TransformListContext>(_ctx, getState());
  enterRule(_localctx, 332, fugue_sqlParser::RuleTransformList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3106);
    match(fugue_sqlParser::T__2);
    setState(3107);
    antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext = transform();
    antlrcpp::downCast<TransformListContext *>(_localctx)->transforms.push_back(antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext);
    setState(3112);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(3108);
      match(fugue_sqlParser::T__0);
      setState(3109);
      antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext = transform();
      antlrcpp::downCast<TransformListContext *>(_localctx)->transforms.push_back(antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext);
      setState(3114);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(3115);
    match(fugue_sqlParser::T__3);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TransformContext ------------------------------------------------------------------

fugue_sqlParser::TransformContext::TransformContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::TransformContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTransform;
}

void fugue_sqlParser::TransformContext::copyFrom(TransformContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- IdentityTransformContext ------------------------------------------------------------------

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::IdentityTransformContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

fugue_sqlParser::IdentityTransformContext::IdentityTransformContext(TransformContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::IdentityTransformContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIdentityTransform(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ApplyTransformContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ApplyTransformContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

std::vector<fugue_sqlParser::TransformArgumentContext *> fugue_sqlParser::ApplyTransformContext::transformArgument() {
  return getRuleContexts<fugue_sqlParser::TransformArgumentContext>();
}

fugue_sqlParser::TransformArgumentContext* fugue_sqlParser::ApplyTransformContext::transformArgument(size_t i) {
  return getRuleContext<fugue_sqlParser::TransformArgumentContext>(i);
}

fugue_sqlParser::ApplyTransformContext::ApplyTransformContext(TransformContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ApplyTransformContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitApplyTransform(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::TransformContext* fugue_sqlParser::transform() {
  TransformContext *_localctx = _tracker.createInstance<TransformContext>(_ctx, getState());
  enterRule(_localctx, 334, fugue_sqlParser::RuleTransform);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3130);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 419, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::IdentityTransformContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3117);
      qualifiedName();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ApplyTransformContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3118);
      antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformName = identifier();
      setState(3119);
      match(fugue_sqlParser::T__2);
      setState(3120);
      antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext = transformArgument();
      antlrcpp::downCast<ApplyTransformContext *>(_localctx)->argument.push_back(antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext);
      setState(3125);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(3121);
        match(fugue_sqlParser::T__0);
        setState(3122);
        antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext = transformArgument();
        antlrcpp::downCast<ApplyTransformContext *>(_localctx)->argument.push_back(antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext);
        setState(3127);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(3128);
      match(fugue_sqlParser::T__3);
      break;
    }

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

  return _localctx;
}

//----------------- TransformArgumentContext ------------------------------------------------------------------

fugue_sqlParser::TransformArgumentContext::TransformArgumentContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::TransformArgumentContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

fugue_sqlParser::ConstantContext* fugue_sqlParser::TransformArgumentContext::constant() {
  return getRuleContext<fugue_sqlParser::ConstantContext>(0);
}


size_t fugue_sqlParser::TransformArgumentContext::getRuleIndex() const {
  return fugue_sqlParser::RuleTransformArgument;
}


std::any fugue_sqlParser::TransformArgumentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTransformArgument(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::TransformArgumentContext* fugue_sqlParser::transformArgument() {
  TransformArgumentContext *_localctx = _tracker.createInstance<TransformArgumentContext>(_ctx, getState());
  enterRule(_localctx, 336, fugue_sqlParser::RuleTransformArgument);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3133);
      constant();
      break;
    }

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

  return _localctx;
}

//----------------- ExpressionContext ------------------------------------------------------------------

fugue_sqlParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::ExpressionContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}


size_t fugue_sqlParser::ExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleExpression;
}


std::any fugue_sqlParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitExpression(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::expression() {
  ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, getState());
  enterRule(_localctx, 338, fugue_sqlParser::RuleExpression);

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

  return _localctx;
}

//----------------- BooleanExpressionContext ------------------------------------------------------------------

fugue_sqlParser::BooleanExpressionContext::BooleanExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::BooleanExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleBooleanExpression;
}

void fugue_sqlParser::BooleanExpressionContext::copyFrom(BooleanExpressionContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- LogicalNotContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::LogicalNotContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::LogicalNotContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}

fugue_sqlParser::LogicalNotContext::LogicalNotContext(BooleanExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::LogicalNotContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLogicalNot(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PredicatedContext ------------------------------------------------------------------

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::PredicatedContext::valueExpression() {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(0);
}

fugue_sqlParser::PredicateContext* fugue_sqlParser::PredicatedContext::predicate() {
  return getRuleContext<fugue_sqlParser::PredicateContext>(0);
}

fugue_sqlParser::PredicatedContext::PredicatedContext(BooleanExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::PredicatedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPredicated(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExistsContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ExistsContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::ExistsContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::ExistsContext::ExistsContext(BooleanExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ExistsContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitExists(this);
  else
    return visitor->visitChildren(this);
}
//----------------- LogicalBinaryContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::BooleanExpressionContext *> fugue_sqlParser::LogicalBinaryContext::booleanExpression() {
  return getRuleContexts<fugue_sqlParser::BooleanExpressionContext>();
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::LogicalBinaryContext::booleanExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::LogicalBinaryContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

tree::TerminalNode* fugue_sqlParser::LogicalBinaryContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}

fugue_sqlParser::LogicalBinaryContext::LogicalBinaryContext(BooleanExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::LogicalBinaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLogicalBinary(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::booleanExpression() {
   return booleanExpression(0);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::booleanExpression(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  fugue_sqlParser::BooleanExpressionContext *_localctx = _tracker.createInstance<BooleanExpressionContext>(_ctx, parentState);
  fugue_sqlParser::BooleanExpressionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 340;
  enterRecursionRule(_localctx, 340, fugue_sqlParser::RuleBooleanExpression, precedence);

    

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3150);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 422, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<LogicalNotContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(3139);
      match(fugue_sqlParser::NOT);
      setState(3140);
      booleanExpression(5);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<ExistsContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3141);
      match(fugue_sqlParser::EXISTS);
      setState(3142);
      match(fugue_sqlParser::T__2);
      setState(3143);
      query();
      setState(3144);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<PredicatedContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3146);
      valueExpression(0);
      setState(3148);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 421, _ctx)) {
      case 1: {
        setState(3147);
        predicate();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(3160);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 424, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3158);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 423, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<LogicalBinaryContext>(_tracker.createInstance<BooleanExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleBooleanExpression);
          setState(3152);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(3153);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::AND);
          setState(3154);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->right = booleanExpression(3);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<LogicalBinaryContext>(_tracker.createInstance<BooleanExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleBooleanExpression);
          setState(3155);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(3156);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::OR);
          setState(3157);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->right = booleanExpression(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(3162);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 424, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- PredicateContext ------------------------------------------------------------------

fugue_sqlParser::PredicateContext::PredicateContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::BETWEEN() {
  return getToken(fugue_sqlParser::BETWEEN, 0);
}

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::PredicateContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::PredicateContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::PredicateContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::PredicateContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

fugue_sqlParser::QueryContext* fugue_sqlParser::PredicateContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::RLIKE() {
  return getToken(fugue_sqlParser::RLIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::ANY() {
  return getToken(fugue_sqlParser::ANY, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::SOME() {
  return getToken(fugue_sqlParser::SOME, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::ALL() {
  return getToken(fugue_sqlParser::ALL, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::ESCAPE() {
  return getToken(fugue_sqlParser::ESCAPE, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::IS() {
  return getToken(fugue_sqlParser::IS, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::TRUE() {
  return getToken(fugue_sqlParser::TRUE, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::FALSE() {
  return getToken(fugue_sqlParser::FALSE, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::UNKNOWN() {
  return getToken(fugue_sqlParser::UNKNOWN, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateContext::DISTINCT() {
  return getToken(fugue_sqlParser::DISTINCT, 0);
}


size_t fugue_sqlParser::PredicateContext::getRuleIndex() const {
  return fugue_sqlParser::RulePredicate;
}


std::any fugue_sqlParser::PredicateContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPredicate(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PredicateContext* fugue_sqlParser::predicate() {
  PredicateContext *_localctx = _tracker.createInstance<PredicateContext>(_ctx, getState());
  enterRule(_localctx, 342, fugue_sqlParser::RulePredicate);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3163);
        match(fugue_sqlParser::NOT);
      }
      setState(3166);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::BETWEEN);
      setState(3167);
      antlrcpp::downCast<PredicateContext *>(_localctx)->lower = valueExpression(0);
      setState(3168);
      match(fugue_sqlParser::AND);
      setState(3169);
      antlrcpp::downCast<PredicateContext *>(_localctx)->upper = valueExpression(0);
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3171);
        match(fugue_sqlParser::NOT);
      }
      setState(3174);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::IN);
      setState(3175);
      match(fugue_sqlParser::T__2);
      setState(3176);
      expression();
      setState(3181);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__0) {
        setState(3177);
        match(fugue_sqlParser::T__0);
        setState(3178);
        expression();
        setState(3183);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(3184);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3187);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3186);
        match(fugue_sqlParser::NOT);
      }
      setState(3189);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::IN);
      setState(3190);
      match(fugue_sqlParser::T__2);
      setState(3191);
      query();
      setState(3192);
      match(fugue_sqlParser::T__3);
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3194);
        match(fugue_sqlParser::NOT);
      }
      setState(3197);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::RLIKE);
      setState(3198);
      antlrcpp::downCast<PredicateContext *>(_localctx)->pattern = valueExpression(0);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3200);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3199);
        match(fugue_sqlParser::NOT);
      }
      setState(3202);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::LIKE);
      setState(3203);
      antlrcpp::downCast<PredicateContext *>(_localctx)->quantifier = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ALL

      || _la == fugue_sqlParser::ANY || _la == fugue_sqlParser::SOME)) {
        antlrcpp::downCast<PredicateContext *>(_localctx)->quantifier = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3217);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 432, _ctx)) {
      case 1: {
        setState(3204);
        match(fugue_sqlParser::T__2);
        setState(3205);
        match(fugue_sqlParser::T__3);
        break;
      }

      case 2: {
        setState(3206);
        match(fugue_sqlParser::T__2);
        setState(3207);
        expression();
        setState(3212);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(3208);
          match(fugue_sqlParser::T__0);
          setState(3209);
          expression();
          setState(3214);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(3215);
        match(fugue_sqlParser::T__3);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(3220);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3219);
        match(fugue_sqlParser::NOT);
      }
      setState(3222);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::LIKE);
      setState(3223);
      antlrcpp::downCast<PredicateContext *>(_localctx)->pattern = valueExpression(0);
      setState(3226);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 434, _ctx)) {
      case 1: {
        setState(3224);
        match(fugue_sqlParser::ESCAPE);
        setState(3225);
        antlrcpp::downCast<PredicateContext *>(_localctx)->escapeChar = match(fugue_sqlParser::STRING);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(3228);
      match(fugue_sqlParser::IS);
      setState(3230);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3229);
        match(fugue_sqlParser::NOT);
      }
      setState(3232);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::THENULL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(3233);
      match(fugue_sqlParser::IS);
      setState(3235);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3234);
        match(fugue_sqlParser::NOT);
      }
      setState(3237);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FALSE || _la == fugue_sqlParser::TRUE

      || _la == fugue_sqlParser::UNKNOWN)) {
        antlrcpp::downCast<PredicateContext *>(_localctx)->kind = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(3238);
      match(fugue_sqlParser::IS);
      setState(3240);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3239);
        match(fugue_sqlParser::NOT);
      }
      setState(3242);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::DISTINCT);
      setState(3243);
      match(fugue_sqlParser::FROM);
      setState(3244);
      antlrcpp::downCast<PredicateContext *>(_localctx)->right = valueExpression(0);
      break;
    }

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

  return _localctx;
}

//----------------- ValueExpressionContext ------------------------------------------------------------------

fugue_sqlParser::ValueExpressionContext::ValueExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::ValueExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleValueExpression;
}

void fugue_sqlParser::ValueExpressionContext::copyFrom(ValueExpressionContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- ValueExpressionDefaultContext ------------------------------------------------------------------

fugue_sqlParser::PrimaryExpressionContext* fugue_sqlParser::ValueExpressionDefaultContext::primaryExpression() {
  return getRuleContext<fugue_sqlParser::PrimaryExpressionContext>(0);
}

fugue_sqlParser::ValueExpressionDefaultContext::ValueExpressionDefaultContext(ValueExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ValueExpressionDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitValueExpressionDefault(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ComparisonContext ------------------------------------------------------------------

fugue_sqlParser::ComparisonOperatorContext* fugue_sqlParser::ComparisonContext::comparisonOperator() {
  return getRuleContext<fugue_sqlParser::ComparisonOperatorContext>(0);
}

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::ComparisonContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::ComparisonContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

fugue_sqlParser::ComparisonContext::ComparisonContext(ValueExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ComparisonContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitComparison(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ArithmeticBinaryContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::ArithmeticBinaryContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::ArithmeticBinaryContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::SLASH() {
  return getToken(fugue_sqlParser::SLASH, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::PERCENT() {
  return getToken(fugue_sqlParser::PERCENT, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::DIV() {
  return getToken(fugue_sqlParser::DIV, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::PLUS() {
  return getToken(fugue_sqlParser::PLUS, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::CONCAT_PIPE() {
  return getToken(fugue_sqlParser::CONCAT_PIPE, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::AMPERSAND() {
  return getToken(fugue_sqlParser::AMPERSAND, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::HAT() {
  return getToken(fugue_sqlParser::HAT, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticBinaryContext::PIPE() {
  return getToken(fugue_sqlParser::PIPE, 0);
}

fugue_sqlParser::ArithmeticBinaryContext::ArithmeticBinaryContext(ValueExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ArithmeticBinaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitArithmeticBinary(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ArithmeticUnaryContext ------------------------------------------------------------------

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::ArithmeticUnaryContext::valueExpression() {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticUnaryContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticUnaryContext::PLUS() {
  return getToken(fugue_sqlParser::PLUS, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticUnaryContext::TILDE() {
  return getToken(fugue_sqlParser::TILDE, 0);
}

fugue_sqlParser::ArithmeticUnaryContext::ArithmeticUnaryContext(ValueExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ArithmeticUnaryContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitArithmeticUnary(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::valueExpression() {
   return valueExpression(0);
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::valueExpression(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  fugue_sqlParser::ValueExpressionContext *_localctx = _tracker.createInstance<ValueExpressionContext>(_ctx, parentState);
  fugue_sqlParser::ValueExpressionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 344;
  enterRecursionRule(_localctx, 344, fugue_sqlParser::RuleValueExpression, 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(3251);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 439, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<ValueExpressionDefaultContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(3248);
      primaryExpression(0);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<ArithmeticUnaryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3249);
      antlrcpp::downCast<ArithmeticUnaryContext *>(_localctx)->theOperator = _input->LT(1);
      _la = _input->LA(1);
      if (!(((((_la - 314) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 314)) & ((1ULL << (fugue_sqlParser::PLUS - 314))
        | (1ULL << (fugue_sqlParser::MINUS - 314))
        | (1ULL << (fugue_sqlParser::TILDE - 314)))) != 0))) {
        antlrcpp::downCast<ArithmeticUnaryContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3250);
      valueExpression(7);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(3274);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 441, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3272);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 440, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<ArithmeticBinaryContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3253);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(3254);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _input->LT(1);
          _la = _input->LA(1);
          if (!(((((_la - 316) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 316)) & ((1ULL << (fugue_sqlParser::ASTERISK - 316))
            | (1ULL << (fugue_sqlParser::SLASH - 316))
            | (1ULL << (fugue_sqlParser::PERCENT - 316))
            | (1ULL << (fugue_sqlParser::DIV - 316)))) != 0))) {
            antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(3255);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->right = valueExpression(7);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<ArithmeticBinaryContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3256);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(3257);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _input->LT(1);
          _la = _input->LA(1);
          if (!(((((_la - 314) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 314)) & ((1ULL << (fugue_sqlParser::PLUS - 314))
            | (1ULL << (fugue_sqlParser::MINUS - 314))
            | (1ULL << (fugue_sqlParser::CONCAT_PIPE - 314)))) != 0))) {
            antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(3258);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->right = valueExpression(6);
          break;
        }

        case 3: {
          auto newContext = _tracker.createInstance<ArithmeticBinaryContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3259);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(3260);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::AMPERSAND);
          setState(3261);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->right = valueExpression(5);
          break;
        }

        case 4: {
          auto newContext = _tracker.createInstance<ArithmeticBinaryContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3262);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(3263);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::HAT);
          setState(3264);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->right = valueExpression(4);
          break;
        }

        case 5: {
          auto newContext = _tracker.createInstance<ArithmeticBinaryContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3265);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(3266);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::PIPE);
          setState(3267);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->right = valueExpression(3);
          break;
        }

        case 6: {
          auto newContext = _tracker.createInstance<ComparisonContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3268);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(3269);
          comparisonOperator();
          setState(3270);
          antlrcpp::downCast<ComparisonContext *>(_localctx)->right = valueExpression(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(3276);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 441, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- PrimaryExpressionContext ------------------------------------------------------------------

fugue_sqlParser::PrimaryExpressionContext::PrimaryExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::PrimaryExpressionContext::getRuleIndex() const {
  return fugue_sqlParser::RulePrimaryExpression;
}

void fugue_sqlParser::PrimaryExpressionContext::copyFrom(PrimaryExpressionContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- StructContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::StructContext::STRUCT() {
  return getToken(fugue_sqlParser::STRUCT, 0);
}

std::vector<fugue_sqlParser::NamedExpressionContext *> fugue_sqlParser::StructContext::namedExpression() {
  return getRuleContexts<fugue_sqlParser::NamedExpressionContext>();
}

fugue_sqlParser::NamedExpressionContext* fugue_sqlParser::StructContext::namedExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::NamedExpressionContext>(i);
}

fugue_sqlParser::StructContext::StructContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::StructContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitStruct(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DereferenceContext ------------------------------------------------------------------

fugue_sqlParser::PrimaryExpressionContext* fugue_sqlParser::DereferenceContext::primaryExpression() {
  return getRuleContext<fugue_sqlParser::PrimaryExpressionContext>(0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::DereferenceContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::DereferenceContext::DereferenceContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DereferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDereference(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SimpleCaseContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SimpleCaseContext::CASE() {
  return getToken(fugue_sqlParser::CASE, 0);
}

tree::TerminalNode* fugue_sqlParser::SimpleCaseContext::END() {
  return getToken(fugue_sqlParser::END, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::SimpleCaseContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::SimpleCaseContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

std::vector<fugue_sqlParser::WhenClauseContext *> fugue_sqlParser::SimpleCaseContext::whenClause() {
  return getRuleContexts<fugue_sqlParser::WhenClauseContext>();
}

fugue_sqlParser::WhenClauseContext* fugue_sqlParser::SimpleCaseContext::whenClause(size_t i) {
  return getRuleContext<fugue_sqlParser::WhenClauseContext>(i);
}

tree::TerminalNode* fugue_sqlParser::SimpleCaseContext::ELSE() {
  return getToken(fugue_sqlParser::ELSE, 0);
}

fugue_sqlParser::SimpleCaseContext::SimpleCaseContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SimpleCaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSimpleCase(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ColumnReferenceContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ColumnReferenceContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::ColumnReferenceContext::ColumnReferenceContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ColumnReferenceContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitColumnReference(this);
  else
    return visitor->visitChildren(this);
}
//----------------- RowConstructorContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::NamedExpressionContext *> fugue_sqlParser::RowConstructorContext::namedExpression() {
  return getRuleContexts<fugue_sqlParser::NamedExpressionContext>();
}

fugue_sqlParser::NamedExpressionContext* fugue_sqlParser::RowConstructorContext::namedExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::NamedExpressionContext>(i);
}

fugue_sqlParser::RowConstructorContext::RowConstructorContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::RowConstructorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitRowConstructor(this);
  else
    return visitor->visitChildren(this);
}
//----------------- LastContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::LastContext::LAST() {
  return getToken(fugue_sqlParser::LAST, 0);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::LastContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::LastContext::IGNORE() {
  return getToken(fugue_sqlParser::IGNORE, 0);
}

tree::TerminalNode* fugue_sqlParser::LastContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

fugue_sqlParser::LastContext::LastContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::LastContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLast(this);
  else
    return visitor->visitChildren(this);
}
//----------------- StarContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::StarContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::StarContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

fugue_sqlParser::StarContext::StarContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::StarContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitStar(this);
  else
    return visitor->visitChildren(this);
}
//----------------- OverlayContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::OverlayContext::OVERLAY() {
  return getToken(fugue_sqlParser::OVERLAY, 0);
}

tree::TerminalNode* fugue_sqlParser::OverlayContext::PLACING() {
  return getToken(fugue_sqlParser::PLACING, 0);
}

tree::TerminalNode* fugue_sqlParser::OverlayContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::OverlayContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::OverlayContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::OverlayContext::FOR() {
  return getToken(fugue_sqlParser::FOR, 0);
}

fugue_sqlParser::OverlayContext::OverlayContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::OverlayContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitOverlay(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SubscriptContext ------------------------------------------------------------------

fugue_sqlParser::PrimaryExpressionContext* fugue_sqlParser::SubscriptContext::primaryExpression() {
  return getRuleContext<fugue_sqlParser::PrimaryExpressionContext>(0);
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::SubscriptContext::valueExpression() {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(0);
}

fugue_sqlParser::SubscriptContext::SubscriptContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SubscriptContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSubscript(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SubqueryExpressionContext ------------------------------------------------------------------

fugue_sqlParser::QueryContext* fugue_sqlParser::SubqueryExpressionContext::query() {
  return getRuleContext<fugue_sqlParser::QueryContext>(0);
}

fugue_sqlParser::SubqueryExpressionContext::SubqueryExpressionContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SubqueryExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSubqueryExpression(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SubstringContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SubstringContext::SUBSTR() {
  return getToken(fugue_sqlParser::SUBSTR, 0);
}

tree::TerminalNode* fugue_sqlParser::SubstringContext::SUBSTRING() {
  return getToken(fugue_sqlParser::SUBSTRING, 0);
}

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::SubstringContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::SubstringContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::SubstringContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::SubstringContext::FOR() {
  return getToken(fugue_sqlParser::FOR, 0);
}

fugue_sqlParser::SubstringContext::SubstringContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SubstringContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSubstring(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CurrentDatetimeContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CurrentDatetimeContext::CURRENT_DATE() {
  return getToken(fugue_sqlParser::CURRENT_DATE, 0);
}

tree::TerminalNode* fugue_sqlParser::CurrentDatetimeContext::CURRENT_TIMESTAMP() {
  return getToken(fugue_sqlParser::CURRENT_TIMESTAMP, 0);
}

fugue_sqlParser::CurrentDatetimeContext::CurrentDatetimeContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CurrentDatetimeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCurrentDatetime(this);
  else
    return visitor->visitChildren(this);
}
//----------------- CastContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::CastContext::CAST() {
  return getToken(fugue_sqlParser::CAST, 0);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::CastContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::CastContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::CastContext::dataType() {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(0);
}

fugue_sqlParser::CastContext::CastContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::CastContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitCast(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ConstantDefaultContext ------------------------------------------------------------------

fugue_sqlParser::ConstantContext* fugue_sqlParser::ConstantDefaultContext::constant() {
  return getRuleContext<fugue_sqlParser::ConstantContext>(0);
}

fugue_sqlParser::ConstantDefaultContext::ConstantDefaultContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ConstantDefaultContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitConstantDefault(this);
  else
    return visitor->visitChildren(this);
}
//----------------- LambdaContext ------------------------------------------------------------------

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::LambdaContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::LambdaContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::LambdaContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

fugue_sqlParser::LambdaContext::LambdaContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::LambdaContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLambda(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ParenthesizedExpressionContext ------------------------------------------------------------------

fugue_sqlParser::ExpressionContext* fugue_sqlParser::ParenthesizedExpressionContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

fugue_sqlParser::ParenthesizedExpressionContext::ParenthesizedExpressionContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ParenthesizedExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitParenthesizedExpression(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExtractContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ExtractContext::EXTRACT() {
  return getToken(fugue_sqlParser::EXTRACT, 0);
}

tree::TerminalNode* fugue_sqlParser::ExtractContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ExtractContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::ExtractContext::valueExpression() {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(0);
}

fugue_sqlParser::ExtractContext::ExtractContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ExtractContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitExtract(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TrimContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::TrimContext::TRIM() {
  return getToken(fugue_sqlParser::TRIM, 0);
}

tree::TerminalNode* fugue_sqlParser::TrimContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::TrimContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::TrimContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

tree::TerminalNode* fugue_sqlParser::TrimContext::BOTH() {
  return getToken(fugue_sqlParser::BOTH, 0);
}

tree::TerminalNode* fugue_sqlParser::TrimContext::LEADING() {
  return getToken(fugue_sqlParser::LEADING, 0);
}

tree::TerminalNode* fugue_sqlParser::TrimContext::TRAILING() {
  return getToken(fugue_sqlParser::TRAILING, 0);
}

fugue_sqlParser::TrimContext::TrimContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TrimContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTrim(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FunctionCallContext ------------------------------------------------------------------

fugue_sqlParser::FunctionNameContext* fugue_sqlParser::FunctionCallContext::functionName() {
  return getRuleContext<fugue_sqlParser::FunctionNameContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FunctionCallContext::FILTER() {
  return getToken(fugue_sqlParser::FILTER, 0);
}

tree::TerminalNode* fugue_sqlParser::FunctionCallContext::WHERE() {
  return getToken(fugue_sqlParser::WHERE, 0);
}

tree::TerminalNode* fugue_sqlParser::FunctionCallContext::OVER() {
  return getToken(fugue_sqlParser::OVER, 0);
}

fugue_sqlParser::WindowSpecContext* fugue_sqlParser::FunctionCallContext::windowSpec() {
  return getRuleContext<fugue_sqlParser::WindowSpecContext>(0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::FunctionCallContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::FunctionCallContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

fugue_sqlParser::BooleanExpressionContext* fugue_sqlParser::FunctionCallContext::booleanExpression() {
  return getRuleContext<fugue_sqlParser::BooleanExpressionContext>(0);
}

fugue_sqlParser::SetQuantifierContext* fugue_sqlParser::FunctionCallContext::setQuantifier() {
  return getRuleContext<fugue_sqlParser::SetQuantifierContext>(0);
}

fugue_sqlParser::FunctionCallContext::FunctionCallContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FunctionCallContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFunctionCall(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SearchedCaseContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SearchedCaseContext::CASE() {
  return getToken(fugue_sqlParser::CASE, 0);
}

tree::TerminalNode* fugue_sqlParser::SearchedCaseContext::END() {
  return getToken(fugue_sqlParser::END, 0);
}

std::vector<fugue_sqlParser::WhenClauseContext *> fugue_sqlParser::SearchedCaseContext::whenClause() {
  return getRuleContexts<fugue_sqlParser::WhenClauseContext>();
}

fugue_sqlParser::WhenClauseContext* fugue_sqlParser::SearchedCaseContext::whenClause(size_t i) {
  return getRuleContext<fugue_sqlParser::WhenClauseContext>(i);
}

tree::TerminalNode* fugue_sqlParser::SearchedCaseContext::ELSE() {
  return getToken(fugue_sqlParser::ELSE, 0);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::SearchedCaseContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

fugue_sqlParser::SearchedCaseContext::SearchedCaseContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SearchedCaseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSearchedCase(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PositionContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::PositionContext::POSITION() {
  return getToken(fugue_sqlParser::POSITION, 0);
}

tree::TerminalNode* fugue_sqlParser::PositionContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

std::vector<fugue_sqlParser::ValueExpressionContext *> fugue_sqlParser::PositionContext::valueExpression() {
  return getRuleContexts<fugue_sqlParser::ValueExpressionContext>();
}

fugue_sqlParser::ValueExpressionContext* fugue_sqlParser::PositionContext::valueExpression(size_t i) {
  return getRuleContext<fugue_sqlParser::ValueExpressionContext>(i);
}

fugue_sqlParser::PositionContext::PositionContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::PositionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPosition(this);
  else
    return visitor->visitChildren(this);
}
//----------------- FirstContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::FirstContext::FIRST() {
  return getToken(fugue_sqlParser::FIRST, 0);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::FirstContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FirstContext::IGNORE() {
  return getToken(fugue_sqlParser::IGNORE, 0);
}

tree::TerminalNode* fugue_sqlParser::FirstContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

fugue_sqlParser::FirstContext::FirstContext(PrimaryExpressionContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FirstContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFirst(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PrimaryExpressionContext* fugue_sqlParser::primaryExpression() {
   return primaryExpression(0);
}

fugue_sqlParser::PrimaryExpressionContext* fugue_sqlParser::primaryExpression(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  fugue_sqlParser::PrimaryExpressionContext *_localctx = _tracker.createInstance<PrimaryExpressionContext>(_ctx, parentState);
  fugue_sqlParser::PrimaryExpressionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 346;
  enterRecursionRule(_localctx, 346, fugue_sqlParser::RulePrimaryExpression, 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(3461);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 461, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<CurrentDatetimeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(3278);
      antlrcpp::downCast<CurrentDatetimeContext *>(_localctx)->name = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::CURRENT_DATE

      || _la == fugue_sqlParser::CURRENT_TIMESTAMP)) {
        antlrcpp::downCast<CurrentDatetimeContext *>(_localctx)->name = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<SearchedCaseContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3279);
      match(fugue_sqlParser::CASE);
      setState(3281); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3280);
        whenClause();
        setState(3283); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::WHEN);
      setState(3287);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ELSE) {
        setState(3285);
        match(fugue_sqlParser::ELSE);
        setState(3286);
        antlrcpp::downCast<SearchedCaseContext *>(_localctx)->elseExpression = expression();
      }
      setState(3289);
      match(fugue_sqlParser::END);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<SimpleCaseContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3291);
      match(fugue_sqlParser::CASE);
      setState(3292);
      antlrcpp::downCast<SimpleCaseContext *>(_localctx)->value = expression();
      setState(3294); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3293);
        whenClause();
        setState(3296); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::WHEN);
      setState(3300);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ELSE) {
        setState(3298);
        match(fugue_sqlParser::ELSE);
        setState(3299);
        antlrcpp::downCast<SimpleCaseContext *>(_localctx)->elseExpression = expression();
      }
      setState(3302);
      match(fugue_sqlParser::END);
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<CastContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3304);
      match(fugue_sqlParser::CAST);
      setState(3305);
      match(fugue_sqlParser::T__2);
      setState(3306);
      expression();
      setState(3307);
      match(fugue_sqlParser::AS);
      setState(3308);
      dataType();
      setState(3309);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<StructContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3311);
      match(fugue_sqlParser::STRUCT);
      setState(3312);
      match(fugue_sqlParser::T__2);
      setState(3321);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
        | (1ULL << fugue_sqlParser::ADD)
        | (1ULL << fugue_sqlParser::AFTER)
        | (1ULL << fugue_sqlParser::ALL)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::ANALYZE)
        | (1ULL << fugue_sqlParser::AND)
        | (1ULL << fugue_sqlParser::ANTI)
        | (1ULL << fugue_sqlParser::ANY)
        | (1ULL << fugue_sqlParser::ARCHIVE)
        | (1ULL << fugue_sqlParser::ARRAY)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
        | (1ULL << (fugue_sqlParser::AT - 64))
        | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
        | (1ULL << (fugue_sqlParser::BETWEEN - 64))
        | (1ULL << (fugue_sqlParser::BOTH - 64))
        | (1ULL << (fugue_sqlParser::BUCKET - 64))
        | (1ULL << (fugue_sqlParser::BUCKETS - 64))
        | (1ULL << (fugue_sqlParser::BY - 64))
        | (1ULL << (fugue_sqlParser::CACHE - 64))
        | (1ULL << (fugue_sqlParser::CASCADE - 64))
        | (1ULL << (fugue_sqlParser::CASE - 64))
        | (1ULL << (fugue_sqlParser::CAST - 64))
        | (1ULL << (fugue_sqlParser::CHANGE - 64))
        | (1ULL << (fugue_sqlParser::CHECK - 64))
        | (1ULL << (fugue_sqlParser::CLEAR - 64))
        | (1ULL << (fugue_sqlParser::CLUSTER - 64))
        | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
        | (1ULL << (fugue_sqlParser::CODEGEN - 64))
        | (1ULL << (fugue_sqlParser::COLLATE - 64))
        | (1ULL << (fugue_sqlParser::COLLECTION - 64))
        | (1ULL << (fugue_sqlParser::COLUMN - 64))
        | (1ULL << (fugue_sqlParser::COLUMNS - 64))
        | (1ULL << (fugue_sqlParser::COMMENT - 64))
        | (1ULL << (fugue_sqlParser::COMMIT - 64))
        | (1ULL << (fugue_sqlParser::COMPACT - 64))
        | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
        | (1ULL << (fugue_sqlParser::COMPUTE - 64))
        | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
        | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
        | (1ULL << (fugue_sqlParser::COST - 64))
        | (1ULL << (fugue_sqlParser::CREATE - 64))
        | (1ULL << (fugue_sqlParser::CROSS - 64))
        | (1ULL << (fugue_sqlParser::CUBE - 64))
        | (1ULL << (fugue_sqlParser::CURRENT - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
        | (1ULL << (fugue_sqlParser::DATA - 64))
        | (1ULL << (fugue_sqlParser::DATABASE - 64))
        | (1ULL << (fugue_sqlParser::DATABASES - 64))
        | (1ULL << (fugue_sqlParser::DAY - 64))
        | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
        | (1ULL << (fugue_sqlParser::DEFINED - 64))
        | (1ULL << (fugue_sqlParser::DELETE - 64))
        | (1ULL << (fugue_sqlParser::DELIMITED - 64))
        | (1ULL << (fugue_sqlParser::DESC - 64))
        | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
        | (1ULL << (fugue_sqlParser::DFS - 64))
        | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
        | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
        | (1ULL << (fugue_sqlParser::DISTINCT - 64))
        | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
        | (1ULL << (fugue_sqlParser::DROP - 64))
        | (1ULL << (fugue_sqlParser::ELSE - 64))
        | (1ULL << (fugue_sqlParser::END - 64))
        | (1ULL << (fugue_sqlParser::ESCAPE - 64))
        | (1ULL << (fugue_sqlParser::ESCAPED - 64))
        | (1ULL << (fugue_sqlParser::EXCEPT - 64))
        | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
        | (1ULL << (fugue_sqlParser::EXISTS - 64))
        | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
        | (1ULL << (fugue_sqlParser::EXPORT - 64))
        | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
        | (1ULL << (fugue_sqlParser::EXTRACT - 128))
        | (1ULL << (fugue_sqlParser::FALSE - 128))
        | (1ULL << (fugue_sqlParser::FETCH - 128))
        | (1ULL << (fugue_sqlParser::FIELDS - 128))
        | (1ULL << (fugue_sqlParser::FILTER - 128))
        | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
        | (1ULL << (fugue_sqlParser::FIRST - 128))
        | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
        | (1ULL << (fugue_sqlParser::FOR - 128))
        | (1ULL << (fugue_sqlParser::FOREIGN - 128))
        | (1ULL << (fugue_sqlParser::FORMAT - 128))
        | (1ULL << (fugue_sqlParser::FORMATTED - 128))
        | (1ULL << (fugue_sqlParser::FROM - 128))
        | (1ULL << (fugue_sqlParser::FULL - 128))
        | (1ULL << (fugue_sqlParser::FUNCTION - 128))
        | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
        | (1ULL << (fugue_sqlParser::GLOBAL - 128))
        | (1ULL << (fugue_sqlParser::GRANT - 128))
        | (1ULL << (fugue_sqlParser::GROUP - 128))
        | (1ULL << (fugue_sqlParser::GROUPING - 128))
        | (1ULL << (fugue_sqlParser::HAVING - 128))
        | (1ULL << (fugue_sqlParser::HOUR - 128))
        | (1ULL << (fugue_sqlParser::IF - 128))
        | (1ULL << (fugue_sqlParser::IGNORE - 128))
        | (1ULL << (fugue_sqlParser::IMPORT - 128))
        | (1ULL << (fugue_sqlParser::IN - 128))
        | (1ULL << (fugue_sqlParser::INDEX - 128))
        | (1ULL << (fugue_sqlParser::INDEXES - 128))
        | (1ULL << (fugue_sqlParser::INNER - 128))
        | (1ULL << (fugue_sqlParser::INPATH - 128))
        | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
        | (1ULL << (fugue_sqlParser::INSERT - 128))
        | (1ULL << (fugue_sqlParser::INTERSECT - 128))
        | (1ULL << (fugue_sqlParser::INTERVAL - 128))
        | (1ULL << (fugue_sqlParser::INTO - 128))
        | (1ULL << (fugue_sqlParser::IS - 128))
        | (1ULL << (fugue_sqlParser::ITEMS - 128))
        | (1ULL << (fugue_sqlParser::JOIN - 128))
        | (1ULL << (fugue_sqlParser::KEYS - 128))
        | (1ULL << (fugue_sqlParser::LAST - 128))
        | (1ULL << (fugue_sqlParser::LATERAL - 128))
        | (1ULL << (fugue_sqlParser::LAZY - 128))
        | (1ULL << (fugue_sqlParser::LEADING - 128))
        | (1ULL << (fugue_sqlParser::LEFT - 128))
        | (1ULL << (fugue_sqlParser::LIKE - 128))
        | (1ULL << (fugue_sqlParser::LIMIT - 128))
        | (1ULL << (fugue_sqlParser::LINES - 128))
        | (1ULL << (fugue_sqlParser::LIST - 128))
        | (1ULL << (fugue_sqlParser::LOAD - 128))
        | (1ULL << (fugue_sqlParser::LOCAL - 128))
        | (1ULL << (fugue_sqlParser::LOCATION - 128))
        | (1ULL << (fugue_sqlParser::LOCK - 128))
        | (1ULL << (fugue_sqlParser::LOCKS - 128))
        | (1ULL << (fugue_sqlParser::LOGICAL - 128))
        | (1ULL << (fugue_sqlParser::MACRO - 128))
        | (1ULL << (fugue_sqlParser::MAP - 128))
        | (1ULL << (fugue_sqlParser::MATCHED - 128))
        | (1ULL << (fugue_sqlParser::MERGE - 128))
        | (1ULL << (fugue_sqlParser::MINUTE - 128))
        | (1ULL << (fugue_sqlParser::MONTH - 128))
        | (1ULL << (fugue_sqlParser::MSCK - 128))
        | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
        | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
        | (1ULL << (fugue_sqlParser::NO - 192))
        | (1ULL << (fugue_sqlParser::NOT - 192))
        | (1ULL << (fugue_sqlParser::THENULL - 192))
        | (1ULL << (fugue_sqlParser::THENULLS - 192))
        | (1ULL << (fugue_sqlParser::OF - 192))
        | (1ULL << (fugue_sqlParser::ON - 192))
        | (1ULL << (fugue_sqlParser::ONLY - 192))
        | (1ULL << (fugue_sqlParser::OPTION - 192))
        | (1ULL << (fugue_sqlParser::OPTIONS - 192))
        | (1ULL << (fugue_sqlParser::OR - 192))
        | (1ULL << (fugue_sqlParser::ORDER - 192))
        | (1ULL << (fugue_sqlParser::OUT - 192))
        | (1ULL << (fugue_sqlParser::OUTER - 192))
        | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
        | (1ULL << (fugue_sqlParser::OVER - 192))
        | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
        | (1ULL << (fugue_sqlParser::OVERLAY - 192))
        | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
        | (1ULL << (fugue_sqlParser::PARTITION - 192))
        | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
        | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
        | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
        | (1ULL << (fugue_sqlParser::PIVOT - 192))
        | (1ULL << (fugue_sqlParser::PLACING - 192))
        | (1ULL << (fugue_sqlParser::POSITION - 192))
        | (1ULL << (fugue_sqlParser::PRECEDING - 192))
        | (1ULL << (fugue_sqlParser::PRIMARY - 192))
        | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
        | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
        | (1ULL << (fugue_sqlParser::PURGE - 192))
        | (1ULL << (fugue_sqlParser::QUERY - 192))
        | (1ULL << (fugue_sqlParser::RANGE - 192))
        | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
        | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
        | (1ULL << (fugue_sqlParser::RECOVER - 192))
        | (1ULL << (fugue_sqlParser::REDUCE - 192))
        | (1ULL << (fugue_sqlParser::REFERENCES - 192))
        | (1ULL << (fugue_sqlParser::REFRESH - 192))
        | (1ULL << (fugue_sqlParser::RENAME - 192))
        | (1ULL << (fugue_sqlParser::REPAIR - 192))
        | (1ULL << (fugue_sqlParser::REPLACE - 192))
        | (1ULL << (fugue_sqlParser::RESET - 192))
        | (1ULL << (fugue_sqlParser::RESTRICT - 192))
        | (1ULL << (fugue_sqlParser::REVOKE - 192))
        | (1ULL << (fugue_sqlParser::RIGHT - 192))
        | (1ULL << (fugue_sqlParser::RLIKE - 192))
        | (1ULL << (fugue_sqlParser::ROLE - 192))
        | (1ULL << (fugue_sqlParser::ROLES - 192))
        | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
        | (1ULL << (fugue_sqlParser::ROLLUP - 192))
        | (1ULL << (fugue_sqlParser::ROW - 192))
        | (1ULL << (fugue_sqlParser::ROWS - 192))
        | (1ULL << (fugue_sqlParser::SCHEMA - 192))
        | (1ULL << (fugue_sqlParser::SECOND - 192))
        | (1ULL << (fugue_sqlParser::SELECT - 192))
        | (1ULL << (fugue_sqlParser::SEMI - 192))
        | (1ULL << (fugue_sqlParser::SEPARATED - 192))
        | (1ULL << (fugue_sqlParser::SERDE - 192))
        | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
        | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
        | (1ULL << (fugue_sqlParser::SET - 192))
        | (1ULL << (fugue_sqlParser::SETMINUS - 192))
        | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
        | (1ULL << (fugue_sqlParser::SKEWED - 256))
        | (1ULL << (fugue_sqlParser::SOME - 256))
        | (1ULL << (fugue_sqlParser::SORT - 256))
        | (1ULL << (fugue_sqlParser::SORTED - 256))
        | (1ULL << (fugue_sqlParser::START - 256))
        | (1ULL << (fugue_sqlParser::STATISTICS - 256))
        | (1ULL << (fugue_sqlParser::STORED - 256))
        | (1ULL << (fugue_sqlParser::STRATIFY - 256))
        | (1ULL << (fugue_sqlParser::STRUCT - 256))
        | (1ULL << (fugue_sqlParser::SUBSTR - 256))
        | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
        | (1ULL << (fugue_sqlParser::TABLE - 256))
        | (1ULL << (fugue_sqlParser::TABLES - 256))
        | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
        | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
        | (1ULL << (fugue_sqlParser::TERMINATED - 256))
        | (1ULL << (fugue_sqlParser::THEN - 256))
        | (1ULL << (fugue_sqlParser::TO - 256))
        | (1ULL << (fugue_sqlParser::TOUCH - 256))
        | (1ULL << (fugue_sqlParser::TRAILING - 256))
        | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
        | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
        | (1ULL << (fugue_sqlParser::TRIM - 256))
        | (1ULL << (fugue_sqlParser::TRUE - 256))
        | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
        | (1ULL << (fugue_sqlParser::TYPE - 256))
        | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
        | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
        | (1ULL << (fugue_sqlParser::UNCACHE - 256))
        | (1ULL << (fugue_sqlParser::UNION - 256))
        | (1ULL << (fugue_sqlParser::UNIQUE - 256))
        | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
        | (1ULL << (fugue_sqlParser::UNLOCK - 256))
        | (1ULL << (fugue_sqlParser::UNSET - 256))
        | (1ULL << (fugue_sqlParser::UPDATE - 256))
        | (1ULL << (fugue_sqlParser::USE - 256))
        | (1ULL << (fugue_sqlParser::USER - 256))
        | (1ULL << (fugue_sqlParser::USING - 256))
        | (1ULL << (fugue_sqlParser::VALUES - 256))
        | (1ULL << (fugue_sqlParser::VIEW - 256))
        | (1ULL << (fugue_sqlParser::VIEWS - 256))
        | (1ULL << (fugue_sqlParser::WHEN - 256))
        | (1ULL << (fugue_sqlParser::WHERE - 256))
        | (1ULL << (fugue_sqlParser::WINDOW - 256))
        | (1ULL << (fugue_sqlParser::WITH - 256))
        | (1ULL << (fugue_sqlParser::YEAR - 256))
        | (1ULL << (fugue_sqlParser::PLUS - 256))
        | (1ULL << (fugue_sqlParser::MINUS - 256))
        | (1ULL << (fugue_sqlParser::ASTERISK - 256))
        | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || ((((_la - 320) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 320)) & ((1ULL << (fugue_sqlParser::TILDE - 320))
        | (1ULL << (fugue_sqlParser::STRING - 320))
        | (1ULL << (fugue_sqlParser::BIGINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::SMALLINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::TINYINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 320))
        | (1ULL << (fugue_sqlParser::EXPONENT_VALUE - 320))
        | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 320))
        | (1ULL << (fugue_sqlParser::DOUBLE_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::BIGDECIMAL_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::IDENTIFIER - 320))
        | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 320)))) != 0)) {
        setState(3313);
        antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext = namedExpression();
        antlrcpp::downCast<StructContext *>(_localctx)->argument.push_back(antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext);
        setState(3318);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(3314);
          match(fugue_sqlParser::T__0);
          setState(3315);
          antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext = namedExpression();
          antlrcpp::downCast<StructContext *>(_localctx)->argument.push_back(antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext);
          setState(3320);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(3323);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<FirstContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3324);
      match(fugue_sqlParser::FIRST);
      setState(3325);
      match(fugue_sqlParser::T__2);
      setState(3326);
      expression();
      setState(3329);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IGNORE) {
        setState(3327);
        match(fugue_sqlParser::IGNORE);
        setState(3328);
        match(fugue_sqlParser::THENULLS);
      }
      setState(3331);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<LastContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3333);
      match(fugue_sqlParser::LAST);
      setState(3334);
      match(fugue_sqlParser::T__2);
      setState(3335);
      expression();
      setState(3338);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IGNORE) {
        setState(3336);
        match(fugue_sqlParser::IGNORE);
        setState(3337);
        match(fugue_sqlParser::THENULLS);
      }
      setState(3340);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<PositionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3342);
      match(fugue_sqlParser::POSITION);
      setState(3343);
      match(fugue_sqlParser::T__2);
      setState(3344);
      antlrcpp::downCast<PositionContext *>(_localctx)->substr = valueExpression(0);
      setState(3345);
      match(fugue_sqlParser::IN);
      setState(3346);
      antlrcpp::downCast<PositionContext *>(_localctx)->istr = valueExpression(0);
      setState(3347);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<ConstantDefaultContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3349);
      constant();
      break;
    }

    case 10: {
      _localctx = _tracker.createInstance<StarContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3350);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<StarContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3351);
      qualifiedName();
      setState(3352);
      match(fugue_sqlParser::T__6);
      setState(3353);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<RowConstructorContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3355);
      match(fugue_sqlParser::T__2);
      setState(3356);
      namedExpression();
      setState(3359); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3357);
        match(fugue_sqlParser::T__0);
        setState(3358);
        namedExpression();
        setState(3361); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::T__0);
      setState(3363);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<SubqueryExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3365);
      match(fugue_sqlParser::T__2);
      setState(3366);
      query();
      setState(3367);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<FunctionCallContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3369);
      functionName();
      setState(3370);
      match(fugue_sqlParser::T__2);
      setState(3382);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & ((1ULL << fugue_sqlParser::T__2)
        | (1ULL << fugue_sqlParser::ADD)
        | (1ULL << fugue_sqlParser::AFTER)
        | (1ULL << fugue_sqlParser::ALL)
        | (1ULL << fugue_sqlParser::ALTER)
        | (1ULL << fugue_sqlParser::ANALYZE)
        | (1ULL << fugue_sqlParser::AND)
        | (1ULL << fugue_sqlParser::ANTI)
        | (1ULL << fugue_sqlParser::ANY)
        | (1ULL << fugue_sqlParser::ARCHIVE)
        | (1ULL << fugue_sqlParser::ARRAY)
        | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
        | (1ULL << (fugue_sqlParser::AT - 64))
        | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
        | (1ULL << (fugue_sqlParser::BETWEEN - 64))
        | (1ULL << (fugue_sqlParser::BOTH - 64))
        | (1ULL << (fugue_sqlParser::BUCKET - 64))
        | (1ULL << (fugue_sqlParser::BUCKETS - 64))
        | (1ULL << (fugue_sqlParser::BY - 64))
        | (1ULL << (fugue_sqlParser::CACHE - 64))
        | (1ULL << (fugue_sqlParser::CASCADE - 64))
        | (1ULL << (fugue_sqlParser::CASE - 64))
        | (1ULL << (fugue_sqlParser::CAST - 64))
        | (1ULL << (fugue_sqlParser::CHANGE - 64))
        | (1ULL << (fugue_sqlParser::CHECK - 64))
        | (1ULL << (fugue_sqlParser::CLEAR - 64))
        | (1ULL << (fugue_sqlParser::CLUSTER - 64))
        | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
        | (1ULL << (fugue_sqlParser::CODEGEN - 64))
        | (1ULL << (fugue_sqlParser::COLLATE - 64))
        | (1ULL << (fugue_sqlParser::COLLECTION - 64))
        | (1ULL << (fugue_sqlParser::COLUMN - 64))
        | (1ULL << (fugue_sqlParser::COLUMNS - 64))
        | (1ULL << (fugue_sqlParser::COMMENT - 64))
        | (1ULL << (fugue_sqlParser::COMMIT - 64))
        | (1ULL << (fugue_sqlParser::COMPACT - 64))
        | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
        | (1ULL << (fugue_sqlParser::COMPUTE - 64))
        | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
        | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
        | (1ULL << (fugue_sqlParser::COST - 64))
        | (1ULL << (fugue_sqlParser::CREATE - 64))
        | (1ULL << (fugue_sqlParser::CROSS - 64))
        | (1ULL << (fugue_sqlParser::CUBE - 64))
        | (1ULL << (fugue_sqlParser::CURRENT - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
        | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
        | (1ULL << (fugue_sqlParser::DATA - 64))
        | (1ULL << (fugue_sqlParser::DATABASE - 64))
        | (1ULL << (fugue_sqlParser::DATABASES - 64))
        | (1ULL << (fugue_sqlParser::DAY - 64))
        | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
        | (1ULL << (fugue_sqlParser::DEFINED - 64))
        | (1ULL << (fugue_sqlParser::DELETE - 64))
        | (1ULL << (fugue_sqlParser::DELIMITED - 64))
        | (1ULL << (fugue_sqlParser::DESC - 64))
        | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
        | (1ULL << (fugue_sqlParser::DFS - 64))
        | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
        | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
        | (1ULL << (fugue_sqlParser::DISTINCT - 64))
        | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
        | (1ULL << (fugue_sqlParser::DROP - 64))
        | (1ULL << (fugue_sqlParser::ELSE - 64))
        | (1ULL << (fugue_sqlParser::END - 64))
        | (1ULL << (fugue_sqlParser::ESCAPE - 64))
        | (1ULL << (fugue_sqlParser::ESCAPED - 64))
        | (1ULL << (fugue_sqlParser::EXCEPT - 64))
        | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
        | (1ULL << (fugue_sqlParser::EXISTS - 64))
        | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
        | (1ULL << (fugue_sqlParser::EXPORT - 64))
        | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
        | (1ULL << (fugue_sqlParser::EXTRACT - 128))
        | (1ULL << (fugue_sqlParser::FALSE - 128))
        | (1ULL << (fugue_sqlParser::FETCH - 128))
        | (1ULL << (fugue_sqlParser::FIELDS - 128))
        | (1ULL << (fugue_sqlParser::FILTER - 128))
        | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
        | (1ULL << (fugue_sqlParser::FIRST - 128))
        | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
        | (1ULL << (fugue_sqlParser::FOR - 128))
        | (1ULL << (fugue_sqlParser::FOREIGN - 128))
        | (1ULL << (fugue_sqlParser::FORMAT - 128))
        | (1ULL << (fugue_sqlParser::FORMATTED - 128))
        | (1ULL << (fugue_sqlParser::FROM - 128))
        | (1ULL << (fugue_sqlParser::FULL - 128))
        | (1ULL << (fugue_sqlParser::FUNCTION - 128))
        | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
        | (1ULL << (fugue_sqlParser::GLOBAL - 128))
        | (1ULL << (fugue_sqlParser::GRANT - 128))
        | (1ULL << (fugue_sqlParser::GROUP - 128))
        | (1ULL << (fugue_sqlParser::GROUPING - 128))
        | (1ULL << (fugue_sqlParser::HAVING - 128))
        | (1ULL << (fugue_sqlParser::HOUR - 128))
        | (1ULL << (fugue_sqlParser::IF - 128))
        | (1ULL << (fugue_sqlParser::IGNORE - 128))
        | (1ULL << (fugue_sqlParser::IMPORT - 128))
        | (1ULL << (fugue_sqlParser::IN - 128))
        | (1ULL << (fugue_sqlParser::INDEX - 128))
        | (1ULL << (fugue_sqlParser::INDEXES - 128))
        | (1ULL << (fugue_sqlParser::INNER - 128))
        | (1ULL << (fugue_sqlParser::INPATH - 128))
        | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
        | (1ULL << (fugue_sqlParser::INSERT - 128))
        | (1ULL << (fugue_sqlParser::INTERSECT - 128))
        | (1ULL << (fugue_sqlParser::INTERVAL - 128))
        | (1ULL << (fugue_sqlParser::INTO - 128))
        | (1ULL << (fugue_sqlParser::IS - 128))
        | (1ULL << (fugue_sqlParser::ITEMS - 128))
        | (1ULL << (fugue_sqlParser::JOIN - 128))
        | (1ULL << (fugue_sqlParser::KEYS - 128))
        | (1ULL << (fugue_sqlParser::LAST - 128))
        | (1ULL << (fugue_sqlParser::LATERAL - 128))
        | (1ULL << (fugue_sqlParser::LAZY - 128))
        | (1ULL << (fugue_sqlParser::LEADING - 128))
        | (1ULL << (fugue_sqlParser::LEFT - 128))
        | (1ULL << (fugue_sqlParser::LIKE - 128))
        | (1ULL << (fugue_sqlParser::LIMIT - 128))
        | (1ULL << (fugue_sqlParser::LINES - 128))
        | (1ULL << (fugue_sqlParser::LIST - 128))
        | (1ULL << (fugue_sqlParser::LOAD - 128))
        | (1ULL << (fugue_sqlParser::LOCAL - 128))
        | (1ULL << (fugue_sqlParser::LOCATION - 128))
        | (1ULL << (fugue_sqlParser::LOCK - 128))
        | (1ULL << (fugue_sqlParser::LOCKS - 128))
        | (1ULL << (fugue_sqlParser::LOGICAL - 128))
        | (1ULL << (fugue_sqlParser::MACRO - 128))
        | (1ULL << (fugue_sqlParser::MAP - 128))
        | (1ULL << (fugue_sqlParser::MATCHED - 128))
        | (1ULL << (fugue_sqlParser::MERGE - 128))
        | (1ULL << (fugue_sqlParser::MINUTE - 128))
        | (1ULL << (fugue_sqlParser::MONTH - 128))
        | (1ULL << (fugue_sqlParser::MSCK - 128))
        | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
        | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 192) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 192)) & ((1ULL << (fugue_sqlParser::NATURAL - 192))
        | (1ULL << (fugue_sqlParser::NO - 192))
        | (1ULL << (fugue_sqlParser::NOT - 192))
        | (1ULL << (fugue_sqlParser::THENULL - 192))
        | (1ULL << (fugue_sqlParser::THENULLS - 192))
        | (1ULL << (fugue_sqlParser::OF - 192))
        | (1ULL << (fugue_sqlParser::ON - 192))
        | (1ULL << (fugue_sqlParser::ONLY - 192))
        | (1ULL << (fugue_sqlParser::OPTION - 192))
        | (1ULL << (fugue_sqlParser::OPTIONS - 192))
        | (1ULL << (fugue_sqlParser::OR - 192))
        | (1ULL << (fugue_sqlParser::ORDER - 192))
        | (1ULL << (fugue_sqlParser::OUT - 192))
        | (1ULL << (fugue_sqlParser::OUTER - 192))
        | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 192))
        | (1ULL << (fugue_sqlParser::OVER - 192))
        | (1ULL << (fugue_sqlParser::OVERLAPS - 192))
        | (1ULL << (fugue_sqlParser::OVERLAY - 192))
        | (1ULL << (fugue_sqlParser::OVERWRITE - 192))
        | (1ULL << (fugue_sqlParser::PARTITION - 192))
        | (1ULL << (fugue_sqlParser::PARTITIONED - 192))
        | (1ULL << (fugue_sqlParser::PARTITIONS - 192))
        | (1ULL << (fugue_sqlParser::PERCENTLIT - 192))
        | (1ULL << (fugue_sqlParser::PIVOT - 192))
        | (1ULL << (fugue_sqlParser::PLACING - 192))
        | (1ULL << (fugue_sqlParser::POSITION - 192))
        | (1ULL << (fugue_sqlParser::PRECEDING - 192))
        | (1ULL << (fugue_sqlParser::PRIMARY - 192))
        | (1ULL << (fugue_sqlParser::PRINCIPALS - 192))
        | (1ULL << (fugue_sqlParser::PROPERTIES - 192))
        | (1ULL << (fugue_sqlParser::PURGE - 192))
        | (1ULL << (fugue_sqlParser::QUERY - 192))
        | (1ULL << (fugue_sqlParser::RANGE - 192))
        | (1ULL << (fugue_sqlParser::RECORDREADER - 192))
        | (1ULL << (fugue_sqlParser::RECORDWRITER - 192))
        | (1ULL << (fugue_sqlParser::RECOVER - 192))
        | (1ULL << (fugue_sqlParser::REDUCE - 192))
        | (1ULL << (fugue_sqlParser::REFERENCES - 192))
        | (1ULL << (fugue_sqlParser::REFRESH - 192))
        | (1ULL << (fugue_sqlParser::RENAME - 192))
        | (1ULL << (fugue_sqlParser::REPAIR - 192))
        | (1ULL << (fugue_sqlParser::REPLACE - 192))
        | (1ULL << (fugue_sqlParser::RESET - 192))
        | (1ULL << (fugue_sqlParser::RESTRICT - 192))
        | (1ULL << (fugue_sqlParser::REVOKE - 192))
        | (1ULL << (fugue_sqlParser::RIGHT - 192))
        | (1ULL << (fugue_sqlParser::RLIKE - 192))
        | (1ULL << (fugue_sqlParser::ROLE - 192))
        | (1ULL << (fugue_sqlParser::ROLES - 192))
        | (1ULL << (fugue_sqlParser::ROLLBACK - 192))
        | (1ULL << (fugue_sqlParser::ROLLUP - 192))
        | (1ULL << (fugue_sqlParser::ROW - 192))
        | (1ULL << (fugue_sqlParser::ROWS - 192))
        | (1ULL << (fugue_sqlParser::SCHEMA - 192))
        | (1ULL << (fugue_sqlParser::SECOND - 192))
        | (1ULL << (fugue_sqlParser::SELECT - 192))
        | (1ULL << (fugue_sqlParser::SEMI - 192))
        | (1ULL << (fugue_sqlParser::SEPARATED - 192))
        | (1ULL << (fugue_sqlParser::SERDE - 192))
        | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 192))
        | (1ULL << (fugue_sqlParser::SESSION_USER - 192))
        | (1ULL << (fugue_sqlParser::SET - 192))
        | (1ULL << (fugue_sqlParser::SETMINUS - 192))
        | (1ULL << (fugue_sqlParser::SETS - 192)))) != 0) || ((((_la - 256) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 256)) & ((1ULL << (fugue_sqlParser::SHOW - 256))
        | (1ULL << (fugue_sqlParser::SKEWED - 256))
        | (1ULL << (fugue_sqlParser::SOME - 256))
        | (1ULL << (fugue_sqlParser::SORT - 256))
        | (1ULL << (fugue_sqlParser::SORTED - 256))
        | (1ULL << (fugue_sqlParser::START - 256))
        | (1ULL << (fugue_sqlParser::STATISTICS - 256))
        | (1ULL << (fugue_sqlParser::STORED - 256))
        | (1ULL << (fugue_sqlParser::STRATIFY - 256))
        | (1ULL << (fugue_sqlParser::STRUCT - 256))
        | (1ULL << (fugue_sqlParser::SUBSTR - 256))
        | (1ULL << (fugue_sqlParser::SUBSTRING - 256))
        | (1ULL << (fugue_sqlParser::TABLE - 256))
        | (1ULL << (fugue_sqlParser::TABLES - 256))
        | (1ULL << (fugue_sqlParser::TABLESAMPLE - 256))
        | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 256))
        | (1ULL << (fugue_sqlParser::TEMPORARY - 256))
        | (1ULL << (fugue_sqlParser::TERMINATED - 256))
        | (1ULL << (fugue_sqlParser::THEN - 256))
        | (1ULL << (fugue_sqlParser::TO - 256))
        | (1ULL << (fugue_sqlParser::TOUCH - 256))
        | (1ULL << (fugue_sqlParser::TRAILING - 256))
        | (1ULL << (fugue_sqlParser::TRANSACTION - 256))
        | (1ULL << (fugue_sqlParser::TRANSACTIONS - 256))
        | (1ULL << (fugue_sqlParser::TRANSFORM - 256))
        | (1ULL << (fugue_sqlParser::TRIM - 256))
        | (1ULL << (fugue_sqlParser::TRUE - 256))
        | (1ULL << (fugue_sqlParser::TRUNCATE - 256))
        | (1ULL << (fugue_sqlParser::TYPE - 256))
        | (1ULL << (fugue_sqlParser::UNARCHIVE - 256))
        | (1ULL << (fugue_sqlParser::UNBOUNDED - 256))
        | (1ULL << (fugue_sqlParser::UNCACHE - 256))
        | (1ULL << (fugue_sqlParser::UNION - 256))
        | (1ULL << (fugue_sqlParser::UNIQUE - 256))
        | (1ULL << (fugue_sqlParser::UNKNOWN - 256))
        | (1ULL << (fugue_sqlParser::UNLOCK - 256))
        | (1ULL << (fugue_sqlParser::UNSET - 256))
        | (1ULL << (fugue_sqlParser::UPDATE - 256))
        | (1ULL << (fugue_sqlParser::USE - 256))
        | (1ULL << (fugue_sqlParser::USER - 256))
        | (1ULL << (fugue_sqlParser::USING - 256))
        | (1ULL << (fugue_sqlParser::VALUES - 256))
        | (1ULL << (fugue_sqlParser::VIEW - 256))
        | (1ULL << (fugue_sqlParser::VIEWS - 256))
        | (1ULL << (fugue_sqlParser::WHEN - 256))
        | (1ULL << (fugue_sqlParser::WHERE - 256))
        | (1ULL << (fugue_sqlParser::WINDOW - 256))
        | (1ULL << (fugue_sqlParser::WITH - 256))
        | (1ULL << (fugue_sqlParser::YEAR - 256))
        | (1ULL << (fugue_sqlParser::PLUS - 256))
        | (1ULL << (fugue_sqlParser::MINUS - 256))
        | (1ULL << (fugue_sqlParser::ASTERISK - 256))
        | (1ULL << (fugue_sqlParser::DIV - 256)))) != 0) || ((((_la - 320) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 320)) & ((1ULL << (fugue_sqlParser::TILDE - 320))
        | (1ULL << (fugue_sqlParser::STRING - 320))
        | (1ULL << (fugue_sqlParser::BIGINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::SMALLINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::TINYINT_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::INTEGER_VALUE - 320))
        | (1ULL << (fugue_sqlParser::EXPONENT_VALUE - 320))
        | (1ULL << (fugue_sqlParser::DECIMAL_VALUE - 320))
        | (1ULL << (fugue_sqlParser::DOUBLE_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::BIGDECIMAL_LITERAL - 320))
        | (1ULL << (fugue_sqlParser::IDENTIFIER - 320))
        | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 320)))) != 0)) {
        setState(3372);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 451, _ctx)) {
        case 1: {
          setState(3371);
          setQuantifier();
          break;
        }

        default:
          break;
        }
        setState(3374);
        antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext = expression();
        antlrcpp::downCast<FunctionCallContext *>(_localctx)->argument.push_back(antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext);
        setState(3379);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(3375);
          match(fugue_sqlParser::T__0);
          setState(3376);
          antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<FunctionCallContext *>(_localctx)->argument.push_back(antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext);
          setState(3381);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(3384);
      match(fugue_sqlParser::T__3);
      setState(3391);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 454, _ctx)) {
      case 1: {
        setState(3385);
        match(fugue_sqlParser::FILTER);
        setState(3386);
        match(fugue_sqlParser::T__2);
        setState(3387);
        match(fugue_sqlParser::WHERE);
        setState(3388);
        antlrcpp::downCast<FunctionCallContext *>(_localctx)->where = booleanExpression(0);
        setState(3389);
        match(fugue_sqlParser::T__3);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 455, _ctx)) {
      case 1: {
        setState(3393);
        match(fugue_sqlParser::OVER);
        setState(3394);
        windowSpec();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<LambdaContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3397);
      identifier();
      setState(3398);
      match(fugue_sqlParser::T__15);
      setState(3399);
      expression();
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<LambdaContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3401);
      match(fugue_sqlParser::T__2);
      setState(3402);
      identifier();
      setState(3405); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3403);
        match(fugue_sqlParser::T__0);
        setState(3404);
        identifier();
        setState(3407); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::T__0);
      setState(3409);
      match(fugue_sqlParser::T__3);
      setState(3410);
      match(fugue_sqlParser::T__15);
      setState(3411);
      expression();
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<ColumnReferenceContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3413);
      identifier();
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<ParenthesizedExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3414);
      match(fugue_sqlParser::T__2);
      setState(3415);
      expression();
      setState(3416);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<ExtractContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3418);
      match(fugue_sqlParser::EXTRACT);
      setState(3419);
      match(fugue_sqlParser::T__2);
      setState(3420);
      antlrcpp::downCast<ExtractContext *>(_localctx)->field = identifier();
      setState(3421);
      match(fugue_sqlParser::FROM);
      setState(3422);
      antlrcpp::downCast<ExtractContext *>(_localctx)->source = valueExpression(0);
      setState(3423);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<SubstringContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3425);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::SUBSTR

      || _la == fugue_sqlParser::SUBSTRING)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3426);
      match(fugue_sqlParser::T__2);
      setState(3427);
      antlrcpp::downCast<SubstringContext *>(_localctx)->istr = valueExpression(0);
      setState(3428);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::T__0 || _la == fugue_sqlParser::FROM)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3429);
      antlrcpp::downCast<SubstringContext *>(_localctx)->pos = valueExpression(0);
      setState(3432);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__0 || _la == fugue_sqlParser::FOR) {
        setState(3430);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::T__0 || _la == fugue_sqlParser::FOR)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(3431);
        antlrcpp::downCast<SubstringContext *>(_localctx)->ilen = valueExpression(0);
      }
      setState(3434);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<TrimContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3436);
      match(fugue_sqlParser::TRIM);
      setState(3437);
      match(fugue_sqlParser::T__2);
      setState(3439);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 458, _ctx)) {
      case 1: {
        setState(3438);
        antlrcpp::downCast<TrimContext *>(_localctx)->trimOption = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::BOTH || _la == fugue_sqlParser::LEADING || _la == fugue_sqlParser::TRAILING)) {
          antlrcpp::downCast<TrimContext *>(_localctx)->trimOption = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 459, _ctx)) {
      case 1: {
        setState(3441);
        antlrcpp::downCast<TrimContext *>(_localctx)->trimStr = valueExpression(0);
        break;
      }

      default:
        break;
      }
      setState(3444);
      match(fugue_sqlParser::FROM);
      setState(3445);
      antlrcpp::downCast<TrimContext *>(_localctx)->srcStr = valueExpression(0);
      setState(3446);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<OverlayContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3448);
      match(fugue_sqlParser::OVERLAY);
      setState(3449);
      match(fugue_sqlParser::T__2);
      setState(3450);
      antlrcpp::downCast<OverlayContext *>(_localctx)->iinput = valueExpression(0);
      setState(3451);
      match(fugue_sqlParser::PLACING);
      setState(3452);
      antlrcpp::downCast<OverlayContext *>(_localctx)->replace = valueExpression(0);
      setState(3453);
      match(fugue_sqlParser::FROM);
      setState(3454);
      antlrcpp::downCast<OverlayContext *>(_localctx)->position = valueExpression(0);
      setState(3457);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FOR) {
        setState(3455);
        match(fugue_sqlParser::FOR);
        setState(3456);
        antlrcpp::downCast<OverlayContext *>(_localctx)->length = valueExpression(0);
      }
      setState(3459);
      match(fugue_sqlParser::T__3);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(3473);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 463, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3471);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 462, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<SubscriptContext>(_tracker.createInstance<PrimaryExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->value = previousContext;
          pushNewRecursionContext(newContext, startState, RulePrimaryExpression);
          setState(3463);

          if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)");
          setState(3464);
          match(fugue_sqlParser::T__4);
          setState(3465);
          antlrcpp::downCast<SubscriptContext *>(_localctx)->index = valueExpression(0);
          setState(3466);
          match(fugue_sqlParser::T__5);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<DereferenceContext>(_tracker.createInstance<PrimaryExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->base = previousContext;
          pushNewRecursionContext(newContext, startState, RulePrimaryExpression);
          setState(3468);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(3469);
          match(fugue_sqlParser::T__6);
          setState(3470);
          antlrcpp::downCast<DereferenceContext *>(_localctx)->fieldName = identifier();
          break;
        }

        default:
          break;
        } 
      }
      setState(3475);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 463, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- ConstantContext ------------------------------------------------------------------

fugue_sqlParser::ConstantContext::ConstantContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::ConstantContext::getRuleIndex() const {
  return fugue_sqlParser::RuleConstant;
}

void fugue_sqlParser::ConstantContext::copyFrom(ConstantContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- NullLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::NullLiteralContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

fugue_sqlParser::NullLiteralContext::NullLiteralContext(ConstantContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::NullLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNullLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- StringLiteralContext ------------------------------------------------------------------

std::vector<tree::TerminalNode *> fugue_sqlParser::StringLiteralContext::STRING() {
  return getTokens(fugue_sqlParser::STRING);
}

tree::TerminalNode* fugue_sqlParser::StringLiteralContext::STRING(size_t i) {
  return getToken(fugue_sqlParser::STRING, i);
}

fugue_sqlParser::StringLiteralContext::StringLiteralContext(ConstantContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::StringLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitStringLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TypeConstructorContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext* fugue_sqlParser::TypeConstructorContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::TypeConstructorContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}

fugue_sqlParser::TypeConstructorContext::TypeConstructorContext(ConstantContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TypeConstructorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTypeConstructor(this);
  else
    return visitor->visitChildren(this);
}
//----------------- IntervalLiteralContext ------------------------------------------------------------------

fugue_sqlParser::IntervalContext* fugue_sqlParser::IntervalLiteralContext::interval() {
  return getRuleContext<fugue_sqlParser::IntervalContext>(0);
}

fugue_sqlParser::IntervalLiteralContext::IntervalLiteralContext(ConstantContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::IntervalLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIntervalLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- NumericLiteralContext ------------------------------------------------------------------

fugue_sqlParser::NumberContext* fugue_sqlParser::NumericLiteralContext::number() {
  return getRuleContext<fugue_sqlParser::NumberContext>(0);
}

fugue_sqlParser::NumericLiteralContext::NumericLiteralContext(ConstantContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::NumericLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNumericLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- BooleanLiteralContext ------------------------------------------------------------------

fugue_sqlParser::BooleanValueContext* fugue_sqlParser::BooleanLiteralContext::booleanValue() {
  return getRuleContext<fugue_sqlParser::BooleanValueContext>(0);
}

fugue_sqlParser::BooleanLiteralContext::BooleanLiteralContext(ConstantContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::BooleanLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitBooleanLiteral(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::ConstantContext* fugue_sqlParser::constant() {
  ConstantContext *_localctx = _tracker.createInstance<ConstantContext>(_ctx, getState());
  enterRule(_localctx, 348, fugue_sqlParser::RuleConstant);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3488);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 465, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::NullLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3476);
      match(fugue_sqlParser::THENULL);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::IntervalLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3477);
      interval();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TypeConstructorContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3478);
      identifier();
      setState(3479);
      match(fugue_sqlParser::STRING);
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::NumericLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(3481);
      number();
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::BooleanLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(3482);
      booleanValue();
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<fugue_sqlParser::StringLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 6);
      setState(3484); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(3483);
                match(fugue_sqlParser::STRING);
                break;
              }

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

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

  return _localctx;
}

//----------------- ComparisonOperatorContext ------------------------------------------------------------------

fugue_sqlParser::ComparisonOperatorContext::ComparisonOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::ComparisonEqualOperatorContext* fugue_sqlParser::ComparisonOperatorContext::comparisonEqualOperator() {
  return getRuleContext<fugue_sqlParser::ComparisonEqualOperatorContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::NEQ() {
  return getToken(fugue_sqlParser::NEQ, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::NEQJ() {
  return getToken(fugue_sqlParser::NEQJ, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::LT() {
  return getToken(fugue_sqlParser::LT, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::LTE() {
  return getToken(fugue_sqlParser::LTE, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::GT() {
  return getToken(fugue_sqlParser::GT, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::GTE() {
  return getToken(fugue_sqlParser::GTE, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonOperatorContext::NSEQ() {
  return getToken(fugue_sqlParser::NSEQ, 0);
}


size_t fugue_sqlParser::ComparisonOperatorContext::getRuleIndex() const {
  return fugue_sqlParser::RuleComparisonOperator;
}


std::any fugue_sqlParser::ComparisonOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitComparisonOperator(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ComparisonOperatorContext* fugue_sqlParser::comparisonOperator() {
  ComparisonOperatorContext *_localctx = _tracker.createInstance<ComparisonOperatorContext>(_ctx, getState());
  enterRule(_localctx, 350, fugue_sqlParser::RuleComparisonOperator);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3498);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::EQUAL:
      case fugue_sqlParser::DOUBLEEQUAL: {
        enterOuterAlt(_localctx, 1);
        setState(3490);
        comparisonEqualOperator();
        break;
      }

      case fugue_sqlParser::NEQ: {
        enterOuterAlt(_localctx, 2);
        setState(3491);
        match(fugue_sqlParser::NEQ);
        break;
      }

      case fugue_sqlParser::NEQJ: {
        enterOuterAlt(_localctx, 3);
        setState(3492);
        match(fugue_sqlParser::NEQJ);
        break;
      }

      case fugue_sqlParser::LT: {
        enterOuterAlt(_localctx, 4);
        setState(3493);
        match(fugue_sqlParser::LT);
        break;
      }

      case fugue_sqlParser::LTE: {
        enterOuterAlt(_localctx, 5);
        setState(3494);
        match(fugue_sqlParser::LTE);
        break;
      }

      case fugue_sqlParser::GT: {
        enterOuterAlt(_localctx, 6);
        setState(3495);
        match(fugue_sqlParser::GT);
        break;
      }

      case fugue_sqlParser::GTE: {
        enterOuterAlt(_localctx, 7);
        setState(3496);
        match(fugue_sqlParser::GTE);
        break;
      }

      case fugue_sqlParser::NSEQ: {
        enterOuterAlt(_localctx, 8);
        setState(3497);
        match(fugue_sqlParser::NSEQ);
        break;
      }

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

  return _localctx;
}

//----------------- ComparisonEqualOperatorContext ------------------------------------------------------------------

fugue_sqlParser::ComparisonEqualOperatorContext::ComparisonEqualOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::ComparisonEqualOperatorContext::DOUBLEEQUAL() {
  return getToken(fugue_sqlParser::DOUBLEEQUAL, 0);
}

tree::TerminalNode* fugue_sqlParser::ComparisonEqualOperatorContext::EQUAL() {
  return getToken(fugue_sqlParser::EQUAL, 0);
}


size_t fugue_sqlParser::ComparisonEqualOperatorContext::getRuleIndex() const {
  return fugue_sqlParser::RuleComparisonEqualOperator;
}


std::any fugue_sqlParser::ComparisonEqualOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitComparisonEqualOperator(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ComparisonEqualOperatorContext* fugue_sqlParser::comparisonEqualOperator() {
  ComparisonEqualOperatorContext *_localctx = _tracker.createInstance<ComparisonEqualOperatorContext>(_ctx, getState());
  enterRule(_localctx, 352, fugue_sqlParser::RuleComparisonEqualOperator);
  size_t _la = 0;

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

    || _la == fugue_sqlParser::DOUBLEEQUAL)) {
    _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;
}

//----------------- ArithmeticOperatorContext ------------------------------------------------------------------

fugue_sqlParser::ArithmeticOperatorContext::ArithmeticOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::PLUS() {
  return getToken(fugue_sqlParser::PLUS, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::ASTERISK() {
  return getToken(fugue_sqlParser::ASTERISK, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::SLASH() {
  return getToken(fugue_sqlParser::SLASH, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::PERCENT() {
  return getToken(fugue_sqlParser::PERCENT, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::DIV() {
  return getToken(fugue_sqlParser::DIV, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::TILDE() {
  return getToken(fugue_sqlParser::TILDE, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::AMPERSAND() {
  return getToken(fugue_sqlParser::AMPERSAND, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::PIPE() {
  return getToken(fugue_sqlParser::PIPE, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::CONCAT_PIPE() {
  return getToken(fugue_sqlParser::CONCAT_PIPE, 0);
}

tree::TerminalNode* fugue_sqlParser::ArithmeticOperatorContext::HAT() {
  return getToken(fugue_sqlParser::HAT, 0);
}


size_t fugue_sqlParser::ArithmeticOperatorContext::getRuleIndex() const {
  return fugue_sqlParser::RuleArithmeticOperator;
}


std::any fugue_sqlParser::ArithmeticOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitArithmeticOperator(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ArithmeticOperatorContext* fugue_sqlParser::arithmeticOperator() {
  ArithmeticOperatorContext *_localctx = _tracker.createInstance<ArithmeticOperatorContext>(_ctx, getState());
  enterRule(_localctx, 354, fugue_sqlParser::RuleArithmeticOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3502);
    _la = _input->LA(1);
    if (!(((((_la - 314) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 314)) & ((1ULL << (fugue_sqlParser::PLUS - 314))
      | (1ULL << (fugue_sqlParser::MINUS - 314))
      | (1ULL << (fugue_sqlParser::ASTERISK - 314))
      | (1ULL << (fugue_sqlParser::SLASH - 314))
      | (1ULL << (fugue_sqlParser::PERCENT - 314))
      | (1ULL << (fugue_sqlParser::DIV - 314))
      | (1ULL << (fugue_sqlParser::TILDE - 314))
      | (1ULL << (fugue_sqlParser::AMPERSAND - 314))
      | (1ULL << (fugue_sqlParser::PIPE - 314))
      | (1ULL << (fugue_sqlParser::CONCAT_PIPE - 314))
      | (1ULL << (fugue_sqlParser::HAT - 314)))) != 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;
}

//----------------- PredicateOperatorContext ------------------------------------------------------------------

fugue_sqlParser::PredicateOperatorContext::PredicateOperatorContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::PredicateOperatorContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateOperatorContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateOperatorContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

tree::TerminalNode* fugue_sqlParser::PredicateOperatorContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}


size_t fugue_sqlParser::PredicateOperatorContext::getRuleIndex() const {
  return fugue_sqlParser::RulePredicateOperator;
}


std::any fugue_sqlParser::PredicateOperatorContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPredicateOperator(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::PredicateOperatorContext* fugue_sqlParser::predicateOperator() {
  PredicateOperatorContext *_localctx = _tracker.createInstance<PredicateOperatorContext>(_ctx, getState());
  enterRule(_localctx, 356, fugue_sqlParser::RulePredicateOperator);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3504);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::AND || ((((_la - 154) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 154)) & ((1ULL << (fugue_sqlParser::IN - 154))
      | (1ULL << (fugue_sqlParser::NOT - 154))
      | (1ULL << (fugue_sqlParser::OR - 154)))) != 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;
}

//----------------- BooleanValueContext ------------------------------------------------------------------

fugue_sqlParser::BooleanValueContext::BooleanValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::BooleanValueContext::TRUE() {
  return getToken(fugue_sqlParser::TRUE, 0);
}

tree::TerminalNode* fugue_sqlParser::BooleanValueContext::FALSE() {
  return getToken(fugue_sqlParser::FALSE, 0);
}


size_t fugue_sqlParser::BooleanValueContext::getRuleIndex() const {
  return fugue_sqlParser::RuleBooleanValue;
}


std::any fugue_sqlParser::BooleanValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitBooleanValue(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::BooleanValueContext* fugue_sqlParser::booleanValue() {
  BooleanValueContext *_localctx = _tracker.createInstance<BooleanValueContext>(_ctx, getState());
  enterRule(_localctx, 358, fugue_sqlParser::RuleBooleanValue);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3506);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::FALSE || _la == fugue_sqlParser::TRUE)) {
    _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 ------------------------------------------------------------------

fugue_sqlParser::IntervalContext::IntervalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::IntervalContext::INTERVAL() {
  return getToken(fugue_sqlParser::INTERVAL, 0);
}

fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext* fugue_sqlParser::IntervalContext::errorCapturingMultiUnitsInterval() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext>(0);
}

fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext* fugue_sqlParser::IntervalContext::errorCapturingUnitToUnitInterval() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext>(0);
}


size_t fugue_sqlParser::IntervalContext::getRuleIndex() const {
  return fugue_sqlParser::RuleInterval;
}


std::any fugue_sqlParser::IntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitInterval(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IntervalContext* fugue_sqlParser::interval() {
  IntervalContext *_localctx = _tracker.createInstance<IntervalContext>(_ctx, getState());
  enterRule(_localctx, 360, fugue_sqlParser::RuleInterval);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 467, _ctx)) {
    case 1: {
      setState(3509);
      errorCapturingMultiUnitsInterval();
      break;
    }

    case 2: {
      setState(3510);
      errorCapturingUnitToUnitInterval();
      break;
    }

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

  return _localctx;
}

//----------------- ErrorCapturingMultiUnitsIntervalContext ------------------------------------------------------------------

fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext::ErrorCapturingMultiUnitsIntervalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::MultiUnitsIntervalContext* fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext::multiUnitsInterval() {
  return getRuleContext<fugue_sqlParser::MultiUnitsIntervalContext>(0);
}

fugue_sqlParser::UnitToUnitIntervalContext* fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext::unitToUnitInterval() {
  return getRuleContext<fugue_sqlParser::UnitToUnitIntervalContext>(0);
}


size_t fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext::getRuleIndex() const {
  return fugue_sqlParser::RuleErrorCapturingMultiUnitsInterval;
}


std::any fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitErrorCapturingMultiUnitsInterval(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ErrorCapturingMultiUnitsIntervalContext* fugue_sqlParser::errorCapturingMultiUnitsInterval() {
  ErrorCapturingMultiUnitsIntervalContext *_localctx = _tracker.createInstance<ErrorCapturingMultiUnitsIntervalContext>(_ctx, getState());
  enterRule(_localctx, 362, fugue_sqlParser::RuleErrorCapturingMultiUnitsInterval);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 468, _ctx)) {
    case 1: {
      setState(3514);
      unitToUnitInterval();
      break;
    }

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

  return _localctx;
}

//----------------- MultiUnitsIntervalContext ------------------------------------------------------------------

fugue_sqlParser::MultiUnitsIntervalContext::MultiUnitsIntervalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::IntervalValueContext *> fugue_sqlParser::MultiUnitsIntervalContext::intervalValue() {
  return getRuleContexts<fugue_sqlParser::IntervalValueContext>();
}

fugue_sqlParser::IntervalValueContext* fugue_sqlParser::MultiUnitsIntervalContext::intervalValue(size_t i) {
  return getRuleContext<fugue_sqlParser::IntervalValueContext>(i);
}

std::vector<fugue_sqlParser::IntervalUnitContext *> fugue_sqlParser::MultiUnitsIntervalContext::intervalUnit() {
  return getRuleContexts<fugue_sqlParser::IntervalUnitContext>();
}

fugue_sqlParser::IntervalUnitContext* fugue_sqlParser::MultiUnitsIntervalContext::intervalUnit(size_t i) {
  return getRuleContext<fugue_sqlParser::IntervalUnitContext>(i);
}


size_t fugue_sqlParser::MultiUnitsIntervalContext::getRuleIndex() const {
  return fugue_sqlParser::RuleMultiUnitsInterval;
}


std::any fugue_sqlParser::MultiUnitsIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitMultiUnitsInterval(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::MultiUnitsIntervalContext* fugue_sqlParser::multiUnitsInterval() {
  MultiUnitsIntervalContext *_localctx = _tracker.createInstance<MultiUnitsIntervalContext>(_ctx, getState());
  enterRule(_localctx, 364, fugue_sqlParser::RuleMultiUnitsInterval);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3520); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(3517);
              intervalValue();
              setState(3518);
              intervalUnit();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(3522); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 469, _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;
}

//----------------- ErrorCapturingUnitToUnitIntervalContext ------------------------------------------------------------------

fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext::ErrorCapturingUnitToUnitIntervalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::UnitToUnitIntervalContext *> fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext::unitToUnitInterval() {
  return getRuleContexts<fugue_sqlParser::UnitToUnitIntervalContext>();
}

fugue_sqlParser::UnitToUnitIntervalContext* fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext::unitToUnitInterval(size_t i) {
  return getRuleContext<fugue_sqlParser::UnitToUnitIntervalContext>(i);
}

fugue_sqlParser::MultiUnitsIntervalContext* fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext::multiUnitsInterval() {
  return getRuleContext<fugue_sqlParser::MultiUnitsIntervalContext>(0);
}


size_t fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext::getRuleIndex() const {
  return fugue_sqlParser::RuleErrorCapturingUnitToUnitInterval;
}


std::any fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitErrorCapturingUnitToUnitInterval(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ErrorCapturingUnitToUnitIntervalContext* fugue_sqlParser::errorCapturingUnitToUnitInterval() {
  ErrorCapturingUnitToUnitIntervalContext *_localctx = _tracker.createInstance<ErrorCapturingUnitToUnitIntervalContext>(_ctx, getState());
  enterRule(_localctx, 366, fugue_sqlParser::RuleErrorCapturingUnitToUnitInterval);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3524);
    antlrcpp::downCast<ErrorCapturingUnitToUnitIntervalContext *>(_localctx)->body = unitToUnitInterval();
    setState(3527);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 470, _ctx)) {
    case 1: {
      setState(3525);
      antlrcpp::downCast<ErrorCapturingUnitToUnitIntervalContext *>(_localctx)->error1 = multiUnitsInterval();
      break;
    }

    case 2: {
      setState(3526);
      antlrcpp::downCast<ErrorCapturingUnitToUnitIntervalContext *>(_localctx)->error2 = unitToUnitInterval();
      break;
    }

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

  return _localctx;
}

//----------------- UnitToUnitIntervalContext ------------------------------------------------------------------

fugue_sqlParser::UnitToUnitIntervalContext::UnitToUnitIntervalContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::UnitToUnitIntervalContext::TO() {
  return getToken(fugue_sqlParser::TO, 0);
}

fugue_sqlParser::IntervalValueContext* fugue_sqlParser::UnitToUnitIntervalContext::intervalValue() {
  return getRuleContext<fugue_sqlParser::IntervalValueContext>(0);
}

std::vector<fugue_sqlParser::IntervalUnitContext *> fugue_sqlParser::UnitToUnitIntervalContext::intervalUnit() {
  return getRuleContexts<fugue_sqlParser::IntervalUnitContext>();
}

fugue_sqlParser::IntervalUnitContext* fugue_sqlParser::UnitToUnitIntervalContext::intervalUnit(size_t i) {
  return getRuleContext<fugue_sqlParser::IntervalUnitContext>(i);
}


size_t fugue_sqlParser::UnitToUnitIntervalContext::getRuleIndex() const {
  return fugue_sqlParser::RuleUnitToUnitInterval;
}


std::any fugue_sqlParser::UnitToUnitIntervalContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUnitToUnitInterval(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::UnitToUnitIntervalContext* fugue_sqlParser::unitToUnitInterval() {
  UnitToUnitIntervalContext *_localctx = _tracker.createInstance<UnitToUnitIntervalContext>(_ctx, getState());
  enterRule(_localctx, 368, fugue_sqlParser::RuleUnitToUnitInterval);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3529);
    antlrcpp::downCast<UnitToUnitIntervalContext *>(_localctx)->value = intervalValue();
    setState(3530);
    antlrcpp::downCast<UnitToUnitIntervalContext *>(_localctx)->ifrom = intervalUnit();
    setState(3531);
    match(fugue_sqlParser::TO);
    setState(3532);
    antlrcpp::downCast<UnitToUnitIntervalContext *>(_localctx)->to = intervalUnit();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IntervalValueContext ------------------------------------------------------------------

fugue_sqlParser::IntervalValueContext::IntervalValueContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::IntervalValueContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalValueContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalValueContext::PLUS() {
  return getToken(fugue_sqlParser::PLUS, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalValueContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalValueContext::STRING() {
  return getToken(fugue_sqlParser::STRING, 0);
}


size_t fugue_sqlParser::IntervalValueContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIntervalValue;
}


std::any fugue_sqlParser::IntervalValueContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIntervalValue(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IntervalValueContext* fugue_sqlParser::intervalValue() {
  IntervalValueContext *_localctx = _tracker.createInstance<IntervalValueContext>(_ctx, getState());
  enterRule(_localctx, 370, fugue_sqlParser::RuleIntervalValue);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3539);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::PLUS:
      case fugue_sqlParser::MINUS:
      case fugue_sqlParser::INTEGER_VALUE:
      case fugue_sqlParser::DECIMAL_VALUE: {
        enterOuterAlt(_localctx, 1);
        setState(3535);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::PLUS

        || _la == fugue_sqlParser::MINUS) {
          setState(3534);
          _la = _input->LA(1);
          if (!(_la == fugue_sqlParser::PLUS

          || _la == fugue_sqlParser::MINUS)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        setState(3537);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::INTEGER_VALUE

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

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 2);
        setState(3538);
        match(fugue_sqlParser::STRING);
        break;
      }

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

  return _localctx;
}

//----------------- IntervalUnitContext ------------------------------------------------------------------

fugue_sqlParser::IntervalUnitContext::IntervalUnitContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::IntervalUnitContext::DAY() {
  return getToken(fugue_sqlParser::DAY, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalUnitContext::HOUR() {
  return getToken(fugue_sqlParser::HOUR, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalUnitContext::MINUTE() {
  return getToken(fugue_sqlParser::MINUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalUnitContext::MONTH() {
  return getToken(fugue_sqlParser::MONTH, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalUnitContext::SECOND() {
  return getToken(fugue_sqlParser::SECOND, 0);
}

tree::TerminalNode* fugue_sqlParser::IntervalUnitContext::YEAR() {
  return getToken(fugue_sqlParser::YEAR, 0);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::IntervalUnitContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}


size_t fugue_sqlParser::IntervalUnitContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIntervalUnit;
}


std::any fugue_sqlParser::IntervalUnitContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIntervalUnit(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IntervalUnitContext* fugue_sqlParser::intervalUnit() {
  IntervalUnitContext *_localctx = _tracker.createInstance<IntervalUnitContext>(_ctx, getState());
  enterRule(_localctx, 372, fugue_sqlParser::RuleIntervalUnit);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3542);
      match(fugue_sqlParser::HOUR);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3543);
      match(fugue_sqlParser::MINUTE);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3544);
      match(fugue_sqlParser::MONTH);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3545);
      match(fugue_sqlParser::SECOND);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(3546);
      match(fugue_sqlParser::YEAR);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(3547);
      identifier();
      break;
    }

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

  return _localctx;
}

//----------------- ColPositionContext ------------------------------------------------------------------

fugue_sqlParser::ColPositionContext::ColPositionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::ColPositionContext::FIRST() {
  return getToken(fugue_sqlParser::FIRST, 0);
}

tree::TerminalNode* fugue_sqlParser::ColPositionContext::AFTER() {
  return getToken(fugue_sqlParser::AFTER, 0);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::ColPositionContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}


size_t fugue_sqlParser::ColPositionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleColPosition;
}


std::any fugue_sqlParser::ColPositionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitColPosition(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ColPositionContext* fugue_sqlParser::colPosition() {
  ColPositionContext *_localctx = _tracker.createInstance<ColPositionContext>(_ctx, getState());
  enterRule(_localctx, 374, fugue_sqlParser::RuleColPosition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3553);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::FIRST: {
        enterOuterAlt(_localctx, 1);
        setState(3550);
        antlrcpp::downCast<ColPositionContext *>(_localctx)->position = match(fugue_sqlParser::FIRST);
        break;
      }

      case fugue_sqlParser::AFTER: {
        enterOuterAlt(_localctx, 2);
        setState(3551);
        antlrcpp::downCast<ColPositionContext *>(_localctx)->position = match(fugue_sqlParser::AFTER);
        setState(3552);
        antlrcpp::downCast<ColPositionContext *>(_localctx)->afterCol = errorCapturingIdentifier();
        break;
      }

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

  return _localctx;
}

//----------------- DataTypeContext ------------------------------------------------------------------

fugue_sqlParser::DataTypeContext::DataTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::DataTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleDataType;
}

void fugue_sqlParser::DataTypeContext::copyFrom(DataTypeContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- ComplexDataTypeContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ComplexDataTypeContext::LT() {
  return getToken(fugue_sqlParser::LT, 0);
}

std::vector<fugue_sqlParser::DataTypeContext *> fugue_sqlParser::ComplexDataTypeContext::dataType() {
  return getRuleContexts<fugue_sqlParser::DataTypeContext>();
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::ComplexDataTypeContext::dataType(size_t i) {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(i);
}

tree::TerminalNode* fugue_sqlParser::ComplexDataTypeContext::GT() {
  return getToken(fugue_sqlParser::GT, 0);
}

tree::TerminalNode* fugue_sqlParser::ComplexDataTypeContext::ARRAY() {
  return getToken(fugue_sqlParser::ARRAY, 0);
}

tree::TerminalNode* fugue_sqlParser::ComplexDataTypeContext::MAP() {
  return getToken(fugue_sqlParser::MAP, 0);
}

tree::TerminalNode* fugue_sqlParser::ComplexDataTypeContext::STRUCT() {
  return getToken(fugue_sqlParser::STRUCT, 0);
}

tree::TerminalNode* fugue_sqlParser::ComplexDataTypeContext::NEQ() {
  return getToken(fugue_sqlParser::NEQ, 0);
}

fugue_sqlParser::ComplexColTypeListContext* fugue_sqlParser::ComplexDataTypeContext::complexColTypeList() {
  return getRuleContext<fugue_sqlParser::ComplexColTypeListContext>(0);
}

fugue_sqlParser::ComplexDataTypeContext::ComplexDataTypeContext(DataTypeContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ComplexDataTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitComplexDataType(this);
  else
    return visitor->visitChildren(this);
}
//----------------- PrimitiveDataTypeContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext* fugue_sqlParser::PrimitiveDataTypeContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::PrimitiveDataTypeContext::INTEGER_VALUE() {
  return getTokens(fugue_sqlParser::INTEGER_VALUE);
}

tree::TerminalNode* fugue_sqlParser::PrimitiveDataTypeContext::INTEGER_VALUE(size_t i) {
  return getToken(fugue_sqlParser::INTEGER_VALUE, i);
}

fugue_sqlParser::PrimitiveDataTypeContext::PrimitiveDataTypeContext(DataTypeContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::PrimitiveDataTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitPrimitiveDataType(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::DataTypeContext* fugue_sqlParser::dataType() {
  DataTypeContext *_localctx = _tracker.createInstance<DataTypeContext>(_ctx, getState());
  enterRule(_localctx, 376, fugue_sqlParser::RuleDataType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3589);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 479, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ComplexDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3555);
      antlrcpp::downCast<ComplexDataTypeContext *>(_localctx)->icomplex = match(fugue_sqlParser::ARRAY);
      setState(3556);
      match(fugue_sqlParser::LT);
      setState(3557);
      dataType();
      setState(3558);
      match(fugue_sqlParser::GT);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ComplexDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3560);
      antlrcpp::downCast<ComplexDataTypeContext *>(_localctx)->icomplex = match(fugue_sqlParser::MAP);
      setState(3561);
      match(fugue_sqlParser::LT);
      setState(3562);
      dataType();
      setState(3563);
      match(fugue_sqlParser::T__0);
      setState(3564);
      dataType();
      setState(3565);
      match(fugue_sqlParser::GT);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ComplexDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3567);
      antlrcpp::downCast<ComplexDataTypeContext *>(_localctx)->icomplex = match(fugue_sqlParser::STRUCT);
      setState(3574);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::LT: {
          setState(3568);
          match(fugue_sqlParser::LT);
          setState(3570);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (((((_la - 53) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 53)) & ((1ULL << (fugue_sqlParser::ADD - 53))
            | (1ULL << (fugue_sqlParser::AFTER - 53))
            | (1ULL << (fugue_sqlParser::ALL - 53))
            | (1ULL << (fugue_sqlParser::ALTER - 53))
            | (1ULL << (fugue_sqlParser::ANALYZE - 53))
            | (1ULL << (fugue_sqlParser::AND - 53))
            | (1ULL << (fugue_sqlParser::ANTI - 53))
            | (1ULL << (fugue_sqlParser::ANY - 53))
            | (1ULL << (fugue_sqlParser::ARCHIVE - 53))
            | (1ULL << (fugue_sqlParser::ARRAY - 53))
            | (1ULL << (fugue_sqlParser::AS - 53))
            | (1ULL << (fugue_sqlParser::ASC - 53))
            | (1ULL << (fugue_sqlParser::AT - 53))
            | (1ULL << (fugue_sqlParser::AUTHORIZATION - 53))
            | (1ULL << (fugue_sqlParser::BETWEEN - 53))
            | (1ULL << (fugue_sqlParser::BOTH - 53))
            | (1ULL << (fugue_sqlParser::BUCKET - 53))
            | (1ULL << (fugue_sqlParser::BUCKETS - 53))
            | (1ULL << (fugue_sqlParser::BY - 53))
            | (1ULL << (fugue_sqlParser::CACHE - 53))
            | (1ULL << (fugue_sqlParser::CASCADE - 53))
            | (1ULL << (fugue_sqlParser::CASE - 53))
            | (1ULL << (fugue_sqlParser::CAST - 53))
            | (1ULL << (fugue_sqlParser::CHANGE - 53))
            | (1ULL << (fugue_sqlParser::CHECK - 53))
            | (1ULL << (fugue_sqlParser::CLEAR - 53))
            | (1ULL << (fugue_sqlParser::CLUSTER - 53))
            | (1ULL << (fugue_sqlParser::CLUSTERED - 53))
            | (1ULL << (fugue_sqlParser::CODEGEN - 53))
            | (1ULL << (fugue_sqlParser::COLLATE - 53))
            | (1ULL << (fugue_sqlParser::COLLECTION - 53))
            | (1ULL << (fugue_sqlParser::COLUMN - 53))
            | (1ULL << (fugue_sqlParser::COLUMNS - 53))
            | (1ULL << (fugue_sqlParser::COMMENT - 53))
            | (1ULL << (fugue_sqlParser::COMMIT - 53))
            | (1ULL << (fugue_sqlParser::COMPACT - 53))
            | (1ULL << (fugue_sqlParser::COMPACTIONS - 53))
            | (1ULL << (fugue_sqlParser::COMPUTE - 53))
            | (1ULL << (fugue_sqlParser::CONCATENATE - 53))
            | (1ULL << (fugue_sqlParser::CONSTRAINT - 53))
            | (1ULL << (fugue_sqlParser::COST - 53))
            | (1ULL << (fugue_sqlParser::CREATE - 53))
            | (1ULL << (fugue_sqlParser::CROSS - 53))
            | (1ULL << (fugue_sqlParser::CUBE - 53))
            | (1ULL << (fugue_sqlParser::CURRENT - 53))
            | (1ULL << (fugue_sqlParser::CURRENT_DATE - 53))
            | (1ULL << (fugue_sqlParser::CURRENT_TIME - 53))
            | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 53))
            | (1ULL << (fugue_sqlParser::CURRENT_USER - 53))
            | (1ULL << (fugue_sqlParser::DATA - 53))
            | (1ULL << (fugue_sqlParser::DATABASE - 53))
            | (1ULL << (fugue_sqlParser::DATABASES - 53))
            | (1ULL << (fugue_sqlParser::DAY - 53))
            | (1ULL << (fugue_sqlParser::DBPROPERTIES - 53))
            | (1ULL << (fugue_sqlParser::DEFINED - 53))
            | (1ULL << (fugue_sqlParser::DELETE - 53))
            | (1ULL << (fugue_sqlParser::DELIMITED - 53))
            | (1ULL << (fugue_sqlParser::DESC - 53))
            | (1ULL << (fugue_sqlParser::DESCRIBE - 53))
            | (1ULL << (fugue_sqlParser::DFS - 53))
            | (1ULL << (fugue_sqlParser::DIRECTORIES - 53))
            | (1ULL << (fugue_sqlParser::DIRECTORY - 53))
            | (1ULL << (fugue_sqlParser::DISTINCT - 53))
            | (1ULL << (fugue_sqlParser::DISTRIBUTE - 53)))) != 0) || ((((_la - 117) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 117)) & ((1ULL << (fugue_sqlParser::DROP - 117))
            | (1ULL << (fugue_sqlParser::ELSE - 117))
            | (1ULL << (fugue_sqlParser::END - 117))
            | (1ULL << (fugue_sqlParser::ESCAPE - 117))
            | (1ULL << (fugue_sqlParser::ESCAPED - 117))
            | (1ULL << (fugue_sqlParser::EXCEPT - 117))
            | (1ULL << (fugue_sqlParser::EXCHANGE - 117))
            | (1ULL << (fugue_sqlParser::EXISTS - 117))
            | (1ULL << (fugue_sqlParser::EXPLAIN - 117))
            | (1ULL << (fugue_sqlParser::EXPORT - 117))
            | (1ULL << (fugue_sqlParser::EXTENDED - 117))
            | (1ULL << (fugue_sqlParser::EXTERNAL - 117))
            | (1ULL << (fugue_sqlParser::EXTRACT - 117))
            | (1ULL << (fugue_sqlParser::FALSE - 117))
            | (1ULL << (fugue_sqlParser::FETCH - 117))
            | (1ULL << (fugue_sqlParser::FIELDS - 117))
            | (1ULL << (fugue_sqlParser::FILTER - 117))
            | (1ULL << (fugue_sqlParser::FILEFORMAT - 117))
            | (1ULL << (fugue_sqlParser::FIRST - 117))
            | (1ULL << (fugue_sqlParser::FOLLOWING - 117))
            | (1ULL << (fugue_sqlParser::FOR - 117))
            | (1ULL << (fugue_sqlParser::FOREIGN - 117))
            | (1ULL << (fugue_sqlParser::FORMAT - 117))
            | (1ULL << (fugue_sqlParser::FORMATTED - 117))
            | (1ULL << (fugue_sqlParser::FROM - 117))
            | (1ULL << (fugue_sqlParser::FULL - 117))
            | (1ULL << (fugue_sqlParser::FUNCTION - 117))
            | (1ULL << (fugue_sqlParser::FUNCTIONS - 117))
            | (1ULL << (fugue_sqlParser::GLOBAL - 117))
            | (1ULL << (fugue_sqlParser::GRANT - 117))
            | (1ULL << (fugue_sqlParser::GROUP - 117))
            | (1ULL << (fugue_sqlParser::GROUPING - 117))
            | (1ULL << (fugue_sqlParser::HAVING - 117))
            | (1ULL << (fugue_sqlParser::HOUR - 117))
            | (1ULL << (fugue_sqlParser::IF - 117))
            | (1ULL << (fugue_sqlParser::IGNORE - 117))
            | (1ULL << (fugue_sqlParser::IMPORT - 117))
            | (1ULL << (fugue_sqlParser::IN - 117))
            | (1ULL << (fugue_sqlParser::INDEX - 117))
            | (1ULL << (fugue_sqlParser::INDEXES - 117))
            | (1ULL << (fugue_sqlParser::INNER - 117))
            | (1ULL << (fugue_sqlParser::INPATH - 117))
            | (1ULL << (fugue_sqlParser::INPUTFORMAT - 117))
            | (1ULL << (fugue_sqlParser::INSERT - 117))
            | (1ULL << (fugue_sqlParser::INTERSECT - 117))
            | (1ULL << (fugue_sqlParser::INTERVAL - 117))
            | (1ULL << (fugue_sqlParser::INTO - 117))
            | (1ULL << (fugue_sqlParser::IS - 117))
            | (1ULL << (fugue_sqlParser::ITEMS - 117))
            | (1ULL << (fugue_sqlParser::JOIN - 117))
            | (1ULL << (fugue_sqlParser::KEYS - 117))
            | (1ULL << (fugue_sqlParser::LAST - 117))
            | (1ULL << (fugue_sqlParser::LATERAL - 117))
            | (1ULL << (fugue_sqlParser::LAZY - 117))
            | (1ULL << (fugue_sqlParser::LEADING - 117))
            | (1ULL << (fugue_sqlParser::LEFT - 117))
            | (1ULL << (fugue_sqlParser::LIKE - 117))
            | (1ULL << (fugue_sqlParser::LIMIT - 117))
            | (1ULL << (fugue_sqlParser::LINES - 117))
            | (1ULL << (fugue_sqlParser::LIST - 117))
            | (1ULL << (fugue_sqlParser::LOAD - 117))
            | (1ULL << (fugue_sqlParser::LOCAL - 117))
            | (1ULL << (fugue_sqlParser::LOCATION - 117))
            | (1ULL << (fugue_sqlParser::LOCK - 117)))) != 0) || ((((_la - 181) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 181)) & ((1ULL << (fugue_sqlParser::LOCKS - 181))
            | (1ULL << (fugue_sqlParser::LOGICAL - 181))
            | (1ULL << (fugue_sqlParser::MACRO - 181))
            | (1ULL << (fugue_sqlParser::MAP - 181))
            | (1ULL << (fugue_sqlParser::MATCHED - 181))
            | (1ULL << (fugue_sqlParser::MERGE - 181))
            | (1ULL << (fugue_sqlParser::MINUTE - 181))
            | (1ULL << (fugue_sqlParser::MONTH - 181))
            | (1ULL << (fugue_sqlParser::MSCK - 181))
            | (1ULL << (fugue_sqlParser::NAMESPACE - 181))
            | (1ULL << (fugue_sqlParser::NAMESPACES - 181))
            | (1ULL << (fugue_sqlParser::NATURAL - 181))
            | (1ULL << (fugue_sqlParser::NO - 181))
            | (1ULL << (fugue_sqlParser::NOT - 181))
            | (1ULL << (fugue_sqlParser::THENULL - 181))
            | (1ULL << (fugue_sqlParser::THENULLS - 181))
            | (1ULL << (fugue_sqlParser::OF - 181))
            | (1ULL << (fugue_sqlParser::ON - 181))
            | (1ULL << (fugue_sqlParser::ONLY - 181))
            | (1ULL << (fugue_sqlParser::OPTION - 181))
            | (1ULL << (fugue_sqlParser::OPTIONS - 181))
            | (1ULL << (fugue_sqlParser::OR - 181))
            | (1ULL << (fugue_sqlParser::ORDER - 181))
            | (1ULL << (fugue_sqlParser::OUT - 181))
            | (1ULL << (fugue_sqlParser::OUTER - 181))
            | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 181))
            | (1ULL << (fugue_sqlParser::OVER - 181))
            | (1ULL << (fugue_sqlParser::OVERLAPS - 181))
            | (1ULL << (fugue_sqlParser::OVERLAY - 181))
            | (1ULL << (fugue_sqlParser::OVERWRITE - 181))
            | (1ULL << (fugue_sqlParser::PARTITION - 181))
            | (1ULL << (fugue_sqlParser::PARTITIONED - 181))
            | (1ULL << (fugue_sqlParser::PARTITIONS - 181))
            | (1ULL << (fugue_sqlParser::PERCENTLIT - 181))
            | (1ULL << (fugue_sqlParser::PIVOT - 181))
            | (1ULL << (fugue_sqlParser::PLACING - 181))
            | (1ULL << (fugue_sqlParser::POSITION - 181))
            | (1ULL << (fugue_sqlParser::PRECEDING - 181))
            | (1ULL << (fugue_sqlParser::PRIMARY - 181))
            | (1ULL << (fugue_sqlParser::PRINCIPALS - 181))
            | (1ULL << (fugue_sqlParser::PROPERTIES - 181))
            | (1ULL << (fugue_sqlParser::PURGE - 181))
            | (1ULL << (fugue_sqlParser::QUERY - 181))
            | (1ULL << (fugue_sqlParser::RANGE - 181))
            | (1ULL << (fugue_sqlParser::RECORDREADER - 181))
            | (1ULL << (fugue_sqlParser::RECORDWRITER - 181))
            | (1ULL << (fugue_sqlParser::RECOVER - 181))
            | (1ULL << (fugue_sqlParser::REDUCE - 181))
            | (1ULL << (fugue_sqlParser::REFERENCES - 181))
            | (1ULL << (fugue_sqlParser::REFRESH - 181))
            | (1ULL << (fugue_sqlParser::RENAME - 181))
            | (1ULL << (fugue_sqlParser::REPAIR - 181))
            | (1ULL << (fugue_sqlParser::REPLACE - 181))
            | (1ULL << (fugue_sqlParser::RESET - 181))
            | (1ULL << (fugue_sqlParser::RESTRICT - 181))
            | (1ULL << (fugue_sqlParser::REVOKE - 181))
            | (1ULL << (fugue_sqlParser::RIGHT - 181))
            | (1ULL << (fugue_sqlParser::RLIKE - 181))
            | (1ULL << (fugue_sqlParser::ROLE - 181))
            | (1ULL << (fugue_sqlParser::ROLES - 181))
            | (1ULL << (fugue_sqlParser::ROLLBACK - 181))
            | (1ULL << (fugue_sqlParser::ROLLUP - 181))
            | (1ULL << (fugue_sqlParser::ROW - 181))
            | (1ULL << (fugue_sqlParser::ROWS - 181)))) != 0) || ((((_la - 245) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 245)) & ((1ULL << (fugue_sqlParser::SCHEMA - 245))
            | (1ULL << (fugue_sqlParser::SECOND - 245))
            | (1ULL << (fugue_sqlParser::SELECT - 245))
            | (1ULL << (fugue_sqlParser::SEMI - 245))
            | (1ULL << (fugue_sqlParser::SEPARATED - 245))
            | (1ULL << (fugue_sqlParser::SERDE - 245))
            | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 245))
            | (1ULL << (fugue_sqlParser::SESSION_USER - 245))
            | (1ULL << (fugue_sqlParser::SET - 245))
            | (1ULL << (fugue_sqlParser::SETMINUS - 245))
            | (1ULL << (fugue_sqlParser::SETS - 245))
            | (1ULL << (fugue_sqlParser::SHOW - 245))
            | (1ULL << (fugue_sqlParser::SKEWED - 245))
            | (1ULL << (fugue_sqlParser::SOME - 245))
            | (1ULL << (fugue_sqlParser::SORT - 245))
            | (1ULL << (fugue_sqlParser::SORTED - 245))
            | (1ULL << (fugue_sqlParser::START - 245))
            | (1ULL << (fugue_sqlParser::STATISTICS - 245))
            | (1ULL << (fugue_sqlParser::STORED - 245))
            | (1ULL << (fugue_sqlParser::STRATIFY - 245))
            | (1ULL << (fugue_sqlParser::STRUCT - 245))
            | (1ULL << (fugue_sqlParser::SUBSTR - 245))
            | (1ULL << (fugue_sqlParser::SUBSTRING - 245))
            | (1ULL << (fugue_sqlParser::TABLE - 245))
            | (1ULL << (fugue_sqlParser::TABLES - 245))
            | (1ULL << (fugue_sqlParser::TABLESAMPLE - 245))
            | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 245))
            | (1ULL << (fugue_sqlParser::TEMPORARY - 245))
            | (1ULL << (fugue_sqlParser::TERMINATED - 245))
            | (1ULL << (fugue_sqlParser::THEN - 245))
            | (1ULL << (fugue_sqlParser::TO - 245))
            | (1ULL << (fugue_sqlParser::TOUCH - 245))
            | (1ULL << (fugue_sqlParser::TRAILING - 245))
            | (1ULL << (fugue_sqlParser::TRANSACTION - 245))
            | (1ULL << (fugue_sqlParser::TRANSACTIONS - 245))
            | (1ULL << (fugue_sqlParser::TRANSFORM - 245))
            | (1ULL << (fugue_sqlParser::TRIM - 245))
            | (1ULL << (fugue_sqlParser::TRUE - 245))
            | (1ULL << (fugue_sqlParser::TRUNCATE - 245))
            | (1ULL << (fugue_sqlParser::TYPE - 245))
            | (1ULL << (fugue_sqlParser::UNARCHIVE - 245))
            | (1ULL << (fugue_sqlParser::UNBOUNDED - 245))
            | (1ULL << (fugue_sqlParser::UNCACHE - 245))
            | (1ULL << (fugue_sqlParser::UNION - 245))
            | (1ULL << (fugue_sqlParser::UNIQUE - 245))
            | (1ULL << (fugue_sqlParser::UNKNOWN - 245))
            | (1ULL << (fugue_sqlParser::UNLOCK - 245))
            | (1ULL << (fugue_sqlParser::UNSET - 245))
            | (1ULL << (fugue_sqlParser::UPDATE - 245))
            | (1ULL << (fugue_sqlParser::USE - 245))
            | (1ULL << (fugue_sqlParser::USER - 245))
            | (1ULL << (fugue_sqlParser::USING - 245))
            | (1ULL << (fugue_sqlParser::VALUES - 245))
            | (1ULL << (fugue_sqlParser::VIEW - 245))
            | (1ULL << (fugue_sqlParser::VIEWS - 245))
            | (1ULL << (fugue_sqlParser::WHEN - 245))
            | (1ULL << (fugue_sqlParser::WHERE - 245))
            | (1ULL << (fugue_sqlParser::WINDOW - 245))
            | (1ULL << (fugue_sqlParser::WITH - 245))
            | (1ULL << (fugue_sqlParser::YEAR - 245)))) != 0) || ((((_la - 319) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 319)) & ((1ULL << (fugue_sqlParser::DIV - 319))
            | (1ULL << (fugue_sqlParser::IDENTIFIER - 319))
            | (1ULL << (fugue_sqlParser::BACKQUOTED_IDENTIFIER - 319)))) != 0)) {
            setState(3569);
            complexColTypeList();
          }
          setState(3572);
          match(fugue_sqlParser::GT);
          break;
        }

        case fugue_sqlParser::NEQ: {
          setState(3573);
          match(fugue_sqlParser::NEQ);
          break;
        }

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

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::PrimitiveDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(3576);
      identifier();
      setState(3587);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 478, _ctx)) {
      case 1: {
        setState(3577);
        match(fugue_sqlParser::T__2);
        setState(3578);
        match(fugue_sqlParser::INTEGER_VALUE);
        setState(3583);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__0) {
          setState(3579);
          match(fugue_sqlParser::T__0);
          setState(3580);
          match(fugue_sqlParser::INTEGER_VALUE);
          setState(3585);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(3586);
        match(fugue_sqlParser::T__3);
        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;
}

//----------------- QualifiedColTypeWithPositionListContext ------------------------------------------------------------------

fugue_sqlParser::QualifiedColTypeWithPositionListContext::QualifiedColTypeWithPositionListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::QualifiedColTypeWithPositionContext *> fugue_sqlParser::QualifiedColTypeWithPositionListContext::qualifiedColTypeWithPosition() {
  return getRuleContexts<fugue_sqlParser::QualifiedColTypeWithPositionContext>();
}

fugue_sqlParser::QualifiedColTypeWithPositionContext* fugue_sqlParser::QualifiedColTypeWithPositionListContext::qualifiedColTypeWithPosition(size_t i) {
  return getRuleContext<fugue_sqlParser::QualifiedColTypeWithPositionContext>(i);
}


size_t fugue_sqlParser::QualifiedColTypeWithPositionListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQualifiedColTypeWithPositionList;
}


std::any fugue_sqlParser::QualifiedColTypeWithPositionListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQualifiedColTypeWithPositionList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QualifiedColTypeWithPositionListContext* fugue_sqlParser::qualifiedColTypeWithPositionList() {
  QualifiedColTypeWithPositionListContext *_localctx = _tracker.createInstance<QualifiedColTypeWithPositionListContext>(_ctx, getState());
  enterRule(_localctx, 378, fugue_sqlParser::RuleQualifiedColTypeWithPositionList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3591);
    qualifiedColTypeWithPosition();
    setState(3596);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(3592);
      match(fugue_sqlParser::T__0);
      setState(3593);
      qualifiedColTypeWithPosition();
      setState(3598);
      _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;
}

//----------------- QualifiedColTypeWithPositionContext ------------------------------------------------------------------

fugue_sqlParser::QualifiedColTypeWithPositionContext::QualifiedColTypeWithPositionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::QualifiedColTypeWithPositionContext::dataType() {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(0);
}

fugue_sqlParser::MultipartIdentifierContext* fugue_sqlParser::QualifiedColTypeWithPositionContext::multipartIdentifier() {
  return getRuleContext<fugue_sqlParser::MultipartIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::QualifiedColTypeWithPositionContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::QualifiedColTypeWithPositionContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::QualifiedColTypeWithPositionContext::commentSpec() {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(0);
}

fugue_sqlParser::ColPositionContext* fugue_sqlParser::QualifiedColTypeWithPositionContext::colPosition() {
  return getRuleContext<fugue_sqlParser::ColPositionContext>(0);
}


size_t fugue_sqlParser::QualifiedColTypeWithPositionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQualifiedColTypeWithPosition;
}


std::any fugue_sqlParser::QualifiedColTypeWithPositionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQualifiedColTypeWithPosition(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QualifiedColTypeWithPositionContext* fugue_sqlParser::qualifiedColTypeWithPosition() {
  QualifiedColTypeWithPositionContext *_localctx = _tracker.createInstance<QualifiedColTypeWithPositionContext>(_ctx, getState());
  enterRule(_localctx, 380, fugue_sqlParser::RuleQualifiedColTypeWithPosition);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3599);
    antlrcpp::downCast<QualifiedColTypeWithPositionContext *>(_localctx)->name = multipartIdentifier();
    setState(3600);
    dataType();
    setState(3603);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::NOT) {
      setState(3601);
      match(fugue_sqlParser::NOT);
      setState(3602);
      match(fugue_sqlParser::THENULL);
    }
    setState(3606);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::COMMENT) {
      setState(3605);
      commentSpec();
    }
    setState(3609);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AFTER || _la == fugue_sqlParser::FIRST) {
      setState(3608);
      colPosition();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColTypeListContext ------------------------------------------------------------------

fugue_sqlParser::ColTypeListContext::ColTypeListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ColTypeContext *> fugue_sqlParser::ColTypeListContext::colType() {
  return getRuleContexts<fugue_sqlParser::ColTypeContext>();
}

fugue_sqlParser::ColTypeContext* fugue_sqlParser::ColTypeListContext::colType(size_t i) {
  return getRuleContext<fugue_sqlParser::ColTypeContext>(i);
}


size_t fugue_sqlParser::ColTypeListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleColTypeList;
}


std::any fugue_sqlParser::ColTypeListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitColTypeList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ColTypeListContext* fugue_sqlParser::colTypeList() {
  ColTypeListContext *_localctx = _tracker.createInstance<ColTypeListContext>(_ctx, getState());
  enterRule(_localctx, 382, fugue_sqlParser::RuleColTypeList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3611);
    colType();
    setState(3616);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 484, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3612);
        match(fugue_sqlParser::T__0);
        setState(3613);
        colType(); 
      }
      setState(3618);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 484, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ColTypeContext ------------------------------------------------------------------

fugue_sqlParser::ColTypeContext::ColTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::ColTypeContext::dataType() {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(0);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::ColTypeContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ColTypeContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::ColTypeContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::ColTypeContext::commentSpec() {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(0);
}


size_t fugue_sqlParser::ColTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleColType;
}


std::any fugue_sqlParser::ColTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitColType(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ColTypeContext* fugue_sqlParser::colType() {
  ColTypeContext *_localctx = _tracker.createInstance<ColTypeContext>(_ctx, getState());
  enterRule(_localctx, 384, fugue_sqlParser::RuleColType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3619);
    antlrcpp::downCast<ColTypeContext *>(_localctx)->colName = errorCapturingIdentifier();
    setState(3620);
    dataType();
    setState(3623);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 485, _ctx)) {
    case 1: {
      setState(3621);
      match(fugue_sqlParser::NOT);
      setState(3622);
      match(fugue_sqlParser::THENULL);
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 486, _ctx)) {
    case 1: {
      setState(3625);
      commentSpec();
      break;
    }

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

  return _localctx;
}

//----------------- ComplexColTypeListContext ------------------------------------------------------------------

fugue_sqlParser::ComplexColTypeListContext::ComplexColTypeListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::ComplexColTypeContext *> fugue_sqlParser::ComplexColTypeListContext::complexColType() {
  return getRuleContexts<fugue_sqlParser::ComplexColTypeContext>();
}

fugue_sqlParser::ComplexColTypeContext* fugue_sqlParser::ComplexColTypeListContext::complexColType(size_t i) {
  return getRuleContext<fugue_sqlParser::ComplexColTypeContext>(i);
}


size_t fugue_sqlParser::ComplexColTypeListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleComplexColTypeList;
}


std::any fugue_sqlParser::ComplexColTypeListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitComplexColTypeList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ComplexColTypeListContext* fugue_sqlParser::complexColTypeList() {
  ComplexColTypeListContext *_localctx = _tracker.createInstance<ComplexColTypeListContext>(_ctx, getState());
  enterRule(_localctx, 386, fugue_sqlParser::RuleComplexColTypeList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3628);
    complexColType();
    setState(3633);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(3629);
      match(fugue_sqlParser::T__0);
      setState(3630);
      complexColType();
      setState(3635);
      _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;
}

//----------------- ComplexColTypeContext ------------------------------------------------------------------

fugue_sqlParser::ComplexColTypeContext::ComplexColTypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ComplexColTypeContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::ComplexColTypeContext::dataType() {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(0);
}

tree::TerminalNode* fugue_sqlParser::ComplexColTypeContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::ComplexColTypeContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::ComplexColTypeContext::commentSpec() {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(0);
}


size_t fugue_sqlParser::ComplexColTypeContext::getRuleIndex() const {
  return fugue_sqlParser::RuleComplexColType;
}


std::any fugue_sqlParser::ComplexColTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitComplexColType(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ComplexColTypeContext* fugue_sqlParser::complexColType() {
  ComplexColTypeContext *_localctx = _tracker.createInstance<ComplexColTypeContext>(_ctx, getState());
  enterRule(_localctx, 388, fugue_sqlParser::RuleComplexColType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3636);
    identifier();
    setState(3637);
    match(fugue_sqlParser::T__1);
    setState(3638);
    dataType();
    setState(3641);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::NOT) {
      setState(3639);
      match(fugue_sqlParser::NOT);
      setState(3640);
      match(fugue_sqlParser::THENULL);
    }
    setState(3644);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::COMMENT) {
      setState(3643);
      commentSpec();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WhenClauseContext ------------------------------------------------------------------

fugue_sqlParser::WhenClauseContext::WhenClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::WhenClauseContext::WHEN() {
  return getToken(fugue_sqlParser::WHEN, 0);
}

tree::TerminalNode* fugue_sqlParser::WhenClauseContext::THEN() {
  return getToken(fugue_sqlParser::THEN, 0);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::WhenClauseContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::WhenClauseContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}


size_t fugue_sqlParser::WhenClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleWhenClause;
}


std::any fugue_sqlParser::WhenClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitWhenClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::WhenClauseContext* fugue_sqlParser::whenClause() {
  WhenClauseContext *_localctx = _tracker.createInstance<WhenClauseContext>(_ctx, getState());
  enterRule(_localctx, 390, fugue_sqlParser::RuleWhenClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3646);
    match(fugue_sqlParser::WHEN);
    setState(3647);
    antlrcpp::downCast<WhenClauseContext *>(_localctx)->condition = expression();
    setState(3648);
    match(fugue_sqlParser::THEN);
    setState(3649);
    antlrcpp::downCast<WhenClauseContext *>(_localctx)->result = expression();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowClauseContext ------------------------------------------------------------------

fugue_sqlParser::WindowClauseContext::WindowClauseContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::WindowClauseContext::WINDOW() {
  return getToken(fugue_sqlParser::WINDOW, 0);
}

std::vector<fugue_sqlParser::NamedWindowContext *> fugue_sqlParser::WindowClauseContext::namedWindow() {
  return getRuleContexts<fugue_sqlParser::NamedWindowContext>();
}

fugue_sqlParser::NamedWindowContext* fugue_sqlParser::WindowClauseContext::namedWindow(size_t i) {
  return getRuleContext<fugue_sqlParser::NamedWindowContext>(i);
}


size_t fugue_sqlParser::WindowClauseContext::getRuleIndex() const {
  return fugue_sqlParser::RuleWindowClause;
}


std::any fugue_sqlParser::WindowClauseContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitWindowClause(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::WindowClauseContext* fugue_sqlParser::windowClause() {
  WindowClauseContext *_localctx = _tracker.createInstance<WindowClauseContext>(_ctx, getState());
  enterRule(_localctx, 392, fugue_sqlParser::RuleWindowClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3651);
    match(fugue_sqlParser::WINDOW);
    setState(3652);
    namedWindow();
    setState(3657);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 490, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3653);
        match(fugue_sqlParser::T__0);
        setState(3654);
        namedWindow(); 
      }
      setState(3659);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 490, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- NamedWindowContext ------------------------------------------------------------------

fugue_sqlParser::NamedWindowContext::NamedWindowContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::NamedWindowContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

fugue_sqlParser::WindowSpecContext* fugue_sqlParser::NamedWindowContext::windowSpec() {
  return getRuleContext<fugue_sqlParser::WindowSpecContext>(0);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::NamedWindowContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}


size_t fugue_sqlParser::NamedWindowContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNamedWindow;
}


std::any fugue_sqlParser::NamedWindowContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNamedWindow(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NamedWindowContext* fugue_sqlParser::namedWindow() {
  NamedWindowContext *_localctx = _tracker.createInstance<NamedWindowContext>(_ctx, getState());
  enterRule(_localctx, 394, fugue_sqlParser::RuleNamedWindow);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3660);
    antlrcpp::downCast<NamedWindowContext *>(_localctx)->name = errorCapturingIdentifier();
    setState(3661);
    match(fugue_sqlParser::AS);
    setState(3662);
    windowSpec();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- WindowSpecContext ------------------------------------------------------------------

fugue_sqlParser::WindowSpecContext::WindowSpecContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::WindowSpecContext::getRuleIndex() const {
  return fugue_sqlParser::RuleWindowSpec;
}

void fugue_sqlParser::WindowSpecContext::copyFrom(WindowSpecContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- WindowRefContext ------------------------------------------------------------------

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::WindowRefContext::errorCapturingIdentifier() {
  return getRuleContext<fugue_sqlParser::ErrorCapturingIdentifierContext>(0);
}

fugue_sqlParser::WindowRefContext::WindowRefContext(WindowSpecContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::WindowRefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitWindowRef(this);
  else
    return visitor->visitChildren(this);
}
//----------------- WindowDefContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::WindowDefContext::CLUSTER() {
  return getToken(fugue_sqlParser::CLUSTER, 0);
}

std::vector<tree::TerminalNode *> fugue_sqlParser::WindowDefContext::BY() {
  return getTokens(fugue_sqlParser::BY);
}

tree::TerminalNode* fugue_sqlParser::WindowDefContext::BY(size_t i) {
  return getToken(fugue_sqlParser::BY, i);
}

std::vector<fugue_sqlParser::ExpressionContext *> fugue_sqlParser::WindowDefContext::expression() {
  return getRuleContexts<fugue_sqlParser::ExpressionContext>();
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::WindowDefContext::expression(size_t i) {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(i);
}

fugue_sqlParser::WindowFrameContext* fugue_sqlParser::WindowDefContext::windowFrame() {
  return getRuleContext<fugue_sqlParser::WindowFrameContext>(0);
}

std::vector<fugue_sqlParser::SortItemContext *> fugue_sqlParser::WindowDefContext::sortItem() {
  return getRuleContexts<fugue_sqlParser::SortItemContext>();
}

fugue_sqlParser::SortItemContext* fugue_sqlParser::WindowDefContext::sortItem(size_t i) {
  return getRuleContext<fugue_sqlParser::SortItemContext>(i);
}

tree::TerminalNode* fugue_sqlParser::WindowDefContext::PARTITION() {
  return getToken(fugue_sqlParser::PARTITION, 0);
}

tree::TerminalNode* fugue_sqlParser::WindowDefContext::DISTRIBUTE() {
  return getToken(fugue_sqlParser::DISTRIBUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::WindowDefContext::ORDER() {
  return getToken(fugue_sqlParser::ORDER, 0);
}

tree::TerminalNode* fugue_sqlParser::WindowDefContext::SORT() {
  return getToken(fugue_sqlParser::SORT, 0);
}

fugue_sqlParser::WindowDefContext::WindowDefContext(WindowSpecContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::WindowDefContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitWindowDef(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::WindowSpecContext* fugue_sqlParser::windowSpec() {
  WindowSpecContext *_localctx = _tracker.createInstance<WindowSpecContext>(_ctx, getState());
  enterRule(_localctx, 396, fugue_sqlParser::RuleWindowSpec);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3710);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 498, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::WindowRefContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3664);
      antlrcpp::downCast<WindowRefContext *>(_localctx)->name = errorCapturingIdentifier();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::WindowRefContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3665);
      match(fugue_sqlParser::T__2);
      setState(3666);
      antlrcpp::downCast<WindowRefContext *>(_localctx)->name = errorCapturingIdentifier();
      setState(3667);
      match(fugue_sqlParser::T__3);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::WindowDefContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3669);
      match(fugue_sqlParser::T__2);
      setState(3704);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::CLUSTER: {
          setState(3670);
          match(fugue_sqlParser::CLUSTER);
          setState(3671);
          match(fugue_sqlParser::BY);
          setState(3672);
          antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
          setState(3677);
          _errHandler->sync(this);
          _la = _input->LA(1);
          while (_la == fugue_sqlParser::T__0) {
            setState(3673);
            match(fugue_sqlParser::T__0);
            setState(3674);
            antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
            antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
            setState(3679);
            _errHandler->sync(this);
            _la = _input->LA(1);
          }
          break;
        }

        case fugue_sqlParser::T__3:
        case fugue_sqlParser::DISTRIBUTE:
        case fugue_sqlParser::ORDER:
        case fugue_sqlParser::PARTITION:
        case fugue_sqlParser::RANGE:
        case fugue_sqlParser::ROWS:
        case fugue_sqlParser::SORT: {
          setState(3690);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::DISTRIBUTE || _la == fugue_sqlParser::PARTITION) {
            setState(3680);
            _la = _input->LA(1);
            if (!(_la == fugue_sqlParser::DISTRIBUTE || _la == fugue_sqlParser::PARTITION)) {
            _errHandler->recoverInline(this);
            }
            else {
              _errHandler->reportMatch(this);
              consume();
            }
            setState(3681);
            match(fugue_sqlParser::BY);
            setState(3682);
            antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
            antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
            setState(3687);
            _errHandler->sync(this);
            _la = _input->LA(1);
            while (_la == fugue_sqlParser::T__0) {
              setState(3683);
              match(fugue_sqlParser::T__0);
              setState(3684);
              antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
              antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
              setState(3689);
              _errHandler->sync(this);
              _la = _input->LA(1);
            }
          }
          setState(3702);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ORDER

          || _la == fugue_sqlParser::SORT) {
            setState(3692);
            _la = _input->LA(1);
            if (!(_la == fugue_sqlParser::ORDER

            || _la == fugue_sqlParser::SORT)) {
            _errHandler->recoverInline(this);
            }
            else {
              _errHandler->reportMatch(this);
              consume();
            }
            setState(3693);
            match(fugue_sqlParser::BY);
            setState(3694);
            sortItem();
            setState(3699);
            _errHandler->sync(this);
            _la = _input->LA(1);
            while (_la == fugue_sqlParser::T__0) {
              setState(3695);
              match(fugue_sqlParser::T__0);
              setState(3696);
              sortItem();
              setState(3701);
              _errHandler->sync(this);
              _la = _input->LA(1);
            }
          }
          break;
        }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::RANGE

      || _la == fugue_sqlParser::ROWS) {
        setState(3706);
        windowFrame();
      }
      setState(3709);
      match(fugue_sqlParser::T__3);
      break;
    }

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

  return _localctx;
}

//----------------- WindowFrameContext ------------------------------------------------------------------

fugue_sqlParser::WindowFrameContext::WindowFrameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::WindowFrameContext::RANGE() {
  return getToken(fugue_sqlParser::RANGE, 0);
}

std::vector<fugue_sqlParser::FrameBoundContext *> fugue_sqlParser::WindowFrameContext::frameBound() {
  return getRuleContexts<fugue_sqlParser::FrameBoundContext>();
}

fugue_sqlParser::FrameBoundContext* fugue_sqlParser::WindowFrameContext::frameBound(size_t i) {
  return getRuleContext<fugue_sqlParser::FrameBoundContext>(i);
}

tree::TerminalNode* fugue_sqlParser::WindowFrameContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

tree::TerminalNode* fugue_sqlParser::WindowFrameContext::BETWEEN() {
  return getToken(fugue_sqlParser::BETWEEN, 0);
}

tree::TerminalNode* fugue_sqlParser::WindowFrameContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}


size_t fugue_sqlParser::WindowFrameContext::getRuleIndex() const {
  return fugue_sqlParser::RuleWindowFrame;
}


std::any fugue_sqlParser::WindowFrameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitWindowFrame(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::WindowFrameContext* fugue_sqlParser::windowFrame() {
  WindowFrameContext *_localctx = _tracker.createInstance<WindowFrameContext>(_ctx, getState());
  enterRule(_localctx, 398, fugue_sqlParser::RuleWindowFrame);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3728);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 499, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3712);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::RANGE);
      setState(3713);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3714);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::ROWS);
      setState(3715);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3716);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::RANGE);
      setState(3717);
      match(fugue_sqlParser::BETWEEN);
      setState(3718);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      setState(3719);
      match(fugue_sqlParser::AND);
      setState(3720);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->end = frameBound();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3722);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::ROWS);
      setState(3723);
      match(fugue_sqlParser::BETWEEN);
      setState(3724);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      setState(3725);
      match(fugue_sqlParser::AND);
      setState(3726);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->end = frameBound();
      break;
    }

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

  return _localctx;
}

//----------------- FrameBoundContext ------------------------------------------------------------------

fugue_sqlParser::FrameBoundContext::FrameBoundContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::FrameBoundContext::UNBOUNDED() {
  return getToken(fugue_sqlParser::UNBOUNDED, 0);
}

tree::TerminalNode* fugue_sqlParser::FrameBoundContext::PRECEDING() {
  return getToken(fugue_sqlParser::PRECEDING, 0);
}

tree::TerminalNode* fugue_sqlParser::FrameBoundContext::FOLLOWING() {
  return getToken(fugue_sqlParser::FOLLOWING, 0);
}

tree::TerminalNode* fugue_sqlParser::FrameBoundContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::FrameBoundContext::CURRENT() {
  return getToken(fugue_sqlParser::CURRENT, 0);
}

fugue_sqlParser::ExpressionContext* fugue_sqlParser::FrameBoundContext::expression() {
  return getRuleContext<fugue_sqlParser::ExpressionContext>(0);
}


size_t fugue_sqlParser::FrameBoundContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFrameBound;
}


std::any fugue_sqlParser::FrameBoundContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFrameBound(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FrameBoundContext* fugue_sqlParser::frameBound() {
  FrameBoundContext *_localctx = _tracker.createInstance<FrameBoundContext>(_ctx, getState());
  enterRule(_localctx, 400, fugue_sqlParser::RuleFrameBound);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3737);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 500, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3730);
      match(fugue_sqlParser::UNBOUNDED);
      setState(3731);
      antlrcpp::downCast<FrameBoundContext *>(_localctx)->boundType = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FOLLOWING || _la == fugue_sqlParser::PRECEDING)) {
        antlrcpp::downCast<FrameBoundContext *>(_localctx)->boundType = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3732);
      antlrcpp::downCast<FrameBoundContext *>(_localctx)->boundType = match(fugue_sqlParser::CURRENT);
      setState(3733);
      match(fugue_sqlParser::ROW);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3734);
      expression();
      setState(3735);
      antlrcpp::downCast<FrameBoundContext *>(_localctx)->boundType = _input->LT(1);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FOLLOWING || _la == fugue_sqlParser::PRECEDING)) {
        antlrcpp::downCast<FrameBoundContext *>(_localctx)->boundType = _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;
}

//----------------- QualifiedNameListContext ------------------------------------------------------------------

fugue_sqlParser::QualifiedNameListContext::QualifiedNameListContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::QualifiedNameContext *> fugue_sqlParser::QualifiedNameListContext::qualifiedName() {
  return getRuleContexts<fugue_sqlParser::QualifiedNameContext>();
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::QualifiedNameListContext::qualifiedName(size_t i) {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(i);
}


size_t fugue_sqlParser::QualifiedNameListContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQualifiedNameList;
}


std::any fugue_sqlParser::QualifiedNameListContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQualifiedNameList(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QualifiedNameListContext* fugue_sqlParser::qualifiedNameList() {
  QualifiedNameListContext *_localctx = _tracker.createInstance<QualifiedNameListContext>(_ctx, getState());
  enterRule(_localctx, 402, fugue_sqlParser::RuleQualifiedNameList);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3739);
    qualifiedName();
    setState(3744);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__0) {
      setState(3740);
      match(fugue_sqlParser::T__0);
      setState(3741);
      qualifiedName();
      setState(3746);
      _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;
}

//----------------- FunctionNameContext ------------------------------------------------------------------

fugue_sqlParser::FunctionNameContext::FunctionNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::FunctionNameContext::qualifiedName() {
  return getRuleContext<fugue_sqlParser::QualifiedNameContext>(0);
}

tree::TerminalNode* fugue_sqlParser::FunctionNameContext::FILTER() {
  return getToken(fugue_sqlParser::FILTER, 0);
}

tree::TerminalNode* fugue_sqlParser::FunctionNameContext::LEFT() {
  return getToken(fugue_sqlParser::LEFT, 0);
}

tree::TerminalNode* fugue_sqlParser::FunctionNameContext::RIGHT() {
  return getToken(fugue_sqlParser::RIGHT, 0);
}


size_t fugue_sqlParser::FunctionNameContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFunctionName;
}


std::any fugue_sqlParser::FunctionNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFunctionName(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::FunctionNameContext* fugue_sqlParser::functionName() {
  FunctionNameContext *_localctx = _tracker.createInstance<FunctionNameContext>(_ctx, getState());
  enterRule(_localctx, 404, fugue_sqlParser::RuleFunctionName);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3748);
      match(fugue_sqlParser::FILTER);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3749);
      match(fugue_sqlParser::LEFT);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3750);
      match(fugue_sqlParser::RIGHT);
      break;
    }

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

  return _localctx;
}

//----------------- QualifiedNameContext ------------------------------------------------------------------

fugue_sqlParser::QualifiedNameContext::QualifiedNameContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::QualifiedNameContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::QualifiedNameContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}


size_t fugue_sqlParser::QualifiedNameContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQualifiedName;
}


std::any fugue_sqlParser::QualifiedNameContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQualifiedName(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QualifiedNameContext* fugue_sqlParser::qualifiedName() {
  QualifiedNameContext *_localctx = _tracker.createInstance<QualifiedNameContext>(_ctx, getState());
  enterRule(_localctx, 406, fugue_sqlParser::RuleQualifiedName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3753);
    identifier();
    setState(3758);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 503, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3754);
        match(fugue_sqlParser::T__6);
        setState(3755);
        identifier(); 
      }
      setState(3760);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 503, _ctx);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ErrorCapturingIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::ErrorCapturingIdentifierContext::ErrorCapturingIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ErrorCapturingIdentifierContext::identifier() {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(0);
}


size_t fugue_sqlParser::ErrorCapturingIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleErrorCapturingIdentifier;
}


std::any fugue_sqlParser::ErrorCapturingIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitErrorCapturingIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::ErrorCapturingIdentifierContext* fugue_sqlParser::errorCapturingIdentifier() {
  ErrorCapturingIdentifierContext *_localctx = _tracker.createInstance<ErrorCapturingIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 408, fugue_sqlParser::RuleErrorCapturingIdentifier);

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

  return _localctx;
}

//----------------- ErrorCapturingIdentifierExtraContext ------------------------------------------------------------------

fugue_sqlParser::ErrorCapturingIdentifierExtraContext::ErrorCapturingIdentifierExtraContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::ErrorCapturingIdentifierExtraContext::getRuleIndex() const {
  return fugue_sqlParser::RuleErrorCapturingIdentifierExtra;
}

void fugue_sqlParser::ErrorCapturingIdentifierExtraContext::copyFrom(ErrorCapturingIdentifierExtraContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- ErrorIdentContext ------------------------------------------------------------------

std::vector<tree::TerminalNode *> fugue_sqlParser::ErrorIdentContext::MINUS() {
  return getTokens(fugue_sqlParser::MINUS);
}

tree::TerminalNode* fugue_sqlParser::ErrorIdentContext::MINUS(size_t i) {
  return getToken(fugue_sqlParser::MINUS, i);
}

std::vector<fugue_sqlParser::IdentifierContext *> fugue_sqlParser::ErrorIdentContext::identifier() {
  return getRuleContexts<fugue_sqlParser::IdentifierContext>();
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::ErrorIdentContext::identifier(size_t i) {
  return getRuleContext<fugue_sqlParser::IdentifierContext>(i);
}

fugue_sqlParser::ErrorIdentContext::ErrorIdentContext(ErrorCapturingIdentifierExtraContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ErrorIdentContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitErrorIdent(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::ErrorCapturingIdentifierExtraContext* fugue_sqlParser::errorCapturingIdentifierExtra() {
  ErrorCapturingIdentifierExtraContext *_localctx = _tracker.createInstance<ErrorCapturingIdentifierExtraContext>(_ctx, getState());
  enterRule(_localctx, 410, fugue_sqlParser::RuleErrorCapturingIdentifierExtra);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    _localctx = _tracker.createInstance<fugue_sqlParser::ErrorIdentContext>(_localctx);
    enterOuterAlt(_localctx, 1);
    setState(3765); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(3763);
      match(fugue_sqlParser::MINUS);
      setState(3764);
      identifier();
      setState(3767); 
      _errHandler->sync(this);
      _la = _input->LA(1);
    } while (_la == fugue_sqlParser::MINUS);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IdentifierContext ------------------------------------------------------------------

fugue_sqlParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

fugue_sqlParser::StrictIdentifierContext* fugue_sqlParser::IdentifierContext::strictIdentifier() {
  return getRuleContext<fugue_sqlParser::StrictIdentifierContext>(0);
}

fugue_sqlParser::StrictNonReservedContext* fugue_sqlParser::IdentifierContext::strictNonReserved() {
  return getRuleContext<fugue_sqlParser::StrictNonReservedContext>(0);
}


size_t fugue_sqlParser::IdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleIdentifier;
}


std::any fugue_sqlParser::IdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::IdentifierContext* fugue_sqlParser::identifier() {
  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());
  enterRule(_localctx, 412, fugue_sqlParser::RuleIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3771);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV:
      case fugue_sqlParser::IDENTIFIER:
      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        enterOuterAlt(_localctx, 1);
        setState(3769);
        strictIdentifier();
        break;
      }

      case fugue_sqlParser::ANTI:
      case fugue_sqlParser::CROSS:
      case fugue_sqlParser::EXCEPT:
      case fugue_sqlParser::FULL:
      case fugue_sqlParser::INNER:
      case fugue_sqlParser::INTERSECT:
      case fugue_sqlParser::JOIN:
      case fugue_sqlParser::LEFT:
      case fugue_sqlParser::NATURAL:
      case fugue_sqlParser::ON:
      case fugue_sqlParser::RIGHT:
      case fugue_sqlParser::SEMI:
      case fugue_sqlParser::SETMINUS:
      case fugue_sqlParser::UNION:
      case fugue_sqlParser::USING: {
        enterOuterAlt(_localctx, 2);
        setState(3770);
        strictNonReserved();
        break;
      }

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

  return _localctx;
}

//----------------- StrictIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::StrictIdentifierContext::StrictIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::StrictIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleStrictIdentifier;
}

void fugue_sqlParser::StrictIdentifierContext::copyFrom(StrictIdentifierContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- QuotedIdentifierAlternativeContext ------------------------------------------------------------------

fugue_sqlParser::QuotedIdentifierContext* fugue_sqlParser::QuotedIdentifierAlternativeContext::quotedIdentifier() {
  return getRuleContext<fugue_sqlParser::QuotedIdentifierContext>(0);
}

fugue_sqlParser::QuotedIdentifierAlternativeContext::QuotedIdentifierAlternativeContext(StrictIdentifierContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::QuotedIdentifierAlternativeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQuotedIdentifierAlternative(this);
  else
    return visitor->visitChildren(this);
}
//----------------- UnquotedIdentifierContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::UnquotedIdentifierContext::IDENTIFIER() {
  return getToken(fugue_sqlParser::IDENTIFIER, 0);
}

fugue_sqlParser::NonReservedContext* fugue_sqlParser::UnquotedIdentifierContext::nonReserved() {
  return getRuleContext<fugue_sqlParser::NonReservedContext>(0);
}

fugue_sqlParser::UnquotedIdentifierContext::UnquotedIdentifierContext(StrictIdentifierContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::UnquotedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitUnquotedIdentifier(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::StrictIdentifierContext* fugue_sqlParser::strictIdentifier() {
  StrictIdentifierContext *_localctx = _tracker.createInstance<StrictIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 414, fugue_sqlParser::RuleStrictIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3776);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::IDENTIFIER: {
        _localctx = _tracker.createInstance<fugue_sqlParser::UnquotedIdentifierContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(3773);
        match(fugue_sqlParser::IDENTIFIER);
        break;
      }

      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        _localctx = _tracker.createInstance<fugue_sqlParser::QuotedIdentifierAlternativeContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(3774);
        quotedIdentifier();
        break;
      }

      case fugue_sqlParser::ADD:
      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::ALL:
      case fugue_sqlParser::ALTER:
      case fugue_sqlParser::ANALYZE:
      case fugue_sqlParser::AND:
      case fugue_sqlParser::ANY:
      case fugue_sqlParser::ARCHIVE:
      case fugue_sqlParser::ARRAY:
      case fugue_sqlParser::AS:
      case fugue_sqlParser::ASC:
      case fugue_sqlParser::AT:
      case fugue_sqlParser::AUTHORIZATION:
      case fugue_sqlParser::BETWEEN:
      case fugue_sqlParser::BOTH:
      case fugue_sqlParser::BUCKET:
      case fugue_sqlParser::BUCKETS:
      case fugue_sqlParser::BY:
      case fugue_sqlParser::CACHE:
      case fugue_sqlParser::CASCADE:
      case fugue_sqlParser::CASE:
      case fugue_sqlParser::CAST:
      case fugue_sqlParser::CHANGE:
      case fugue_sqlParser::CHECK:
      case fugue_sqlParser::CLEAR:
      case fugue_sqlParser::CLUSTER:
      case fugue_sqlParser::CLUSTERED:
      case fugue_sqlParser::CODEGEN:
      case fugue_sqlParser::COLLATE:
      case fugue_sqlParser::COLLECTION:
      case fugue_sqlParser::COLUMN:
      case fugue_sqlParser::COLUMNS:
      case fugue_sqlParser::COMMENT:
      case fugue_sqlParser::COMMIT:
      case fugue_sqlParser::COMPACT:
      case fugue_sqlParser::COMPACTIONS:
      case fugue_sqlParser::COMPUTE:
      case fugue_sqlParser::CONCATENATE:
      case fugue_sqlParser::CONSTRAINT:
      case fugue_sqlParser::COST:
      case fugue_sqlParser::CREATE:
      case fugue_sqlParser::CUBE:
      case fugue_sqlParser::CURRENT:
      case fugue_sqlParser::CURRENT_DATE:
      case fugue_sqlParser::CURRENT_TIME:
      case fugue_sqlParser::CURRENT_TIMESTAMP:
      case fugue_sqlParser::CURRENT_USER:
      case fugue_sqlParser::DATA:
      case fugue_sqlParser::DATABASE:
      case fugue_sqlParser::DATABASES:
      case fugue_sqlParser::DAY:
      case fugue_sqlParser::DBPROPERTIES:
      case fugue_sqlParser::DEFINED:
      case fugue_sqlParser::DELETE:
      case fugue_sqlParser::DELIMITED:
      case fugue_sqlParser::DESC:
      case fugue_sqlParser::DESCRIBE:
      case fugue_sqlParser::DFS:
      case fugue_sqlParser::DIRECTORIES:
      case fugue_sqlParser::DIRECTORY:
      case fugue_sqlParser::DISTINCT:
      case fugue_sqlParser::DISTRIBUTE:
      case fugue_sqlParser::DROP:
      case fugue_sqlParser::ELSE:
      case fugue_sqlParser::END:
      case fugue_sqlParser::ESCAPE:
      case fugue_sqlParser::ESCAPED:
      case fugue_sqlParser::EXCHANGE:
      case fugue_sqlParser::EXISTS:
      case fugue_sqlParser::EXPLAIN:
      case fugue_sqlParser::EXPORT:
      case fugue_sqlParser::EXTENDED:
      case fugue_sqlParser::EXTERNAL:
      case fugue_sqlParser::EXTRACT:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::FETCH:
      case fugue_sqlParser::FIELDS:
      case fugue_sqlParser::FILTER:
      case fugue_sqlParser::FILEFORMAT:
      case fugue_sqlParser::FIRST:
      case fugue_sqlParser::FOLLOWING:
      case fugue_sqlParser::FOR:
      case fugue_sqlParser::FOREIGN:
      case fugue_sqlParser::FORMAT:
      case fugue_sqlParser::FORMATTED:
      case fugue_sqlParser::FROM:
      case fugue_sqlParser::FUNCTION:
      case fugue_sqlParser::FUNCTIONS:
      case fugue_sqlParser::GLOBAL:
      case fugue_sqlParser::GRANT:
      case fugue_sqlParser::GROUP:
      case fugue_sqlParser::GROUPING:
      case fugue_sqlParser::HAVING:
      case fugue_sqlParser::HOUR:
      case fugue_sqlParser::IF:
      case fugue_sqlParser::IGNORE:
      case fugue_sqlParser::IMPORT:
      case fugue_sqlParser::IN:
      case fugue_sqlParser::INDEX:
      case fugue_sqlParser::INDEXES:
      case fugue_sqlParser::INPATH:
      case fugue_sqlParser::INPUTFORMAT:
      case fugue_sqlParser::INSERT:
      case fugue_sqlParser::INTERVAL:
      case fugue_sqlParser::INTO:
      case fugue_sqlParser::IS:
      case fugue_sqlParser::ITEMS:
      case fugue_sqlParser::KEYS:
      case fugue_sqlParser::LAST:
      case fugue_sqlParser::LATERAL:
      case fugue_sqlParser::LAZY:
      case fugue_sqlParser::LEADING:
      case fugue_sqlParser::LIKE:
      case fugue_sqlParser::LIMIT:
      case fugue_sqlParser::LINES:
      case fugue_sqlParser::LIST:
      case fugue_sqlParser::LOAD:
      case fugue_sqlParser::LOCAL:
      case fugue_sqlParser::LOCATION:
      case fugue_sqlParser::LOCK:
      case fugue_sqlParser::LOCKS:
      case fugue_sqlParser::LOGICAL:
      case fugue_sqlParser::MACRO:
      case fugue_sqlParser::MAP:
      case fugue_sqlParser::MATCHED:
      case fugue_sqlParser::MERGE:
      case fugue_sqlParser::MINUTE:
      case fugue_sqlParser::MONTH:
      case fugue_sqlParser::MSCK:
      case fugue_sqlParser::NAMESPACE:
      case fugue_sqlParser::NAMESPACES:
      case fugue_sqlParser::NO:
      case fugue_sqlParser::NOT:
      case fugue_sqlParser::THENULL:
      case fugue_sqlParser::THENULLS:
      case fugue_sqlParser::OF:
      case fugue_sqlParser::ONLY:
      case fugue_sqlParser::OPTION:
      case fugue_sqlParser::OPTIONS:
      case fugue_sqlParser::OR:
      case fugue_sqlParser::ORDER:
      case fugue_sqlParser::OUT:
      case fugue_sqlParser::OUTER:
      case fugue_sqlParser::OUTPUTFORMAT:
      case fugue_sqlParser::OVER:
      case fugue_sqlParser::OVERLAPS:
      case fugue_sqlParser::OVERLAY:
      case fugue_sqlParser::OVERWRITE:
      case fugue_sqlParser::PARTITION:
      case fugue_sqlParser::PARTITIONED:
      case fugue_sqlParser::PARTITIONS:
      case fugue_sqlParser::PERCENTLIT:
      case fugue_sqlParser::PIVOT:
      case fugue_sqlParser::PLACING:
      case fugue_sqlParser::POSITION:
      case fugue_sqlParser::PRECEDING:
      case fugue_sqlParser::PRIMARY:
      case fugue_sqlParser::PRINCIPALS:
      case fugue_sqlParser::PROPERTIES:
      case fugue_sqlParser::PURGE:
      case fugue_sqlParser::QUERY:
      case fugue_sqlParser::RANGE:
      case fugue_sqlParser::RECORDREADER:
      case fugue_sqlParser::RECORDWRITER:
      case fugue_sqlParser::RECOVER:
      case fugue_sqlParser::REDUCE:
      case fugue_sqlParser::REFERENCES:
      case fugue_sqlParser::REFRESH:
      case fugue_sqlParser::RENAME:
      case fugue_sqlParser::REPAIR:
      case fugue_sqlParser::REPLACE:
      case fugue_sqlParser::RESET:
      case fugue_sqlParser::RESTRICT:
      case fugue_sqlParser::REVOKE:
      case fugue_sqlParser::RLIKE:
      case fugue_sqlParser::ROLE:
      case fugue_sqlParser::ROLES:
      case fugue_sqlParser::ROLLBACK:
      case fugue_sqlParser::ROLLUP:
      case fugue_sqlParser::ROW:
      case fugue_sqlParser::ROWS:
      case fugue_sqlParser::SCHEMA:
      case fugue_sqlParser::SECOND:
      case fugue_sqlParser::SELECT:
      case fugue_sqlParser::SEPARATED:
      case fugue_sqlParser::SERDE:
      case fugue_sqlParser::SERDEPROPERTIES:
      case fugue_sqlParser::SESSION_USER:
      case fugue_sqlParser::SET:
      case fugue_sqlParser::SETS:
      case fugue_sqlParser::SHOW:
      case fugue_sqlParser::SKEWED:
      case fugue_sqlParser::SOME:
      case fugue_sqlParser::SORT:
      case fugue_sqlParser::SORTED:
      case fugue_sqlParser::START:
      case fugue_sqlParser::STATISTICS:
      case fugue_sqlParser::STORED:
      case fugue_sqlParser::STRATIFY:
      case fugue_sqlParser::STRUCT:
      case fugue_sqlParser::SUBSTR:
      case fugue_sqlParser::SUBSTRING:
      case fugue_sqlParser::TABLE:
      case fugue_sqlParser::TABLES:
      case fugue_sqlParser::TABLESAMPLE:
      case fugue_sqlParser::TBLPROPERTIES:
      case fugue_sqlParser::TEMPORARY:
      case fugue_sqlParser::TERMINATED:
      case fugue_sqlParser::THEN:
      case fugue_sqlParser::TO:
      case fugue_sqlParser::TOUCH:
      case fugue_sqlParser::TRAILING:
      case fugue_sqlParser::TRANSACTION:
      case fugue_sqlParser::TRANSACTIONS:
      case fugue_sqlParser::TRANSFORM:
      case fugue_sqlParser::TRIM:
      case fugue_sqlParser::TRUE:
      case fugue_sqlParser::TRUNCATE:
      case fugue_sqlParser::TYPE:
      case fugue_sqlParser::UNARCHIVE:
      case fugue_sqlParser::UNBOUNDED:
      case fugue_sqlParser::UNCACHE:
      case fugue_sqlParser::UNIQUE:
      case fugue_sqlParser::UNKNOWN:
      case fugue_sqlParser::UNLOCK:
      case fugue_sqlParser::UNSET:
      case fugue_sqlParser::UPDATE:
      case fugue_sqlParser::USE:
      case fugue_sqlParser::USER:
      case fugue_sqlParser::VALUES:
      case fugue_sqlParser::VIEW:
      case fugue_sqlParser::VIEWS:
      case fugue_sqlParser::WHEN:
      case fugue_sqlParser::WHERE:
      case fugue_sqlParser::WINDOW:
      case fugue_sqlParser::WITH:
      case fugue_sqlParser::YEAR:
      case fugue_sqlParser::DIV: {
        _localctx = _tracker.createInstance<fugue_sqlParser::UnquotedIdentifierContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(3775);
        nonReserved();
        break;
      }

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

  return _localctx;
}

//----------------- QuotedIdentifierContext ------------------------------------------------------------------

fugue_sqlParser::QuotedIdentifierContext::QuotedIdentifierContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::QuotedIdentifierContext::BACKQUOTED_IDENTIFIER() {
  return getToken(fugue_sqlParser::BACKQUOTED_IDENTIFIER, 0);
}


size_t fugue_sqlParser::QuotedIdentifierContext::getRuleIndex() const {
  return fugue_sqlParser::RuleQuotedIdentifier;
}


std::any fugue_sqlParser::QuotedIdentifierContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitQuotedIdentifier(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::QuotedIdentifierContext* fugue_sqlParser::quotedIdentifier() {
  QuotedIdentifierContext *_localctx = _tracker.createInstance<QuotedIdentifierContext>(_ctx, getState());
  enterRule(_localctx, 416, fugue_sqlParser::RuleQuotedIdentifier);

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

  return _localctx;
}

//----------------- NumberContext ------------------------------------------------------------------

fugue_sqlParser::NumberContext::NumberContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}


size_t fugue_sqlParser::NumberContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNumber;
}

void fugue_sqlParser::NumberContext::copyFrom(NumberContext *ctx) {
  ParserRuleContext::copyFrom(ctx);
}

//----------------- DecimalLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DecimalLiteralContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::DecimalLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::DecimalLiteralContext::DecimalLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DecimalLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDecimalLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- BigIntLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::BigIntLiteralContext::BIGINT_LITERAL() {
  return getToken(fugue_sqlParser::BIGINT_LITERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::BigIntLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::BigIntLiteralContext::BigIntLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::BigIntLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitBigIntLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- TinyIntLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::TinyIntLiteralContext::TINYINT_LITERAL() {
  return getToken(fugue_sqlParser::TINYINT_LITERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::TinyIntLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::TinyIntLiteralContext::TinyIntLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::TinyIntLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitTinyIntLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- LegacyDecimalLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::LegacyDecimalLiteralContext::EXPONENT_VALUE() {
  return getToken(fugue_sqlParser::EXPONENT_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::LegacyDecimalLiteralContext::DECIMAL_VALUE() {
  return getToken(fugue_sqlParser::DECIMAL_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::LegacyDecimalLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::LegacyDecimalLiteralContext::LegacyDecimalLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::LegacyDecimalLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitLegacyDecimalLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- BigDecimalLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::BigDecimalLiteralContext::BIGDECIMAL_LITERAL() {
  return getToken(fugue_sqlParser::BIGDECIMAL_LITERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::BigDecimalLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::BigDecimalLiteralContext::BigDecimalLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::BigDecimalLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitBigDecimalLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- ExponentLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::ExponentLiteralContext::EXPONENT_VALUE() {
  return getToken(fugue_sqlParser::EXPONENT_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::ExponentLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::ExponentLiteralContext::ExponentLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::ExponentLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitExponentLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- DoubleLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::DoubleLiteralContext::DOUBLE_LITERAL() {
  return getToken(fugue_sqlParser::DOUBLE_LITERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::DoubleLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::DoubleLiteralContext::DoubleLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::DoubleLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitDoubleLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- IntegerLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::IntegerLiteralContext::INTEGER_VALUE() {
  return getToken(fugue_sqlParser::INTEGER_VALUE, 0);
}

tree::TerminalNode* fugue_sqlParser::IntegerLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::IntegerLiteralContext::IntegerLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::IntegerLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitIntegerLiteral(this);
  else
    return visitor->visitChildren(this);
}
//----------------- SmallIntLiteralContext ------------------------------------------------------------------

tree::TerminalNode* fugue_sqlParser::SmallIntLiteralContext::SMALLINT_LITERAL() {
  return getToken(fugue_sqlParser::SMALLINT_LITERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::SmallIntLiteralContext::MINUS() {
  return getToken(fugue_sqlParser::MINUS, 0);
}

fugue_sqlParser::SmallIntLiteralContext::SmallIntLiteralContext(NumberContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::SmallIntLiteralContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitSmallIntLiteral(this);
  else
    return visitor->visitChildren(this);
}
fugue_sqlParser::NumberContext* fugue_sqlParser::number() {
  NumberContext *_localctx = _tracker.createInstance<NumberContext>(_ctx, getState());
  enterRule(_localctx, 418, fugue_sqlParser::RuleNumber);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3816);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 516, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ExponentLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3781);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3780);
        match(fugue_sqlParser::MINUS);
      }
      setState(3783);
      match(fugue_sqlParser::EXPONENT_VALUE);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DecimalLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3785);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3784);
        match(fugue_sqlParser::MINUS);
      }
      setState(3787);
      match(fugue_sqlParser::DECIMAL_VALUE);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::LegacyDecimalLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3789);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3788);
        match(fugue_sqlParser::MINUS);
      }
      setState(3791);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::EXPONENT_VALUE

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

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::IntegerLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(3793);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3792);
        match(fugue_sqlParser::MINUS);
      }
      setState(3795);
      match(fugue_sqlParser::INTEGER_VALUE);
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::BigIntLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(3797);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3796);
        match(fugue_sqlParser::MINUS);
      }
      setState(3799);
      match(fugue_sqlParser::BIGINT_LITERAL);
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SmallIntLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 6);
      setState(3801);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3800);
        match(fugue_sqlParser::MINUS);
      }
      setState(3803);
      match(fugue_sqlParser::SMALLINT_LITERAL);
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TinyIntLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 7);
      setState(3805);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3804);
        match(fugue_sqlParser::MINUS);
      }
      setState(3807);
      match(fugue_sqlParser::TINYINT_LITERAL);
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DoubleLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 8);
      setState(3809);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3808);
        match(fugue_sqlParser::MINUS);
      }
      setState(3811);
      match(fugue_sqlParser::DOUBLE_LITERAL);
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<fugue_sqlParser::BigDecimalLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 9);
      setState(3813);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3812);
        match(fugue_sqlParser::MINUS);
      }
      setState(3815);
      match(fugue_sqlParser::BIGDECIMAL_LITERAL);
      break;
    }

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

  return _localctx;
}

//----------------- AlterColumnActionContext ------------------------------------------------------------------

fugue_sqlParser::AlterColumnActionContext::AlterColumnActionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::AlterColumnActionContext::TYPE() {
  return getToken(fugue_sqlParser::TYPE, 0);
}

fugue_sqlParser::DataTypeContext* fugue_sqlParser::AlterColumnActionContext::dataType() {
  return getRuleContext<fugue_sqlParser::DataTypeContext>(0);
}

fugue_sqlParser::CommentSpecContext* fugue_sqlParser::AlterColumnActionContext::commentSpec() {
  return getRuleContext<fugue_sqlParser::CommentSpecContext>(0);
}

fugue_sqlParser::ColPositionContext* fugue_sqlParser::AlterColumnActionContext::colPosition() {
  return getRuleContext<fugue_sqlParser::ColPositionContext>(0);
}

tree::TerminalNode* fugue_sqlParser::AlterColumnActionContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::AlterColumnActionContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::AlterColumnActionContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::AlterColumnActionContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}


size_t fugue_sqlParser::AlterColumnActionContext::getRuleIndex() const {
  return fugue_sqlParser::RuleAlterColumnAction;
}


std::any fugue_sqlParser::AlterColumnActionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAlterColumnAction(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::AlterColumnActionContext* fugue_sqlParser::alterColumnAction() {
  AlterColumnActionContext *_localctx = _tracker.createInstance<AlterColumnActionContext>(_ctx, getState());
  enterRule(_localctx, 420, fugue_sqlParser::RuleAlterColumnAction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3825);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::TYPE: {
        enterOuterAlt(_localctx, 1);
        setState(3818);
        match(fugue_sqlParser::TYPE);
        setState(3819);
        dataType();
        break;
      }

      case fugue_sqlParser::COMMENT: {
        enterOuterAlt(_localctx, 2);
        setState(3820);
        commentSpec();
        break;
      }

      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::FIRST: {
        enterOuterAlt(_localctx, 3);
        setState(3821);
        colPosition();
        break;
      }

      case fugue_sqlParser::DROP:
      case fugue_sqlParser::SET: {
        enterOuterAlt(_localctx, 4);
        setState(3822);
        antlrcpp::downCast<AlterColumnActionContext *>(_localctx)->setOrDrop = _input->LT(1);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::DROP || _la == fugue_sqlParser::SET)) {
          antlrcpp::downCast<AlterColumnActionContext *>(_localctx)->setOrDrop = _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(3823);
        match(fugue_sqlParser::NOT);
        setState(3824);
        match(fugue_sqlParser::THENULL);
        break;
      }

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

  return _localctx;
}

//----------------- AnsiNonReservedContext ------------------------------------------------------------------

fugue_sqlParser::AnsiNonReservedContext::AnsiNonReservedContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ADD() {
  return getToken(fugue_sqlParser::ADD, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::AFTER() {
  return getToken(fugue_sqlParser::AFTER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ANALYZE() {
  return getToken(fugue_sqlParser::ANALYZE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ARCHIVE() {
  return getToken(fugue_sqlParser::ARCHIVE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ARRAY() {
  return getToken(fugue_sqlParser::ARRAY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ASC() {
  return getToken(fugue_sqlParser::ASC, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::AT() {
  return getToken(fugue_sqlParser::AT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::BETWEEN() {
  return getToken(fugue_sqlParser::BETWEEN, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::BUCKET() {
  return getToken(fugue_sqlParser::BUCKET, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::BUCKETS() {
  return getToken(fugue_sqlParser::BUCKETS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CACHE() {
  return getToken(fugue_sqlParser::CACHE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CASCADE() {
  return getToken(fugue_sqlParser::CASCADE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CHANGE() {
  return getToken(fugue_sqlParser::CHANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CLEAR() {
  return getToken(fugue_sqlParser::CLEAR, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CLUSTER() {
  return getToken(fugue_sqlParser::CLUSTER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CLUSTERED() {
  return getToken(fugue_sqlParser::CLUSTERED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CODEGEN() {
  return getToken(fugue_sqlParser::CODEGEN, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COLLECTION() {
  return getToken(fugue_sqlParser::COLLECTION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COMMENT() {
  return getToken(fugue_sqlParser::COMMENT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COMMIT() {
  return getToken(fugue_sqlParser::COMMIT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COMPACT() {
  return getToken(fugue_sqlParser::COMPACT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COMPACTIONS() {
  return getToken(fugue_sqlParser::COMPACTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COMPUTE() {
  return getToken(fugue_sqlParser::COMPUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CONCATENATE() {
  return getToken(fugue_sqlParser::CONCATENATE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::COST() {
  return getToken(fugue_sqlParser::COST, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CUBE() {
  return getToken(fugue_sqlParser::CUBE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::CURRENT() {
  return getToken(fugue_sqlParser::CURRENT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DATA() {
  return getToken(fugue_sqlParser::DATA, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DATABASE() {
  return getToken(fugue_sqlParser::DATABASE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DATABASES() {
  return getToken(fugue_sqlParser::DATABASES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DBPROPERTIES() {
  return getToken(fugue_sqlParser::DBPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DEFINED() {
  return getToken(fugue_sqlParser::DEFINED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DELETE() {
  return getToken(fugue_sqlParser::DELETE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DELIMITED() {
  return getToken(fugue_sqlParser::DELIMITED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DESCRIBE() {
  return getToken(fugue_sqlParser::DESCRIBE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DFS() {
  return getToken(fugue_sqlParser::DFS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DIRECTORIES() {
  return getToken(fugue_sqlParser::DIRECTORIES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DIRECTORY() {
  return getToken(fugue_sqlParser::DIRECTORY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DISTRIBUTE() {
  return getToken(fugue_sqlParser::DISTRIBUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DIV() {
  return getToken(fugue_sqlParser::DIV, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ESCAPED() {
  return getToken(fugue_sqlParser::ESCAPED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXCHANGE() {
  return getToken(fugue_sqlParser::EXCHANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXPLAIN() {
  return getToken(fugue_sqlParser::EXPLAIN, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXPORT() {
  return getToken(fugue_sqlParser::EXPORT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXTERNAL() {
  return getToken(fugue_sqlParser::EXTERNAL, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::EXTRACT() {
  return getToken(fugue_sqlParser::EXTRACT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FIELDS() {
  return getToken(fugue_sqlParser::FIELDS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FILEFORMAT() {
  return getToken(fugue_sqlParser::FILEFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FIRST() {
  return getToken(fugue_sqlParser::FIRST, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FOLLOWING() {
  return getToken(fugue_sqlParser::FOLLOWING, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FORMAT() {
  return getToken(fugue_sqlParser::FORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FORMATTED() {
  return getToken(fugue_sqlParser::FORMATTED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FUNCTION() {
  return getToken(fugue_sqlParser::FUNCTION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::FUNCTIONS() {
  return getToken(fugue_sqlParser::FUNCTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::GLOBAL() {
  return getToken(fugue_sqlParser::GLOBAL, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::GROUPING() {
  return getToken(fugue_sqlParser::GROUPING, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::IGNORE() {
  return getToken(fugue_sqlParser::IGNORE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::IMPORT() {
  return getToken(fugue_sqlParser::IMPORT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::INDEX() {
  return getToken(fugue_sqlParser::INDEX, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::INDEXES() {
  return getToken(fugue_sqlParser::INDEXES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::INPATH() {
  return getToken(fugue_sqlParser::INPATH, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::INPUTFORMAT() {
  return getToken(fugue_sqlParser::INPUTFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::INTERVAL() {
  return getToken(fugue_sqlParser::INTERVAL, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ITEMS() {
  return getToken(fugue_sqlParser::ITEMS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::KEYS() {
  return getToken(fugue_sqlParser::KEYS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LAST() {
  return getToken(fugue_sqlParser::LAST, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LATERAL() {
  return getToken(fugue_sqlParser::LATERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LAZY() {
  return getToken(fugue_sqlParser::LAZY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LIMIT() {
  return getToken(fugue_sqlParser::LIMIT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LINES() {
  return getToken(fugue_sqlParser::LINES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LIST() {
  return getToken(fugue_sqlParser::LIST, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LOAD() {
  return getToken(fugue_sqlParser::LOAD, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LOCAL() {
  return getToken(fugue_sqlParser::LOCAL, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LOCATION() {
  return getToken(fugue_sqlParser::LOCATION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LOCK() {
  return getToken(fugue_sqlParser::LOCK, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LOCKS() {
  return getToken(fugue_sqlParser::LOCKS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::LOGICAL() {
  return getToken(fugue_sqlParser::LOGICAL, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::MACRO() {
  return getToken(fugue_sqlParser::MACRO, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::MAP() {
  return getToken(fugue_sqlParser::MAP, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::MATCHED() {
  return getToken(fugue_sqlParser::MATCHED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::MERGE() {
  return getToken(fugue_sqlParser::MERGE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::MSCK() {
  return getToken(fugue_sqlParser::MSCK, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::NAMESPACE() {
  return getToken(fugue_sqlParser::NAMESPACE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::NAMESPACES() {
  return getToken(fugue_sqlParser::NAMESPACES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::NO() {
  return getToken(fugue_sqlParser::NO, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OF() {
  return getToken(fugue_sqlParser::OF, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OPTION() {
  return getToken(fugue_sqlParser::OPTION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OPTIONS() {
  return getToken(fugue_sqlParser::OPTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OUT() {
  return getToken(fugue_sqlParser::OUT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OUTPUTFORMAT() {
  return getToken(fugue_sqlParser::OUTPUTFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OVER() {
  return getToken(fugue_sqlParser::OVER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OVERLAY() {
  return getToken(fugue_sqlParser::OVERLAY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PARTITION() {
  return getToken(fugue_sqlParser::PARTITION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PARTITIONED() {
  return getToken(fugue_sqlParser::PARTITIONED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PARTITIONS() {
  return getToken(fugue_sqlParser::PARTITIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PERCENTLIT() {
  return getToken(fugue_sqlParser::PERCENTLIT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PIVOT() {
  return getToken(fugue_sqlParser::PIVOT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PLACING() {
  return getToken(fugue_sqlParser::PLACING, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::POSITION() {
  return getToken(fugue_sqlParser::POSITION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PRECEDING() {
  return getToken(fugue_sqlParser::PRECEDING, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PRINCIPALS() {
  return getToken(fugue_sqlParser::PRINCIPALS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PROPERTIES() {
  return getToken(fugue_sqlParser::PROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::PURGE() {
  return getToken(fugue_sqlParser::PURGE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::QUERY() {
  return getToken(fugue_sqlParser::QUERY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RANGE() {
  return getToken(fugue_sqlParser::RANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RECORDREADER() {
  return getToken(fugue_sqlParser::RECORDREADER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RECORDWRITER() {
  return getToken(fugue_sqlParser::RECORDWRITER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RECOVER() {
  return getToken(fugue_sqlParser::RECOVER, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::REDUCE() {
  return getToken(fugue_sqlParser::REDUCE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::REFRESH() {
  return getToken(fugue_sqlParser::REFRESH, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RENAME() {
  return getToken(fugue_sqlParser::RENAME, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::REPAIR() {
  return getToken(fugue_sqlParser::REPAIR, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RESET() {
  return getToken(fugue_sqlParser::RESET, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RESTRICT() {
  return getToken(fugue_sqlParser::RESTRICT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::REVOKE() {
  return getToken(fugue_sqlParser::REVOKE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::RLIKE() {
  return getToken(fugue_sqlParser::RLIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ROLE() {
  return getToken(fugue_sqlParser::ROLE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ROLES() {
  return getToken(fugue_sqlParser::ROLES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ROLLBACK() {
  return getToken(fugue_sqlParser::ROLLBACK, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ROLLUP() {
  return getToken(fugue_sqlParser::ROLLUP, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SCHEMA() {
  return getToken(fugue_sqlParser::SCHEMA, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SEPARATED() {
  return getToken(fugue_sqlParser::SEPARATED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SERDE() {
  return getToken(fugue_sqlParser::SERDE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SERDEPROPERTIES() {
  return getToken(fugue_sqlParser::SERDEPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SETS() {
  return getToken(fugue_sqlParser::SETS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SKEWED() {
  return getToken(fugue_sqlParser::SKEWED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SORT() {
  return getToken(fugue_sqlParser::SORT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SORTED() {
  return getToken(fugue_sqlParser::SORTED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::START() {
  return getToken(fugue_sqlParser::START, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::STATISTICS() {
  return getToken(fugue_sqlParser::STATISTICS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::STORED() {
  return getToken(fugue_sqlParser::STORED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::STRATIFY() {
  return getToken(fugue_sqlParser::STRATIFY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::STRUCT() {
  return getToken(fugue_sqlParser::STRUCT, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SUBSTR() {
  return getToken(fugue_sqlParser::SUBSTR, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::SUBSTRING() {
  return getToken(fugue_sqlParser::SUBSTRING, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TABLES() {
  return getToken(fugue_sqlParser::TABLES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TABLESAMPLE() {
  return getToken(fugue_sqlParser::TABLESAMPLE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TBLPROPERTIES() {
  return getToken(fugue_sqlParser::TBLPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TERMINATED() {
  return getToken(fugue_sqlParser::TERMINATED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TOUCH() {
  return getToken(fugue_sqlParser::TOUCH, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TRANSACTION() {
  return getToken(fugue_sqlParser::TRANSACTION, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TRANSACTIONS() {
  return getToken(fugue_sqlParser::TRANSACTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TRANSFORM() {
  return getToken(fugue_sqlParser::TRANSFORM, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TRIM() {
  return getToken(fugue_sqlParser::TRIM, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TRUE() {
  return getToken(fugue_sqlParser::TRUE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::TRUNCATE() {
  return getToken(fugue_sqlParser::TRUNCATE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::UNARCHIVE() {
  return getToken(fugue_sqlParser::UNARCHIVE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::UNBOUNDED() {
  return getToken(fugue_sqlParser::UNBOUNDED, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::UNCACHE() {
  return getToken(fugue_sqlParser::UNCACHE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::UNLOCK() {
  return getToken(fugue_sqlParser::UNLOCK, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::UNSET() {
  return getToken(fugue_sqlParser::UNSET, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::UPDATE() {
  return getToken(fugue_sqlParser::UPDATE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::USE() {
  return getToken(fugue_sqlParser::USE, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::VALUES() {
  return getToken(fugue_sqlParser::VALUES, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::VIEWS() {
  return getToken(fugue_sqlParser::VIEWS, 0);
}

tree::TerminalNode* fugue_sqlParser::AnsiNonReservedContext::WINDOW() {
  return getToken(fugue_sqlParser::WINDOW, 0);
}


size_t fugue_sqlParser::AnsiNonReservedContext::getRuleIndex() const {
  return fugue_sqlParser::RuleAnsiNonReserved;
}


std::any fugue_sqlParser::AnsiNonReservedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitAnsiNonReserved(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::AnsiNonReservedContext* fugue_sqlParser::ansiNonReserved() {
  AnsiNonReservedContext *_localctx = _tracker.createInstance<AnsiNonReservedContext>(_ctx, getState());
  enterRule(_localctx, 422, fugue_sqlParser::RuleAnsiNonReserved);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3827);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::ADD)
      | (1ULL << fugue_sqlParser::AFTER)
      | (1ULL << fugue_sqlParser::ALTER)
      | (1ULL << fugue_sqlParser::ANALYZE)
      | (1ULL << fugue_sqlParser::ARCHIVE)
      | (1ULL << fugue_sqlParser::ARRAY))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
      | (1ULL << (fugue_sqlParser::AT - 64))
      | (1ULL << (fugue_sqlParser::BETWEEN - 64))
      | (1ULL << (fugue_sqlParser::BUCKET - 64))
      | (1ULL << (fugue_sqlParser::BUCKETS - 64))
      | (1ULL << (fugue_sqlParser::BY - 64))
      | (1ULL << (fugue_sqlParser::CACHE - 64))
      | (1ULL << (fugue_sqlParser::CASCADE - 64))
      | (1ULL << (fugue_sqlParser::CHANGE - 64))
      | (1ULL << (fugue_sqlParser::CLEAR - 64))
      | (1ULL << (fugue_sqlParser::CLUSTER - 64))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
      | (1ULL << (fugue_sqlParser::CODEGEN - 64))
      | (1ULL << (fugue_sqlParser::COLLECTION - 64))
      | (1ULL << (fugue_sqlParser::COLUMNS - 64))
      | (1ULL << (fugue_sqlParser::COMMENT - 64))
      | (1ULL << (fugue_sqlParser::COMMIT - 64))
      | (1ULL << (fugue_sqlParser::COMPACT - 64))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
      | (1ULL << (fugue_sqlParser::COMPUTE - 64))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
      | (1ULL << (fugue_sqlParser::COST - 64))
      | (1ULL << (fugue_sqlParser::CUBE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT - 64))
      | (1ULL << (fugue_sqlParser::DATA - 64))
      | (1ULL << (fugue_sqlParser::DATABASE - 64))
      | (1ULL << (fugue_sqlParser::DATABASES - 64))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
      | (1ULL << (fugue_sqlParser::DEFINED - 64))
      | (1ULL << (fugue_sqlParser::DELETE - 64))
      | (1ULL << (fugue_sqlParser::DELIMITED - 64))
      | (1ULL << (fugue_sqlParser::DESC - 64))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
      | (1ULL << (fugue_sqlParser::DFS - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
      | (1ULL << (fugue_sqlParser::DROP - 64))
      | (1ULL << (fugue_sqlParser::ESCAPED - 64))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
      | (1ULL << (fugue_sqlParser::EXISTS - 64))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
      | (1ULL << (fugue_sqlParser::EXPORT - 64))
      | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
      | (1ULL << (fugue_sqlParser::EXTRACT - 128))
      | (1ULL << (fugue_sqlParser::FIELDS - 128))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
      | (1ULL << (fugue_sqlParser::FIRST - 128))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
      | (1ULL << (fugue_sqlParser::FORMAT - 128))
      | (1ULL << (fugue_sqlParser::FORMATTED - 128))
      | (1ULL << (fugue_sqlParser::FUNCTION - 128))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
      | (1ULL << (fugue_sqlParser::GLOBAL - 128))
      | (1ULL << (fugue_sqlParser::GROUPING - 128))
      | (1ULL << (fugue_sqlParser::IF - 128))
      | (1ULL << (fugue_sqlParser::IGNORE - 128))
      | (1ULL << (fugue_sqlParser::IMPORT - 128))
      | (1ULL << (fugue_sqlParser::INDEX - 128))
      | (1ULL << (fugue_sqlParser::INDEXES - 128))
      | (1ULL << (fugue_sqlParser::INPATH - 128))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
      | (1ULL << (fugue_sqlParser::INSERT - 128))
      | (1ULL << (fugue_sqlParser::INTERVAL - 128))
      | (1ULL << (fugue_sqlParser::ITEMS - 128))
      | (1ULL << (fugue_sqlParser::KEYS - 128))
      | (1ULL << (fugue_sqlParser::LAST - 128))
      | (1ULL << (fugue_sqlParser::LATERAL - 128))
      | (1ULL << (fugue_sqlParser::LAZY - 128))
      | (1ULL << (fugue_sqlParser::LIKE - 128))
      | (1ULL << (fugue_sqlParser::LIMIT - 128))
      | (1ULL << (fugue_sqlParser::LINES - 128))
      | (1ULL << (fugue_sqlParser::LIST - 128))
      | (1ULL << (fugue_sqlParser::LOAD - 128))
      | (1ULL << (fugue_sqlParser::LOCAL - 128))
      | (1ULL << (fugue_sqlParser::LOCATION - 128))
      | (1ULL << (fugue_sqlParser::LOCK - 128))
      | (1ULL << (fugue_sqlParser::LOCKS - 128))
      | (1ULL << (fugue_sqlParser::LOGICAL - 128))
      | (1ULL << (fugue_sqlParser::MACRO - 128))
      | (1ULL << (fugue_sqlParser::MAP - 128))
      | (1ULL << (fugue_sqlParser::MATCHED - 128))
      | (1ULL << (fugue_sqlParser::MERGE - 128))
      | (1ULL << (fugue_sqlParser::MSCK - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 193) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 193)) & ((1ULL << (fugue_sqlParser::NO - 193))
      | (1ULL << (fugue_sqlParser::THENULLS - 193))
      | (1ULL << (fugue_sqlParser::OF - 193))
      | (1ULL << (fugue_sqlParser::OPTION - 193))
      | (1ULL << (fugue_sqlParser::OPTIONS - 193))
      | (1ULL << (fugue_sqlParser::OUT - 193))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 193))
      | (1ULL << (fugue_sqlParser::OVER - 193))
      | (1ULL << (fugue_sqlParser::OVERLAY - 193))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 193))
      | (1ULL << (fugue_sqlParser::PARTITION - 193))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 193))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 193))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 193))
      | (1ULL << (fugue_sqlParser::PIVOT - 193))
      | (1ULL << (fugue_sqlParser::PLACING - 193))
      | (1ULL << (fugue_sqlParser::POSITION - 193))
      | (1ULL << (fugue_sqlParser::PRECEDING - 193))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 193))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 193))
      | (1ULL << (fugue_sqlParser::PURGE - 193))
      | (1ULL << (fugue_sqlParser::QUERY - 193))
      | (1ULL << (fugue_sqlParser::RANGE - 193))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 193))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 193))
      | (1ULL << (fugue_sqlParser::RECOVER - 193))
      | (1ULL << (fugue_sqlParser::REDUCE - 193))
      | (1ULL << (fugue_sqlParser::REFRESH - 193))
      | (1ULL << (fugue_sqlParser::RENAME - 193))
      | (1ULL << (fugue_sqlParser::REPAIR - 193))
      | (1ULL << (fugue_sqlParser::REPLACE - 193))
      | (1ULL << (fugue_sqlParser::RESET - 193))
      | (1ULL << (fugue_sqlParser::RESTRICT - 193))
      | (1ULL << (fugue_sqlParser::REVOKE - 193))
      | (1ULL << (fugue_sqlParser::RLIKE - 193))
      | (1ULL << (fugue_sqlParser::ROLE - 193))
      | (1ULL << (fugue_sqlParser::ROLES - 193))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 193))
      | (1ULL << (fugue_sqlParser::ROLLUP - 193))
      | (1ULL << (fugue_sqlParser::ROW - 193))
      | (1ULL << (fugue_sqlParser::ROWS - 193))
      | (1ULL << (fugue_sqlParser::SCHEMA - 193))
      | (1ULL << (fugue_sqlParser::SEPARATED - 193))
      | (1ULL << (fugue_sqlParser::SERDE - 193))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 193))
      | (1ULL << (fugue_sqlParser::SET - 193))
      | (1ULL << (fugue_sqlParser::SETS - 193))
      | (1ULL << (fugue_sqlParser::SHOW - 193)))) != 0) || ((((_la - 257) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 257)) & ((1ULL << (fugue_sqlParser::SKEWED - 257))
      | (1ULL << (fugue_sqlParser::SORT - 257))
      | (1ULL << (fugue_sqlParser::SORTED - 257))
      | (1ULL << (fugue_sqlParser::START - 257))
      | (1ULL << (fugue_sqlParser::STATISTICS - 257))
      | (1ULL << (fugue_sqlParser::STORED - 257))
      | (1ULL << (fugue_sqlParser::STRATIFY - 257))
      | (1ULL << (fugue_sqlParser::STRUCT - 257))
      | (1ULL << (fugue_sqlParser::SUBSTR - 257))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 257))
      | (1ULL << (fugue_sqlParser::TABLES - 257))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 257))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 257))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 257))
      | (1ULL << (fugue_sqlParser::TERMINATED - 257))
      | (1ULL << (fugue_sqlParser::TOUCH - 257))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 257))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 257))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 257))
      | (1ULL << (fugue_sqlParser::TRIM - 257))
      | (1ULL << (fugue_sqlParser::TRUE - 257))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 257))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 257))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 257))
      | (1ULL << (fugue_sqlParser::UNCACHE - 257))
      | (1ULL << (fugue_sqlParser::UNLOCK - 257))
      | (1ULL << (fugue_sqlParser::UNSET - 257))
      | (1ULL << (fugue_sqlParser::UPDATE - 257))
      | (1ULL << (fugue_sqlParser::USE - 257))
      | (1ULL << (fugue_sqlParser::VALUES - 257))
      | (1ULL << (fugue_sqlParser::VIEW - 257))
      | (1ULL << (fugue_sqlParser::VIEWS - 257))
      | (1ULL << (fugue_sqlParser::WINDOW - 257))
      | (1ULL << (fugue_sqlParser::DIV - 257)))) != 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;
}

//----------------- StrictNonReservedContext ------------------------------------------------------------------

fugue_sqlParser::StrictNonReservedContext::StrictNonReservedContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::ANTI() {
  return getToken(fugue_sqlParser::ANTI, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::CROSS() {
  return getToken(fugue_sqlParser::CROSS, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::EXCEPT() {
  return getToken(fugue_sqlParser::EXCEPT, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::FULL() {
  return getToken(fugue_sqlParser::FULL, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::INNER() {
  return getToken(fugue_sqlParser::INNER, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::INTERSECT() {
  return getToken(fugue_sqlParser::INTERSECT, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::JOIN() {
  return getToken(fugue_sqlParser::JOIN, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::LEFT() {
  return getToken(fugue_sqlParser::LEFT, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::NATURAL() {
  return getToken(fugue_sqlParser::NATURAL, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::ON() {
  return getToken(fugue_sqlParser::ON, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::RIGHT() {
  return getToken(fugue_sqlParser::RIGHT, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::SEMI() {
  return getToken(fugue_sqlParser::SEMI, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::SETMINUS() {
  return getToken(fugue_sqlParser::SETMINUS, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::UNION() {
  return getToken(fugue_sqlParser::UNION, 0);
}

tree::TerminalNode* fugue_sqlParser::StrictNonReservedContext::USING() {
  return getToken(fugue_sqlParser::USING, 0);
}


size_t fugue_sqlParser::StrictNonReservedContext::getRuleIndex() const {
  return fugue_sqlParser::RuleStrictNonReserved;
}


std::any fugue_sqlParser::StrictNonReservedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitStrictNonReserved(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::StrictNonReservedContext* fugue_sqlParser::strictNonReserved() {
  StrictNonReservedContext *_localctx = _tracker.createInstance<StrictNonReservedContext>(_ctx, getState());
  enterRule(_localctx, 424, fugue_sqlParser::RuleStrictNonReserved);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3829);
    _la = _input->LA(1);
    if (!(((((_la - 59) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 59)) & ((1ULL << (fugue_sqlParser::ANTI - 59))
      | (1ULL << (fugue_sqlParser::CROSS - 59))
      | (1ULL << (fugue_sqlParser::EXCEPT - 59)))) != 0) || ((((_la - 142) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 142)) & ((1ULL << (fugue_sqlParser::FULL - 142))
      | (1ULL << (fugue_sqlParser::INNER - 142))
      | (1ULL << (fugue_sqlParser::INTERSECT - 142))
      | (1ULL << (fugue_sqlParser::JOIN - 142))
      | (1ULL << (fugue_sqlParser::LEFT - 142))
      | (1ULL << (fugue_sqlParser::NATURAL - 142))
      | (1ULL << (fugue_sqlParser::ON - 142)))) != 0) || ((((_la - 237) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 237)) & ((1ULL << (fugue_sqlParser::RIGHT - 237))
      | (1ULL << (fugue_sqlParser::SEMI - 237))
      | (1ULL << (fugue_sqlParser::SETMINUS - 237))
      | (1ULL << (fugue_sqlParser::UNION - 237))
      | (1ULL << (fugue_sqlParser::USING - 237)))) != 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;
}

//----------------- NonReservedContext ------------------------------------------------------------------

fugue_sqlParser::NonReservedContext::NonReservedContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ADD() {
  return getToken(fugue_sqlParser::ADD, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::AFTER() {
  return getToken(fugue_sqlParser::AFTER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ALL() {
  return getToken(fugue_sqlParser::ALL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ALTER() {
  return getToken(fugue_sqlParser::ALTER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ANALYZE() {
  return getToken(fugue_sqlParser::ANALYZE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::AND() {
  return getToken(fugue_sqlParser::AND, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ANY() {
  return getToken(fugue_sqlParser::ANY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ARCHIVE() {
  return getToken(fugue_sqlParser::ARCHIVE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ARRAY() {
  return getToken(fugue_sqlParser::ARRAY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::AS() {
  return getToken(fugue_sqlParser::AS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ASC() {
  return getToken(fugue_sqlParser::ASC, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::AT() {
  return getToken(fugue_sqlParser::AT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::AUTHORIZATION() {
  return getToken(fugue_sqlParser::AUTHORIZATION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::BETWEEN() {
  return getToken(fugue_sqlParser::BETWEEN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::BOTH() {
  return getToken(fugue_sqlParser::BOTH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::BUCKET() {
  return getToken(fugue_sqlParser::BUCKET, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::BUCKETS() {
  return getToken(fugue_sqlParser::BUCKETS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::BY() {
  return getToken(fugue_sqlParser::BY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CACHE() {
  return getToken(fugue_sqlParser::CACHE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CASCADE() {
  return getToken(fugue_sqlParser::CASCADE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CASE() {
  return getToken(fugue_sqlParser::CASE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CAST() {
  return getToken(fugue_sqlParser::CAST, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CHANGE() {
  return getToken(fugue_sqlParser::CHANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CHECK() {
  return getToken(fugue_sqlParser::CHECK, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CLEAR() {
  return getToken(fugue_sqlParser::CLEAR, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CLUSTER() {
  return getToken(fugue_sqlParser::CLUSTER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CLUSTERED() {
  return getToken(fugue_sqlParser::CLUSTERED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CODEGEN() {
  return getToken(fugue_sqlParser::CODEGEN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COLLATE() {
  return getToken(fugue_sqlParser::COLLATE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COLLECTION() {
  return getToken(fugue_sqlParser::COLLECTION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COLUMN() {
  return getToken(fugue_sqlParser::COLUMN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COLUMNS() {
  return getToken(fugue_sqlParser::COLUMNS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COMMENT() {
  return getToken(fugue_sqlParser::COMMENT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COMMIT() {
  return getToken(fugue_sqlParser::COMMIT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COMPACT() {
  return getToken(fugue_sqlParser::COMPACT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COMPACTIONS() {
  return getToken(fugue_sqlParser::COMPACTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COMPUTE() {
  return getToken(fugue_sqlParser::COMPUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CONCATENATE() {
  return getToken(fugue_sqlParser::CONCATENATE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CONSTRAINT() {
  return getToken(fugue_sqlParser::CONSTRAINT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::COST() {
  return getToken(fugue_sqlParser::COST, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CREATE() {
  return getToken(fugue_sqlParser::CREATE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CUBE() {
  return getToken(fugue_sqlParser::CUBE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CURRENT() {
  return getToken(fugue_sqlParser::CURRENT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CURRENT_DATE() {
  return getToken(fugue_sqlParser::CURRENT_DATE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CURRENT_TIME() {
  return getToken(fugue_sqlParser::CURRENT_TIME, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CURRENT_TIMESTAMP() {
  return getToken(fugue_sqlParser::CURRENT_TIMESTAMP, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::CURRENT_USER() {
  return getToken(fugue_sqlParser::CURRENT_USER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DATA() {
  return getToken(fugue_sqlParser::DATA, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DATABASE() {
  return getToken(fugue_sqlParser::DATABASE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DATABASES() {
  return getToken(fugue_sqlParser::DATABASES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DAY() {
  return getToken(fugue_sqlParser::DAY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DBPROPERTIES() {
  return getToken(fugue_sqlParser::DBPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DEFINED() {
  return getToken(fugue_sqlParser::DEFINED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DELETE() {
  return getToken(fugue_sqlParser::DELETE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DELIMITED() {
  return getToken(fugue_sqlParser::DELIMITED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DESC() {
  return getToken(fugue_sqlParser::DESC, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DESCRIBE() {
  return getToken(fugue_sqlParser::DESCRIBE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DFS() {
  return getToken(fugue_sqlParser::DFS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DIRECTORIES() {
  return getToken(fugue_sqlParser::DIRECTORIES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DIRECTORY() {
  return getToken(fugue_sqlParser::DIRECTORY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DISTINCT() {
  return getToken(fugue_sqlParser::DISTINCT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DISTRIBUTE() {
  return getToken(fugue_sqlParser::DISTRIBUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DIV() {
  return getToken(fugue_sqlParser::DIV, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::DROP() {
  return getToken(fugue_sqlParser::DROP, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ELSE() {
  return getToken(fugue_sqlParser::ELSE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::END() {
  return getToken(fugue_sqlParser::END, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ESCAPE() {
  return getToken(fugue_sqlParser::ESCAPE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ESCAPED() {
  return getToken(fugue_sqlParser::ESCAPED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXCHANGE() {
  return getToken(fugue_sqlParser::EXCHANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXISTS() {
  return getToken(fugue_sqlParser::EXISTS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXPLAIN() {
  return getToken(fugue_sqlParser::EXPLAIN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXPORT() {
  return getToken(fugue_sqlParser::EXPORT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXTENDED() {
  return getToken(fugue_sqlParser::EXTENDED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXTERNAL() {
  return getToken(fugue_sqlParser::EXTERNAL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::EXTRACT() {
  return getToken(fugue_sqlParser::EXTRACT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FALSE() {
  return getToken(fugue_sqlParser::FALSE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FETCH() {
  return getToken(fugue_sqlParser::FETCH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FILTER() {
  return getToken(fugue_sqlParser::FILTER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FIELDS() {
  return getToken(fugue_sqlParser::FIELDS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FILEFORMAT() {
  return getToken(fugue_sqlParser::FILEFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FIRST() {
  return getToken(fugue_sqlParser::FIRST, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FOLLOWING() {
  return getToken(fugue_sqlParser::FOLLOWING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FOR() {
  return getToken(fugue_sqlParser::FOR, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FOREIGN() {
  return getToken(fugue_sqlParser::FOREIGN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FORMAT() {
  return getToken(fugue_sqlParser::FORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FORMATTED() {
  return getToken(fugue_sqlParser::FORMATTED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FROM() {
  return getToken(fugue_sqlParser::FROM, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FUNCTION() {
  return getToken(fugue_sqlParser::FUNCTION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::FUNCTIONS() {
  return getToken(fugue_sqlParser::FUNCTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::GLOBAL() {
  return getToken(fugue_sqlParser::GLOBAL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::GRANT() {
  return getToken(fugue_sqlParser::GRANT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::GROUP() {
  return getToken(fugue_sqlParser::GROUP, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::GROUPING() {
  return getToken(fugue_sqlParser::GROUPING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::HAVING() {
  return getToken(fugue_sqlParser::HAVING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::HOUR() {
  return getToken(fugue_sqlParser::HOUR, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::IF() {
  return getToken(fugue_sqlParser::IF, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::IGNORE() {
  return getToken(fugue_sqlParser::IGNORE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::IMPORT() {
  return getToken(fugue_sqlParser::IMPORT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::IN() {
  return getToken(fugue_sqlParser::IN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INDEX() {
  return getToken(fugue_sqlParser::INDEX, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INDEXES() {
  return getToken(fugue_sqlParser::INDEXES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INPATH() {
  return getToken(fugue_sqlParser::INPATH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INPUTFORMAT() {
  return getToken(fugue_sqlParser::INPUTFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INSERT() {
  return getToken(fugue_sqlParser::INSERT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INTERVAL() {
  return getToken(fugue_sqlParser::INTERVAL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::INTO() {
  return getToken(fugue_sqlParser::INTO, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::IS() {
  return getToken(fugue_sqlParser::IS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ITEMS() {
  return getToken(fugue_sqlParser::ITEMS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::KEYS() {
  return getToken(fugue_sqlParser::KEYS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LAST() {
  return getToken(fugue_sqlParser::LAST, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LATERAL() {
  return getToken(fugue_sqlParser::LATERAL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LAZY() {
  return getToken(fugue_sqlParser::LAZY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LEADING() {
  return getToken(fugue_sqlParser::LEADING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LIKE() {
  return getToken(fugue_sqlParser::LIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LIMIT() {
  return getToken(fugue_sqlParser::LIMIT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LINES() {
  return getToken(fugue_sqlParser::LINES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LIST() {
  return getToken(fugue_sqlParser::LIST, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LOAD() {
  return getToken(fugue_sqlParser::LOAD, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LOCAL() {
  return getToken(fugue_sqlParser::LOCAL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LOCATION() {
  return getToken(fugue_sqlParser::LOCATION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LOCK() {
  return getToken(fugue_sqlParser::LOCK, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LOCKS() {
  return getToken(fugue_sqlParser::LOCKS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::LOGICAL() {
  return getToken(fugue_sqlParser::LOGICAL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MACRO() {
  return getToken(fugue_sqlParser::MACRO, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MAP() {
  return getToken(fugue_sqlParser::MAP, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MATCHED() {
  return getToken(fugue_sqlParser::MATCHED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MERGE() {
  return getToken(fugue_sqlParser::MERGE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MINUTE() {
  return getToken(fugue_sqlParser::MINUTE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MONTH() {
  return getToken(fugue_sqlParser::MONTH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::MSCK() {
  return getToken(fugue_sqlParser::MSCK, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::NAMESPACE() {
  return getToken(fugue_sqlParser::NAMESPACE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::NAMESPACES() {
  return getToken(fugue_sqlParser::NAMESPACES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::NO() {
  return getToken(fugue_sqlParser::NO, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::NOT() {
  return getToken(fugue_sqlParser::NOT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::THENULL() {
  return getToken(fugue_sqlParser::THENULL, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::THENULLS() {
  return getToken(fugue_sqlParser::THENULLS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OF() {
  return getToken(fugue_sqlParser::OF, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ONLY() {
  return getToken(fugue_sqlParser::ONLY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OPTION() {
  return getToken(fugue_sqlParser::OPTION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OPTIONS() {
  return getToken(fugue_sqlParser::OPTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OR() {
  return getToken(fugue_sqlParser::OR, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ORDER() {
  return getToken(fugue_sqlParser::ORDER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OUT() {
  return getToken(fugue_sqlParser::OUT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OUTER() {
  return getToken(fugue_sqlParser::OUTER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OUTPUTFORMAT() {
  return getToken(fugue_sqlParser::OUTPUTFORMAT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OVER() {
  return getToken(fugue_sqlParser::OVER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OVERLAPS() {
  return getToken(fugue_sqlParser::OVERLAPS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OVERLAY() {
  return getToken(fugue_sqlParser::OVERLAY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::OVERWRITE() {
  return getToken(fugue_sqlParser::OVERWRITE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PARTITION() {
  return getToken(fugue_sqlParser::PARTITION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PARTITIONED() {
  return getToken(fugue_sqlParser::PARTITIONED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PARTITIONS() {
  return getToken(fugue_sqlParser::PARTITIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PERCENTLIT() {
  return getToken(fugue_sqlParser::PERCENTLIT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PIVOT() {
  return getToken(fugue_sqlParser::PIVOT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PLACING() {
  return getToken(fugue_sqlParser::PLACING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::POSITION() {
  return getToken(fugue_sqlParser::POSITION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PRECEDING() {
  return getToken(fugue_sqlParser::PRECEDING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PRIMARY() {
  return getToken(fugue_sqlParser::PRIMARY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PRINCIPALS() {
  return getToken(fugue_sqlParser::PRINCIPALS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PROPERTIES() {
  return getToken(fugue_sqlParser::PROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::PURGE() {
  return getToken(fugue_sqlParser::PURGE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::QUERY() {
  return getToken(fugue_sqlParser::QUERY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RANGE() {
  return getToken(fugue_sqlParser::RANGE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RECORDREADER() {
  return getToken(fugue_sqlParser::RECORDREADER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RECORDWRITER() {
  return getToken(fugue_sqlParser::RECORDWRITER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RECOVER() {
  return getToken(fugue_sqlParser::RECOVER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::REDUCE() {
  return getToken(fugue_sqlParser::REDUCE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::REFERENCES() {
  return getToken(fugue_sqlParser::REFERENCES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::REFRESH() {
  return getToken(fugue_sqlParser::REFRESH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RENAME() {
  return getToken(fugue_sqlParser::RENAME, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::REPAIR() {
  return getToken(fugue_sqlParser::REPAIR, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::REPLACE() {
  return getToken(fugue_sqlParser::REPLACE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RESET() {
  return getToken(fugue_sqlParser::RESET, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RESTRICT() {
  return getToken(fugue_sqlParser::RESTRICT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::REVOKE() {
  return getToken(fugue_sqlParser::REVOKE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::RLIKE() {
  return getToken(fugue_sqlParser::RLIKE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ROLE() {
  return getToken(fugue_sqlParser::ROLE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ROLES() {
  return getToken(fugue_sqlParser::ROLES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ROLLBACK() {
  return getToken(fugue_sqlParser::ROLLBACK, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ROLLUP() {
  return getToken(fugue_sqlParser::ROLLUP, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ROW() {
  return getToken(fugue_sqlParser::ROW, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::ROWS() {
  return getToken(fugue_sqlParser::ROWS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SCHEMA() {
  return getToken(fugue_sqlParser::SCHEMA, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SECOND() {
  return getToken(fugue_sqlParser::SECOND, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SELECT() {
  return getToken(fugue_sqlParser::SELECT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SEPARATED() {
  return getToken(fugue_sqlParser::SEPARATED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SERDE() {
  return getToken(fugue_sqlParser::SERDE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SERDEPROPERTIES() {
  return getToken(fugue_sqlParser::SERDEPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SESSION_USER() {
  return getToken(fugue_sqlParser::SESSION_USER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SET() {
  return getToken(fugue_sqlParser::SET, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SETS() {
  return getToken(fugue_sqlParser::SETS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SHOW() {
  return getToken(fugue_sqlParser::SHOW, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SKEWED() {
  return getToken(fugue_sqlParser::SKEWED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SOME() {
  return getToken(fugue_sqlParser::SOME, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SORT() {
  return getToken(fugue_sqlParser::SORT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SORTED() {
  return getToken(fugue_sqlParser::SORTED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::START() {
  return getToken(fugue_sqlParser::START, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::STATISTICS() {
  return getToken(fugue_sqlParser::STATISTICS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::STORED() {
  return getToken(fugue_sqlParser::STORED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::STRATIFY() {
  return getToken(fugue_sqlParser::STRATIFY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::STRUCT() {
  return getToken(fugue_sqlParser::STRUCT, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SUBSTR() {
  return getToken(fugue_sqlParser::SUBSTR, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::SUBSTRING() {
  return getToken(fugue_sqlParser::SUBSTRING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TABLES() {
  return getToken(fugue_sqlParser::TABLES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TABLESAMPLE() {
  return getToken(fugue_sqlParser::TABLESAMPLE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TBLPROPERTIES() {
  return getToken(fugue_sqlParser::TBLPROPERTIES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TEMPORARY() {
  return getToken(fugue_sqlParser::TEMPORARY, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TERMINATED() {
  return getToken(fugue_sqlParser::TERMINATED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::THEN() {
  return getToken(fugue_sqlParser::THEN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TO() {
  return getToken(fugue_sqlParser::TO, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TOUCH() {
  return getToken(fugue_sqlParser::TOUCH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRAILING() {
  return getToken(fugue_sqlParser::TRAILING, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRANSACTION() {
  return getToken(fugue_sqlParser::TRANSACTION, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRANSACTIONS() {
  return getToken(fugue_sqlParser::TRANSACTIONS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRANSFORM() {
  return getToken(fugue_sqlParser::TRANSFORM, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRIM() {
  return getToken(fugue_sqlParser::TRIM, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRUE() {
  return getToken(fugue_sqlParser::TRUE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TRUNCATE() {
  return getToken(fugue_sqlParser::TRUNCATE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::TYPE() {
  return getToken(fugue_sqlParser::TYPE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNARCHIVE() {
  return getToken(fugue_sqlParser::UNARCHIVE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNBOUNDED() {
  return getToken(fugue_sqlParser::UNBOUNDED, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNCACHE() {
  return getToken(fugue_sqlParser::UNCACHE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNIQUE() {
  return getToken(fugue_sqlParser::UNIQUE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNKNOWN() {
  return getToken(fugue_sqlParser::UNKNOWN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNLOCK() {
  return getToken(fugue_sqlParser::UNLOCK, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UNSET() {
  return getToken(fugue_sqlParser::UNSET, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::UPDATE() {
  return getToken(fugue_sqlParser::UPDATE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::USE() {
  return getToken(fugue_sqlParser::USE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::USER() {
  return getToken(fugue_sqlParser::USER, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::VALUES() {
  return getToken(fugue_sqlParser::VALUES, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::VIEWS() {
  return getToken(fugue_sqlParser::VIEWS, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::WHEN() {
  return getToken(fugue_sqlParser::WHEN, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::WHERE() {
  return getToken(fugue_sqlParser::WHERE, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::WINDOW() {
  return getToken(fugue_sqlParser::WINDOW, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::WITH() {
  return getToken(fugue_sqlParser::WITH, 0);
}

tree::TerminalNode* fugue_sqlParser::NonReservedContext::YEAR() {
  return getToken(fugue_sqlParser::YEAR, 0);
}


size_t fugue_sqlParser::NonReservedContext::getRuleIndex() const {
  return fugue_sqlParser::RuleNonReserved;
}


std::any fugue_sqlParser::NonReservedContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitNonReserved(this);
  else
    return visitor->visitChildren(this);
}

fugue_sqlParser::NonReservedContext* fugue_sqlParser::nonReserved() {
  NonReservedContext *_localctx = _tracker.createInstance<NonReservedContext>(_ctx, getState());
  enterRule(_localctx, 426, fugue_sqlParser::RuleNonReserved);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3831);
    _la = _input->LA(1);
    if (!((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << fugue_sqlParser::ADD)
      | (1ULL << fugue_sqlParser::AFTER)
      | (1ULL << fugue_sqlParser::ALL)
      | (1ULL << fugue_sqlParser::ALTER)
      | (1ULL << fugue_sqlParser::ANALYZE)
      | (1ULL << fugue_sqlParser::AND)
      | (1ULL << fugue_sqlParser::ANY)
      | (1ULL << fugue_sqlParser::ARCHIVE)
      | (1ULL << fugue_sqlParser::ARRAY)
      | (1ULL << fugue_sqlParser::AS))) != 0) || ((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & ((1ULL << (fugue_sqlParser::ASC - 64))
      | (1ULL << (fugue_sqlParser::AT - 64))
      | (1ULL << (fugue_sqlParser::AUTHORIZATION - 64))
      | (1ULL << (fugue_sqlParser::BETWEEN - 64))
      | (1ULL << (fugue_sqlParser::BOTH - 64))
      | (1ULL << (fugue_sqlParser::BUCKET - 64))
      | (1ULL << (fugue_sqlParser::BUCKETS - 64))
      | (1ULL << (fugue_sqlParser::BY - 64))
      | (1ULL << (fugue_sqlParser::CACHE - 64))
      | (1ULL << (fugue_sqlParser::CASCADE - 64))
      | (1ULL << (fugue_sqlParser::CASE - 64))
      | (1ULL << (fugue_sqlParser::CAST - 64))
      | (1ULL << (fugue_sqlParser::CHANGE - 64))
      | (1ULL << (fugue_sqlParser::CHECK - 64))
      | (1ULL << (fugue_sqlParser::CLEAR - 64))
      | (1ULL << (fugue_sqlParser::CLUSTER - 64))
      | (1ULL << (fugue_sqlParser::CLUSTERED - 64))
      | (1ULL << (fugue_sqlParser::CODEGEN - 64))
      | (1ULL << (fugue_sqlParser::COLLATE - 64))
      | (1ULL << (fugue_sqlParser::COLLECTION - 64))
      | (1ULL << (fugue_sqlParser::COLUMN - 64))
      | (1ULL << (fugue_sqlParser::COLUMNS - 64))
      | (1ULL << (fugue_sqlParser::COMMENT - 64))
      | (1ULL << (fugue_sqlParser::COMMIT - 64))
      | (1ULL << (fugue_sqlParser::COMPACT - 64))
      | (1ULL << (fugue_sqlParser::COMPACTIONS - 64))
      | (1ULL << (fugue_sqlParser::COMPUTE - 64))
      | (1ULL << (fugue_sqlParser::CONCATENATE - 64))
      | (1ULL << (fugue_sqlParser::CONSTRAINT - 64))
      | (1ULL << (fugue_sqlParser::COST - 64))
      | (1ULL << (fugue_sqlParser::CREATE - 64))
      | (1ULL << (fugue_sqlParser::CUBE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_DATE - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIME - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_TIMESTAMP - 64))
      | (1ULL << (fugue_sqlParser::CURRENT_USER - 64))
      | (1ULL << (fugue_sqlParser::DATA - 64))
      | (1ULL << (fugue_sqlParser::DATABASE - 64))
      | (1ULL << (fugue_sqlParser::DATABASES - 64))
      | (1ULL << (fugue_sqlParser::DAY - 64))
      | (1ULL << (fugue_sqlParser::DBPROPERTIES - 64))
      | (1ULL << (fugue_sqlParser::DEFINED - 64))
      | (1ULL << (fugue_sqlParser::DELETE - 64))
      | (1ULL << (fugue_sqlParser::DELIMITED - 64))
      | (1ULL << (fugue_sqlParser::DESC - 64))
      | (1ULL << (fugue_sqlParser::DESCRIBE - 64))
      | (1ULL << (fugue_sqlParser::DFS - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORIES - 64))
      | (1ULL << (fugue_sqlParser::DIRECTORY - 64))
      | (1ULL << (fugue_sqlParser::DISTINCT - 64))
      | (1ULL << (fugue_sqlParser::DISTRIBUTE - 64))
      | (1ULL << (fugue_sqlParser::DROP - 64))
      | (1ULL << (fugue_sqlParser::ELSE - 64))
      | (1ULL << (fugue_sqlParser::END - 64))
      | (1ULL << (fugue_sqlParser::ESCAPE - 64))
      | (1ULL << (fugue_sqlParser::ESCAPED - 64))
      | (1ULL << (fugue_sqlParser::EXCHANGE - 64))
      | (1ULL << (fugue_sqlParser::EXISTS - 64))
      | (1ULL << (fugue_sqlParser::EXPLAIN - 64))
      | (1ULL << (fugue_sqlParser::EXPORT - 64))
      | (1ULL << (fugue_sqlParser::EXTENDED - 64)))) != 0) || ((((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & ((1ULL << (fugue_sqlParser::EXTERNAL - 128))
      | (1ULL << (fugue_sqlParser::EXTRACT - 128))
      | (1ULL << (fugue_sqlParser::FALSE - 128))
      | (1ULL << (fugue_sqlParser::FETCH - 128))
      | (1ULL << (fugue_sqlParser::FIELDS - 128))
      | (1ULL << (fugue_sqlParser::FILTER - 128))
      | (1ULL << (fugue_sqlParser::FILEFORMAT - 128))
      | (1ULL << (fugue_sqlParser::FIRST - 128))
      | (1ULL << (fugue_sqlParser::FOLLOWING - 128))
      | (1ULL << (fugue_sqlParser::FOR - 128))
      | (1ULL << (fugue_sqlParser::FOREIGN - 128))
      | (1ULL << (fugue_sqlParser::FORMAT - 128))
      | (1ULL << (fugue_sqlParser::FORMATTED - 128))
      | (1ULL << (fugue_sqlParser::FROM - 128))
      | (1ULL << (fugue_sqlParser::FUNCTION - 128))
      | (1ULL << (fugue_sqlParser::FUNCTIONS - 128))
      | (1ULL << (fugue_sqlParser::GLOBAL - 128))
      | (1ULL << (fugue_sqlParser::GRANT - 128))
      | (1ULL << (fugue_sqlParser::GROUP - 128))
      | (1ULL << (fugue_sqlParser::GROUPING - 128))
      | (1ULL << (fugue_sqlParser::HAVING - 128))
      | (1ULL << (fugue_sqlParser::HOUR - 128))
      | (1ULL << (fugue_sqlParser::IF - 128))
      | (1ULL << (fugue_sqlParser::IGNORE - 128))
      | (1ULL << (fugue_sqlParser::IMPORT - 128))
      | (1ULL << (fugue_sqlParser::IN - 128))
      | (1ULL << (fugue_sqlParser::INDEX - 128))
      | (1ULL << (fugue_sqlParser::INDEXES - 128))
      | (1ULL << (fugue_sqlParser::INPATH - 128))
      | (1ULL << (fugue_sqlParser::INPUTFORMAT - 128))
      | (1ULL << (fugue_sqlParser::INSERT - 128))
      | (1ULL << (fugue_sqlParser::INTERVAL - 128))
      | (1ULL << (fugue_sqlParser::INTO - 128))
      | (1ULL << (fugue_sqlParser::IS - 128))
      | (1ULL << (fugue_sqlParser::ITEMS - 128))
      | (1ULL << (fugue_sqlParser::KEYS - 128))
      | (1ULL << (fugue_sqlParser::LAST - 128))
      | (1ULL << (fugue_sqlParser::LATERAL - 128))
      | (1ULL << (fugue_sqlParser::LAZY - 128))
      | (1ULL << (fugue_sqlParser::LEADING - 128))
      | (1ULL << (fugue_sqlParser::LIKE - 128))
      | (1ULL << (fugue_sqlParser::LIMIT - 128))
      | (1ULL << (fugue_sqlParser::LINES - 128))
      | (1ULL << (fugue_sqlParser::LIST - 128))
      | (1ULL << (fugue_sqlParser::LOAD - 128))
      | (1ULL << (fugue_sqlParser::LOCAL - 128))
      | (1ULL << (fugue_sqlParser::LOCATION - 128))
      | (1ULL << (fugue_sqlParser::LOCK - 128))
      | (1ULL << (fugue_sqlParser::LOCKS - 128))
      | (1ULL << (fugue_sqlParser::LOGICAL - 128))
      | (1ULL << (fugue_sqlParser::MACRO - 128))
      | (1ULL << (fugue_sqlParser::MAP - 128))
      | (1ULL << (fugue_sqlParser::MATCHED - 128))
      | (1ULL << (fugue_sqlParser::MERGE - 128))
      | (1ULL << (fugue_sqlParser::MINUTE - 128))
      | (1ULL << (fugue_sqlParser::MONTH - 128))
      | (1ULL << (fugue_sqlParser::MSCK - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACE - 128))
      | (1ULL << (fugue_sqlParser::NAMESPACES - 128)))) != 0) || ((((_la - 193) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 193)) & ((1ULL << (fugue_sqlParser::NO - 193))
      | (1ULL << (fugue_sqlParser::NOT - 193))
      | (1ULL << (fugue_sqlParser::THENULL - 193))
      | (1ULL << (fugue_sqlParser::THENULLS - 193))
      | (1ULL << (fugue_sqlParser::OF - 193))
      | (1ULL << (fugue_sqlParser::ONLY - 193))
      | (1ULL << (fugue_sqlParser::OPTION - 193))
      | (1ULL << (fugue_sqlParser::OPTIONS - 193))
      | (1ULL << (fugue_sqlParser::OR - 193))
      | (1ULL << (fugue_sqlParser::ORDER - 193))
      | (1ULL << (fugue_sqlParser::OUT - 193))
      | (1ULL << (fugue_sqlParser::OUTER - 193))
      | (1ULL << (fugue_sqlParser::OUTPUTFORMAT - 193))
      | (1ULL << (fugue_sqlParser::OVER - 193))
      | (1ULL << (fugue_sqlParser::OVERLAPS - 193))
      | (1ULL << (fugue_sqlParser::OVERLAY - 193))
      | (1ULL << (fugue_sqlParser::OVERWRITE - 193))
      | (1ULL << (fugue_sqlParser::PARTITION - 193))
      | (1ULL << (fugue_sqlParser::PARTITIONED - 193))
      | (1ULL << (fugue_sqlParser::PARTITIONS - 193))
      | (1ULL << (fugue_sqlParser::PERCENTLIT - 193))
      | (1ULL << (fugue_sqlParser::PIVOT - 193))
      | (1ULL << (fugue_sqlParser::PLACING - 193))
      | (1ULL << (fugue_sqlParser::POSITION - 193))
      | (1ULL << (fugue_sqlParser::PRECEDING - 193))
      | (1ULL << (fugue_sqlParser::PRIMARY - 193))
      | (1ULL << (fugue_sqlParser::PRINCIPALS - 193))
      | (1ULL << (fugue_sqlParser::PROPERTIES - 193))
      | (1ULL << (fugue_sqlParser::PURGE - 193))
      | (1ULL << (fugue_sqlParser::QUERY - 193))
      | (1ULL << (fugue_sqlParser::RANGE - 193))
      | (1ULL << (fugue_sqlParser::RECORDREADER - 193))
      | (1ULL << (fugue_sqlParser::RECORDWRITER - 193))
      | (1ULL << (fugue_sqlParser::RECOVER - 193))
      | (1ULL << (fugue_sqlParser::REDUCE - 193))
      | (1ULL << (fugue_sqlParser::REFERENCES - 193))
      | (1ULL << (fugue_sqlParser::REFRESH - 193))
      | (1ULL << (fugue_sqlParser::RENAME - 193))
      | (1ULL << (fugue_sqlParser::REPAIR - 193))
      | (1ULL << (fugue_sqlParser::REPLACE - 193))
      | (1ULL << (fugue_sqlParser::RESET - 193))
      | (1ULL << (fugue_sqlParser::RESTRICT - 193))
      | (1ULL << (fugue_sqlParser::REVOKE - 193))
      | (1ULL << (fugue_sqlParser::RLIKE - 193))
      | (1ULL << (fugue_sqlParser::ROLE - 193))
      | (1ULL << (fugue_sqlParser::ROLES - 193))
      | (1ULL << (fugue_sqlParser::ROLLBACK - 193))
      | (1ULL << (fugue_sqlParser::ROLLUP - 193))
      | (1ULL << (fugue_sqlParser::ROW - 193))
      | (1ULL << (fugue_sqlParser::ROWS - 193))
      | (1ULL << (fugue_sqlParser::SCHEMA - 193))
      | (1ULL << (fugue_sqlParser::SECOND - 193))
      | (1ULL << (fugue_sqlParser::SELECT - 193))
      | (1ULL << (fugue_sqlParser::SEPARATED - 193))
      | (1ULL << (fugue_sqlParser::SERDE - 193))
      | (1ULL << (fugue_sqlParser::SERDEPROPERTIES - 193))
      | (1ULL << (fugue_sqlParser::SESSION_USER - 193))
      | (1ULL << (fugue_sqlParser::SET - 193))
      | (1ULL << (fugue_sqlParser::SETS - 193))
      | (1ULL << (fugue_sqlParser::SHOW - 193)))) != 0) || ((((_la - 257) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 257)) & ((1ULL << (fugue_sqlParser::SKEWED - 257))
      | (1ULL << (fugue_sqlParser::SOME - 257))
      | (1ULL << (fugue_sqlParser::SORT - 257))
      | (1ULL << (fugue_sqlParser::SORTED - 257))
      | (1ULL << (fugue_sqlParser::START - 257))
      | (1ULL << (fugue_sqlParser::STATISTICS - 257))
      | (1ULL << (fugue_sqlParser::STORED - 257))
      | (1ULL << (fugue_sqlParser::STRATIFY - 257))
      | (1ULL << (fugue_sqlParser::STRUCT - 257))
      | (1ULL << (fugue_sqlParser::SUBSTR - 257))
      | (1ULL << (fugue_sqlParser::SUBSTRING - 257))
      | (1ULL << (fugue_sqlParser::TABLE - 257))
      | (1ULL << (fugue_sqlParser::TABLES - 257))
      | (1ULL << (fugue_sqlParser::TABLESAMPLE - 257))
      | (1ULL << (fugue_sqlParser::TBLPROPERTIES - 257))
      | (1ULL << (fugue_sqlParser::TEMPORARY - 257))
      | (1ULL << (fugue_sqlParser::TERMINATED - 257))
      | (1ULL << (fugue_sqlParser::THEN - 257))
      | (1ULL << (fugue_sqlParser::TO - 257))
      | (1ULL << (fugue_sqlParser::TOUCH - 257))
      | (1ULL << (fugue_sqlParser::TRAILING - 257))
      | (1ULL << (fugue_sqlParser::TRANSACTION - 257))
      | (1ULL << (fugue_sqlParser::TRANSACTIONS - 257))
      | (1ULL << (fugue_sqlParser::TRANSFORM - 257))
      | (1ULL << (fugue_sqlParser::TRIM - 257))
      | (1ULL << (fugue_sqlParser::TRUE - 257))
      | (1ULL << (fugue_sqlParser::TRUNCATE - 257))
      | (1ULL << (fugue_sqlParser::TYPE - 257))
      | (1ULL << (fugue_sqlParser::UNARCHIVE - 257))
      | (1ULL << (fugue_sqlParser::UNBOUNDED - 257))
      | (1ULL << (fugue_sqlParser::UNCACHE - 257))
      | (1ULL << (fugue_sqlParser::UNIQUE - 257))
      | (1ULL << (fugue_sqlParser::UNKNOWN - 257))
      | (1ULL << (fugue_sqlParser::UNLOCK - 257))
      | (1ULL << (fugue_sqlParser::UNSET - 257))
      | (1ULL << (fugue_sqlParser::UPDATE - 257))
      | (1ULL << (fugue_sqlParser::USE - 257))
      | (1ULL << (fugue_sqlParser::USER - 257))
      | (1ULL << (fugue_sqlParser::VALUES - 257))
      | (1ULL << (fugue_sqlParser::VIEW - 257))
      | (1ULL << (fugue_sqlParser::VIEWS - 257))
      | (1ULL << (fugue_sqlParser::WHEN - 257))
      | (1ULL << (fugue_sqlParser::WHERE - 257))
      | (1ULL << (fugue_sqlParser::WINDOW - 257))
      | (1ULL << (fugue_sqlParser::WITH - 257))
      | (1ULL << (fugue_sqlParser::YEAR - 257))
      | (1ULL << (fugue_sqlParser::DIV - 257)))) != 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;
}

bool fugue_sqlParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 47: return fuguePartitionNumSempred(antlrcpp::downCast<FuguePartitionNumContext *>(context), predicateIndex);
    case 115: return queryTermSempred(antlrcpp::downCast<QueryTermContext *>(context), predicateIndex);
    case 170: return booleanExpressionSempred(antlrcpp::downCast<BooleanExpressionContext *>(context), predicateIndex);
    case 172: return valueExpressionSempred(antlrcpp::downCast<ValueExpressionContext *>(context), predicateIndex);
    case 173: return primaryExpressionSempred(antlrcpp::downCast<PrimaryExpressionContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool fugue_sqlParser::fuguePartitionNumSempred(FuguePartitionNumContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool fugue_sqlParser::queryTermSempred(QueryTermContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 1: return precpred(_ctx, 3);
    case 2: return precpred(_ctx, 2);
    case 3: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool fugue_sqlParser::booleanExpressionSempred(BooleanExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 4: return precpred(_ctx, 2);
    case 5: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool fugue_sqlParser::valueExpressionSempred(ValueExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 6: return precpred(_ctx, 6);
    case 7: return precpred(_ctx, 5);
    case 8: return precpred(_ctx, 4);
    case 9: return precpred(_ctx, 3);
    case 10: return precpred(_ctx, 2);
    case 11: return precpred(_ctx, 1);

  default:
    break;
  }
  return true;
}

bool fugue_sqlParser::primaryExpressionSempred(PrimaryExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 12: return precpred(_ctx, 8);
    case 13: return precpred(_ctx, 6);

  default:
    break;
  }
  return true;
}

void fugue_sqlParser::initialize() {
  std::call_once(fugue_sqlParserOnceFlag, fugue_sqlParserInitialize);
}
