
// Generated from fugue_sql.g4 by ANTLR 4.11.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;
};

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

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

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

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

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

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(445);
      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(449);
    _errHandler->sync(this);

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

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

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

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

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::YIELD) {
      setState(458);
      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(475);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(461);
      fugueTransformTask();
      break;
    }

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

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

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

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

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

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

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

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

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

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

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

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

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(474);
      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(477);
    match(fugue_sqlParser::TRANSFORM);
    setState(479);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 4302831616) != 0) {
      setState(481);
      antlrcpp::downCast<FugueTransformTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(484);
    antlrcpp::downCast<FugueTransformTaskContext *>(_localctx)->params = fugueSingleOutputExtensionCommonWild();
    setState(487);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {
    case 1: {
      setState(485);
      match(fugue_sqlParser::CALLBACK);
      setState(486);
      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(489);
    match(fugue_sqlParser::PROCESS);
    setState(491);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 4302831616) != 0) {
      setState(493);
      antlrcpp::downCast<FugueProcessTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(496);
    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(498);
    match(fugue_sqlParser::SAVE);
    setState(499);
    match(fugue_sqlParser::AND);
    setState(500);
    match(fugue_sqlParser::USE);
    setState(502);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 4302831616) != 0) {
      setState(504);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(507);
    antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->m = fugueSaveMode();
    setState(509);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1924145348608) != 0) {
      setState(511);
      antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->fmt = fugueFileFormat();
    }
    setState(514);
    antlrcpp::downCast<FugueSaveAndUseTaskContext *>(_localctx)->path = fuguePath();
    setState(516);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 16, _ctx)) {
    case 1: {
      setState(515);
      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(518);
    match(fugue_sqlParser::RENAME);
    setState(519);
    match(fugue_sqlParser::COLUMNS);
    setState(520);
    antlrcpp::downCast<FugueRenameColumnsTaskContext *>(_localctx)->cols = fugueRenameExpression();
    setState(523);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 17, _ctx)) {
    case 1: {
      setState(521);
      match(fugue_sqlParser::FROM);
      setState(522);
      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(525);
    match(fugue_sqlParser::ALTER);
    setState(526);
    match(fugue_sqlParser::COLUMNS);
    setState(527);
    antlrcpp::downCast<FugueAlterColumnsTaskContext *>(_localctx)->cols = fugueSchema();
    setState(530);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {
    case 1: {
      setState(528);
      match(fugue_sqlParser::FROM);
      setState(529);
      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(532);
    match(fugue_sqlParser::DROP);
    setState(533);
    match(fugue_sqlParser::COLUMNS);
    setState(534);
    antlrcpp::downCast<FugueDropColumnsTaskContext *>(_localctx)->cols = fugueCols();
    setState(537);
    _errHandler->sync(this);

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx)) {
    case 1: {
      setState(539);
      match(fugue_sqlParser::FROM);
      setState(540);
      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(543);
    match(fugue_sqlParser::DROP);
    setState(544);
    match(fugue_sqlParser::ROWS);
    setState(545);
    match(fugue_sqlParser::IF);
    setState(546);
    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(547);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::THENULL

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 22, _ctx)) {
    case 1: {
      setState(552);
      match(fugue_sqlParser::FROM);
      setState(553);
      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(556);
    match(fugue_sqlParser::FILL);
    setState(557);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::THENULL

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 23, _ctx)) {
    case 1: {
      setState(559);
      match(fugue_sqlParser::FROM);
      setState(560);
      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::PREPARTITION() {
  return getToken(fugue_sqlParser::PREPARTITION, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleTaskContext::BY() {
  return getToken(fugue_sqlParser::BY, 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);
}

fugue_sqlParser::FugueColsContext* fugue_sqlParser::FugueSampleTaskContext::fugueCols() {
  return getRuleContext<fugue_sqlParser::FugueColsContext>(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(563);
    match(fugue_sqlParser::SAMPLE);
    setState(565);
    _errHandler->sync(this);

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

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

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 27, _ctx)) {
    case 1: {
      setState(576);
      match(fugue_sqlParser::PREPARTITION);
      setState(577);
      match(fugue_sqlParser::BY);
      setState(578);
      antlrcpp::downCast<FugueSampleTaskContext *>(_localctx)->by = fugueCols();
      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(581);
    match(fugue_sqlParser::TAKE);
    setState(584);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 28, _ctx)) {
    case 1: {
      setState(582);
      antlrcpp::downCast<FugueTakeTaskContext *>(_localctx)->rows = match(fugue_sqlParser::INTEGER_VALUE);
      setState(583);
      _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(588);
    _errHandler->sync(this);

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

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

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

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

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

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

      || _la == fugue_sqlParser::THENULLS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(596);
      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(599);
    match(fugue_sqlParser::ZIP);
    setState(600);
    antlrcpp::downCast<FugueZipTaskContext *>(_localctx)->dfs = fugueDataFrames();
    setState(602);
    _errHandler->sync(this);

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

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 34, _ctx)) {
    case 1: {
      setState(608);
      match(fugue_sqlParser::PRESORT);
      setState(609);
      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(612);
    match(fugue_sqlParser::CREATE);
    setState(613);
    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(615);
    match(fugue_sqlParser::CREATE);
    setState(617);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::DATA) {
      setState(616);
      match(fugue_sqlParser::DATA);
    }
    setState(619);
    antlrcpp::downCast<FugueCreateDataTaskContext *>(_localctx)->data = fugueJsonArray();
    setState(620);
    match(fugue_sqlParser::SCHEMA);
    setState(621);
    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);
}

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

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

fugue_sqlParser::FuguePathsContext* fugue_sqlParser::FugueLoadTaskContext::fuguePaths() {
  return getRuleContext<fugue_sqlParser::FuguePathsContext>(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(623);
    match(fugue_sqlParser::LOAD);
    setState(625);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1924145348608) != 0) {
      setState(624);
      antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->fmt = fugueFileFormat();
    }
    setState(629);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::STRING: {
        setState(627);
        antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->path = fuguePath();
        break;
      }

      case fugue_sqlParser::T__0: {
        setState(628);
        antlrcpp::downCast<FugueLoadTaskContext *>(_localctx)->paths = fuguePaths();
        break;
      }

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 39, _ctx)) {
    case 1: {
      setState(634);
      match(fugue_sqlParser::COLUMNS);
      setState(635);
      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(638);
    match(fugue_sqlParser::OUTPUT);
    setState(640);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 4302831616) != 0) {
      setState(642);
      antlrcpp::downCast<FugueOutputTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(645);
    match(fugue_sqlParser::USING);
    setState(646);
    antlrcpp::downCast<FugueOutputTaskContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(648);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 67109152) != 0) {
      setState(647);
      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(675);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 49, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(650);
      match(fugue_sqlParser::PRINT);
      setState(651);
      antlrcpp::downCast<FuguePrintTaskContext *>(_localctx)->rows = match(fugue_sqlParser::INTEGER_VALUE);
      setState(652);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ROW

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

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

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

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

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

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

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

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

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TITLE) {
        setState(671);
        match(fugue_sqlParser::TITLE);
        setState(672);
        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(677);
    match(fugue_sqlParser::SAVE);
    setState(679);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 4302831616) != 0) {
      setState(681);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(684);
    antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->m = fugueSaveMode();
    setState(686);
    _errHandler->sync(this);

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1924145348608) != 0) {
      setState(688);
      antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->fmt = fugueFileFormat();
    }
    setState(691);
    antlrcpp::downCast<FugueSaveTaskContext *>(_localctx)->path = fuguePath();
    setState(693);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 67109152) != 0) {
      setState(692);
      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(695);
    match(fugue_sqlParser::OUTTRANSFORM);
    setState(697);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 4302831616) != 0) {
      setState(699);
      antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->partition = fuguePrepartition();
    }
    setState(702);
    match(fugue_sqlParser::USING);
    setState(703);
    antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(705);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 67109152) != 0) {
      setState(704);
      antlrcpp::downCast<FugueOutputTransformTaskContext *>(_localctx)->params = fugueParams();
    }
    setState(709);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::CALLBACK) {
      setState(707);
      match(fugue_sqlParser::CALLBACK);
      setState(708);
      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(712);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 58) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 58)) & -1) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 122)) & -1) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 186)) & -1) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 250)) & 1152921504606846975) != 0 || (((_la - 324) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 324)) & 98305) != 0) {
      setState(711);
      antlrcpp::downCast<FugueModuleTaskContext *>(_localctx)->assign = fugueAssignment();
    }
    setState(714);
    match(fugue_sqlParser::SUB);
    setState(716);
    _errHandler->sync(this);

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

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

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 67109152) != 0) {
      setState(720);
      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(723);
    match(fugue_sqlParser::CONNECT);
    setState(724);
    antlrcpp::downCast<FugueSqlEngineContext *>(_localctx)->fugueUsing = fugueExtension();
    setState(726);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 67109152) != 0) {
      setState(725);
      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(728);
    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(732);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 63, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(730);
      antlrcpp::downCast<FugueLoadColumnsContext *>(_localctx)->schema = fugueSchema();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(731);
      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(734);
    _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(736);
    _la = _input->LA(1);
    if (!(((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 1924145348608) != 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(738);
    match(fugue_sqlParser::STRING);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FuguePathsContext ------------------------------------------------------------------

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

std::vector<fugue_sqlParser::FuguePathContext *> fugue_sqlParser::FuguePathsContext::fuguePath() {
  return getRuleContexts<fugue_sqlParser::FuguePathContext>();
}

fugue_sqlParser::FuguePathContext* fugue_sqlParser::FuguePathsContext::fuguePath(size_t i) {
  return getRuleContext<fugue_sqlParser::FuguePathContext>(i);
}


size_t fugue_sqlParser::FuguePathsContext::getRuleIndex() const {
  return fugue_sqlParser::RuleFuguePaths;
}


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

fugue_sqlParser::FuguePathsContext* fugue_sqlParser::fuguePaths() {
  FuguePathsContext *_localctx = _tracker.createInstance<FuguePathsContext>(_ctx, getState());
  enterRule(_localctx, 60, fugue_sqlParser::RuleFuguePaths);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(740);
    match(fugue_sqlParser::T__0);
    setState(741);
    fuguePath();
    setState(746);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(742);
      match(fugue_sqlParser::T__1);
      setState(743);
      fuguePath();
      setState(748);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(749);
    match(fugue_sqlParser::T__2);
   
  }
  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, 62, fugue_sqlParser::RuleFugueCheckpoint);
  size_t _la = 0;

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

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

        case fugue_sqlParser::WEAK: {
          setState(755);
          match(fugue_sqlParser::WEAK);
          setState(756);
          match(fugue_sqlParser::CHECKPOINT);
          break;
        }

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 67109152) != 0) {
        setState(759);
        antlrcpp::downCast<FugueCheckpointWeakContext *>(_localctx)->params = fugueParams();
      }
      break;
    }

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

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STRONG) {
        setState(765);
        match(fugue_sqlParser::STRONG);
      }
      setState(768);
      match(fugue_sqlParser::CHECKPOINT);
      setState(770);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 4302831616) != 0) {
        setState(769);
        antlrcpp::downCast<FugueCheckpointStrongContext *>(_localctx)->partition = fuguePrepartition();
      }
      setState(773);
      _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 67109152) != 0) {
        setState(775);
        antlrcpp::downCast<FugueCheckpointStrongContext *>(_localctx)->params = fugueParams();
      }
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LAZY) {
        setState(778);
        match(fugue_sqlParser::LAZY);
      }
      setState(781);
      match(fugue_sqlParser::DETERMINISTIC);
      setState(782);
      match(fugue_sqlParser::CHECKPOINT);
      setState(784);
      _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 4302831616) != 0) {
        setState(786);
        antlrcpp::downCast<FugueCheckpointDeterministicContext *>(_localctx)->partition = fuguePrepartition();
      }
      setState(790);
      _errHandler->sync(this);

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 67109152) != 0) {
        setState(792);
        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, 64, fugue_sqlParser::RuleFugueCheckpointNamespace);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(797);
    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::TABLE() {
  return getToken(fugue_sqlParser::TABLE, 0);
}

tree::TerminalNode* fugue_sqlParser::FugueYieldContext::VIEW() {
  return getToken(fugue_sqlParser::VIEW, 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, 66, fugue_sqlParser::RuleFugueYield);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(814);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 82, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(799);
      match(fugue_sqlParser::YIELD);
      setState(800);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FILE || _la == fugue_sqlParser::TABLE

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

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

      default:
        break;
      }
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(806);
        match(fugue_sqlParser::LOCAL);
      }
      setState(809);
      match(fugue_sqlParser::DATAFRAME);
      setState(812);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 81, _ctx)) {
      case 1: {
        setState(810);
        match(fugue_sqlParser::AS);
        setState(811);
        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, 68, fugue_sqlParser::RuleFugueBroadcast);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(834);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 85, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFramesListContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(818);
      fugueDataFrame();
      setState(823);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(819);
          match(fugue_sqlParser::T__1);
          setState(820);
          fugueDataFrame(); 
        }
        setState(825);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 83, _ctx);
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFramesDictContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(826);
      fugueDataFramePair();
      setState(831);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(827);
          match(fugue_sqlParser::T__1);
          setState(828);
          fugueDataFramePair(); 
        }
        setState(833);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 84, _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, 72, 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(836);
    antlrcpp::downCast<FugueDataFramePairContext *>(_localctx)->key = fugueIdentifier();
    setState(837);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::T__3 || _la == fugue_sqlParser::EQUAL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(838);
    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, 74, fugue_sqlParser::RuleFugueDataFrame);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(848);
    _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(840);
        fugueIdentifier();
        setState(842);
        _errHandler->sync(this);

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

        default:
          break;
        }
        break;
      }

      case fugue_sqlParser::T__4: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueDataFrameNestedContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(844);
        match(fugue_sqlParser::T__4);
        setState(845);
        antlrcpp::downCast<FugueDataFrameNestedContext *>(_localctx)->task = fugueNestableTask();
        setState(846);
        match(fugue_sqlParser::T__5);
        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, 76, fugue_sqlParser::RuleFugueDataFrameMember);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(850);
    match(fugue_sqlParser::T__0);
    setState(853);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::INTEGER_VALUE: {
        setState(851);
        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(852);
        antlrcpp::downCast<FugueDataFrameMemberContext *>(_localctx)->key = fugueIdentifier();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    setState(855);
    match(fugue_sqlParser::T__2);
   
  }
  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, 78, fugue_sqlParser::RuleFugueAssignment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(857);
    antlrcpp::downCast<FugueAssignmentContext *>(_localctx)->varname = fugueIdentifier();
    setState(858);
    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, 80, fugue_sqlParser::RuleFugueAssignmentSign);

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

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 90, _ctx)) {
    case 1: {
      setState(867);
      match(fugue_sqlParser::SCHEMA);
      setState(868);
      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, 84, fugue_sqlParser::RuleFugueSingleOutputExtensionCommon);

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 92, _ctx)) {
    case 1: {
      setState(876);
      match(fugue_sqlParser::SCHEMA);
      setState(877);
      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, 86, fugue_sqlParser::RuleFugueExtension);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 93, _ctx)) {
    case 1: {
      setState(880);
      antlrcpp::downCast<FugueExtensionContext *>(_localctx)->domain = fugueIdentifier();
      setState(881);
      match(fugue_sqlParser::T__3);
      break;
    }

    default:
      break;
    }
    setState(885);
    fugueIdentifier();
    setState(890);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(886);
        match(fugue_sqlParser::T__6);
        setState(887);
        fugueIdentifier(); 
      }
      setState(892);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 94, _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::PERCENT() {
  return getToken(fugue_sqlParser::PERCENT, 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);
}

tree::TerminalNode* fugue_sqlParser::FugueSampleMethodContext::APPROX() {
  return getToken(fugue_sqlParser::APPROX, 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, 88, fugue_sqlParser::RuleFugueSampleMethod);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(900);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 96, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(893);
      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(894);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::PERCENTLIT || _la == fugue_sqlParser::PERCENT)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::APPROX) {
        setState(895);
        match(fugue_sqlParser::APPROX);
      }
      setState(898);
      antlrcpp::downCast<FugueSampleMethodContext *>(_localctx)->rows = match(fugue_sqlParser::INTEGER_VALUE);
      setState(899);
      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, 90, fugue_sqlParser::RuleFugueZipType);

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

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

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

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

      case fugue_sqlParser::FULL: {
        enterOuterAlt(_localctx, 5);
        setState(908);
        match(fugue_sqlParser::FULL);
        setState(909);
        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, 92, fugue_sqlParser::RuleFuguePrepartition);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 7864320) != 0) {
        setState(912);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->algo = fuguePartitionAlgo();
      }
      setState(915);
      match(fugue_sqlParser::PREPARTITION);
      setState(916);
      antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->num = fuguePartitionNum(0);
      setState(919);
      _errHandler->sync(this);

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

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

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

      default:
        break;
      }
      break;
    }

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 7864320) != 0) {
        setState(925);
        antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->algo = fuguePartitionAlgo();
      }
      setState(928);
      match(fugue_sqlParser::PREPARTITION);
      setState(929);
      match(fugue_sqlParser::BY);
      setState(930);
      antlrcpp::downCast<FuguePrepartitionContext *>(_localctx)->by = fugueCols();
      setState(933);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 102, _ctx)) {
      case 1: {
        setState(931);
        match(fugue_sqlParser::PRESORT);
        setState(932);
        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);
}

tree::TerminalNode* fugue_sqlParser::FuguePartitionAlgoContext::COARSE() {
  return getToken(fugue_sqlParser::COARSE, 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, 94, 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(937);
    _la = _input->LA(1);
    if (!(((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 7864320) != 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 = 96;
  enterRecursionRule(_localctx, 96, 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(945);
    _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(940);
        fuguePartitionNumber();
        break;
      }

      case fugue_sqlParser::T__4: {
        setState(941);
        match(fugue_sqlParser::T__4);
        setState(942);
        fuguePartitionNum(0);
        setState(943);
        match(fugue_sqlParser::T__5);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(952);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _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(947);

        if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
        setState(948);
        _la = _input->LA(1);
        if (!((((_la - 319) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 319)) & 15) != 0)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(949);
        fuguePartitionNum(2); 
      }
      setState(954);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 105, _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, 98, fugue_sqlParser::RuleFuguePartitionNumber);
  size_t _la = 0;

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

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

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

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

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

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(964);
      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, 100, fugue_sqlParser::RuleFugueParams);
  size_t _la = 0;

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

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARAMS) {
        setState(969);
        match(fugue_sqlParser::PARAMS);
      }
      setState(972);
      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, 102, fugue_sqlParser::RuleFugueCols);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(975);
    fugueColumnIdentifier();
    setState(980);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 111, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(976);
        match(fugue_sqlParser::T__1);
        setState(977);
        fugueColumnIdentifier(); 
      }
      setState(982);
      _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;
}

//----------------- 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, 104, fugue_sqlParser::RuleFugueColsSort);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(983);
    fugueColSort();
    setState(988);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(984);
        match(fugue_sqlParser::T__1);
        setState(985);
        fugueColSort(); 
      }
      setState(990);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 112, _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, 106, 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(991);
    fugueColumnIdentifier();
    setState(993);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 113, _ctx)) {
    case 1: {
      setState(992);
      _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, 108, fugue_sqlParser::RuleFugueColumnIdentifier);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(997);
    fugueRenamePair();
    setState(1002);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(998);
        match(fugue_sqlParser::T__1);
        setState(999);
        fugueRenamePair(); 
      }
      setState(1004);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 114, _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, 112, fugue_sqlParser::RuleFugueWildSchema);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1005);
    fugueWildSchemaPair();
    setState(1010);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1006);
        match(fugue_sqlParser::T__1);
        setState(1007);
        fugueWildSchemaPair(); 
      }
      setState(1012);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 115, _ctx);
    }
    setState(1016);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1013);
        fugueSchemaOp(); 
      }
      setState(1018);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 116, _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, 114, fugue_sqlParser::RuleFugueWildSchemaPair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1021);
    _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(1019);
        antlrcpp::downCast<FugueWildSchemaPairContext *>(_localctx)->pair = fugueSchemaPair();
        break;
      }

      case fugue_sqlParser::ASTERISK: {
        enterOuterAlt(_localctx, 2);
        setState(1020);
        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, 116, 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(1034);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::MINUS:
      case fugue_sqlParser::TILDE: {
        enterOuterAlt(_localctx, 1);
        setState(1023);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::MINUS

        || _la == fugue_sqlParser::TILDE)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1024);
        fugueSchemaKey();
        setState(1029);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 118, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(1025);
            match(fugue_sqlParser::T__1);
            setState(1026);
            fugueSchemaKey(); 
          }
          setState(1031);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 118, _ctx);
        }
        break;
      }

      case fugue_sqlParser::PLUS: {
        enterOuterAlt(_localctx, 2);
        setState(1032);
        match(fugue_sqlParser::PLUS);
        setState(1033);
        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, 118, fugue_sqlParser::RuleFugueSchema);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1036);
    fugueSchemaPair();
    setState(1041);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 120, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1037);
        match(fugue_sqlParser::T__1);
        setState(1038);
        fugueSchemaPair(); 
      }
      setState(1043);
      _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;
}

//----------------- 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, 120, fugue_sqlParser::RuleFugueSchemaPair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1044);
    antlrcpp::downCast<FugueSchemaPairContext *>(_localctx)->key = fugueSchemaKey();
    setState(1045);
    match(fugue_sqlParser::T__3);
    setState(1046);
    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, 122, fugue_sqlParser::RuleFugueSchemaKey);

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

tree::TerminalNode* fugue_sqlParser::FugueSchemaMapTypeContext::LT() {
  return getToken(fugue_sqlParser::LT, 0);
}

std::vector<fugue_sqlParser::FugueSchemaTypeContext *> fugue_sqlParser::FugueSchemaMapTypeContext::fugueSchemaType() {
  return getRuleContexts<fugue_sqlParser::FugueSchemaTypeContext>();
}

fugue_sqlParser::FugueSchemaTypeContext* fugue_sqlParser::FugueSchemaMapTypeContext::fugueSchemaType(size_t i) {
  return getRuleContext<fugue_sqlParser::FugueSchemaTypeContext>(i);
}

tree::TerminalNode* fugue_sqlParser::FugueSchemaMapTypeContext::GT() {
  return getToken(fugue_sqlParser::GT, 0);
}

fugue_sqlParser::FugueSchemaMapTypeContext::FugueSchemaMapTypeContext(FugueSchemaTypeContext *ctx) { copyFrom(ctx); }


std::any fugue_sqlParser::FugueSchemaMapTypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<fugue_sqlVisitor*>(visitor))
    return parserVisitor->visitFugueSchemaMapType(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, 124, fugue_sqlParser::RuleFugueSchemaType);

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

      case fugue_sqlParser::T__0: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueSchemaListTypeContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(1051);
        match(fugue_sqlParser::T__0);
        setState(1052);
        fugueSchemaType();
        setState(1053);
        match(fugue_sqlParser::T__2);
        break;
      }

      case fugue_sqlParser::T__7: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueSchemaStructTypeContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(1055);
        match(fugue_sqlParser::T__7);
        setState(1056);
        fugueSchema();
        setState(1057);
        match(fugue_sqlParser::T__8);
        break;
      }

      case fugue_sqlParser::LT: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FugueSchemaMapTypeContext>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(1059);
        match(fugue_sqlParser::LT);
        setState(1060);
        fugueSchemaType();
        setState(1061);
        match(fugue_sqlParser::T__1);
        setState(1062);
        fugueSchemaType();
        setState(1063);
        match(fugue_sqlParser::GT);
        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, 126, fugue_sqlParser::RuleFugueRenamePair);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1067);
    antlrcpp::downCast<FugueRenamePairContext *>(_localctx)->key = fugueSchemaKey();
    setState(1068);
    match(fugue_sqlParser::T__3);
    setState(1069);
    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, 128, fugue_sqlParser::RuleFugueJson);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1091);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 124, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1073);
      match(fugue_sqlParser::T__7);
      setState(1074);
      fugueJsonPairs();
      setState(1076);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__1) {
        setState(1075);
        match(fugue_sqlParser::T__1);
      }
      setState(1078);
      match(fugue_sqlParser::T__8);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1080);
      match(fugue_sqlParser::T__7);
      setState(1081);
      match(fugue_sqlParser::T__8);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1082);
      match(fugue_sqlParser::T__4);
      setState(1083);
      fugueJsonPairs();
      setState(1085);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__1) {
        setState(1084);
        match(fugue_sqlParser::T__1);
      }
      setState(1087);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1089);
      match(fugue_sqlParser::T__4);
      setState(1090);
      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;
}

//----------------- 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, 132, fugue_sqlParser::RuleFugueJsonPairs);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(1093);
    fugueJsonPair();
    setState(1098);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(1094);
        match(fugue_sqlParser::T__1);
        setState(1095);
        fugueJsonPair(); 
      }
      setState(1100);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 125, _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, 134, 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(1101);
    antlrcpp::downCast<FugueJsonPairContext *>(_localctx)->key = fugueJsonKey();
    setState(1102);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::T__3 || _la == fugue_sqlParser::EQUAL)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
    setState(1103);
    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, 136, fugue_sqlParser::RuleFugueJsonKey);

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

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 2);
        setState(1106);
        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, 138, 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(1125);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 129, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1109);
      match(fugue_sqlParser::T__0);
      setState(1110);
      fugueJsonValue();
      setState(1115);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(1111);
          match(fugue_sqlParser::T__1);
          setState(1112);
          fugueJsonValue(); 
        }
        setState(1117);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 127, _ctx);
      }
      setState(1119);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__1) {
        setState(1118);
        match(fugue_sqlParser::T__1);
      }
      setState(1121);
      match(fugue_sqlParser::T__2);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1123);
      match(fugue_sqlParser::T__0);
      setState(1124);
      match(fugue_sqlParser::T__2);
      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, 140, fugue_sqlParser::RuleFugueJsonValue);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(1133);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 1);
        setState(1127);
        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(1128);
        fugueJsonNumber();
        break;
      }

      case fugue_sqlParser::T__4:
      case fugue_sqlParser::T__7: {
        enterOuterAlt(_localctx, 3);
        setState(1129);
        fugueJsonObj();
        break;
      }

      case fugue_sqlParser::T__0: {
        enterOuterAlt(_localctx, 4);
        setState(1130);
        fugueJsonArray();
        break;
      }

      case fugue_sqlParser::T__9:
      case fugue_sqlParser::T__10:
      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::TRUE: {
        enterOuterAlt(_localctx, 5);
        setState(1131);
        fugueJsonBool();
        break;
      }

      case fugue_sqlParser::T__11:
      case fugue_sqlParser::THENULL: {
        enterOuterAlt(_localctx, 6);
        setState(1132);
        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, 142, fugue_sqlParser::RuleFugueJsonNumber);

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

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1137);
    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, 146, 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(1139);
    _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, 148, 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(1141);
    _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, 150, fugue_sqlParser::RuleFugueIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1143);
    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, 152, 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(1145);
    statement();
    setState(1149);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__12) {
      setState(1146);
      match(fugue_sqlParser::T__12);
      setState(1151);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(1152);
    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, 154, fugue_sqlParser::RuleSingleExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1154);
    namedExpression();
    setState(1155);
    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, 156, fugue_sqlParser::RuleSingleTableIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1157);
    tableIdentifier();
    setState(1158);
    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, 158, fugue_sqlParser::RuleSingleMultipartIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1160);
    multipartIdentifier();
    setState(1161);
    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, 160, fugue_sqlParser::RuleSingleFunctionIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1163);
    functionIdentifier();
    setState(1164);
    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, 162, fugue_sqlParser::RuleSingleDataType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1166);
    dataType();
    setState(1167);
    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, 164, fugue_sqlParser::RuleSingleTableSchema);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(1169);
    colTypeList();
    setState(1170);
    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, 166, 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(1877);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 237, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::StatementDefaultContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(1172);
      query();
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::WITH) {
        setState(1173);
        ctes();
      }
      setState(1176);
      dmlStatementNoWith();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::UseContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(1177);
      match(fugue_sqlParser::USE);
      setState(1179);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 133, _ctx)) {
      case 1: {
        setState(1178);
        match(fugue_sqlParser::NAMESPACE);
        break;
      }

      default:
        break;
      }
      setState(1181);
      multipartIdentifier();
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(1182);
      match(fugue_sqlParser::CREATE);
      setState(1183);
      theNamespace();
      setState(1187);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 134, _ctx)) {
      case 1: {
        setState(1184);
        match(fugue_sqlParser::IF);
        setState(1185);
        match(fugue_sqlParser::NOT);
        setState(1186);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1189);
      multipartIdentifier();
      setState(1197);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::COMMENT || _la == fugue_sqlParser::LOCATION || _la == fugue_sqlParser::WITH) {
        setState(1195);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::COMMENT: {
            setState(1190);
            commentSpec();
            break;
          }

          case fugue_sqlParser::LOCATION: {
            setState(1191);
            locationSpec();
            break;
          }

          case fugue_sqlParser::WITH: {
            setState(1192);
            match(fugue_sqlParser::WITH);
            setState(1193);
            _la = _input->LA(1);
            if (!(_la == fugue_sqlParser::DBPROPERTIES || _la == fugue_sqlParser::PROPERTIES)) {
            _errHandler->recoverInline(this);
            }
            else {
              _errHandler->reportMatch(this);
              consume();
            }
            setState(1194);
            tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1199);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetNamespacePropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(1200);
      match(fugue_sqlParser::ALTER);
      setState(1201);
      theNamespace();
      setState(1202);
      multipartIdentifier();
      setState(1203);
      match(fugue_sqlParser::SET);
      setState(1204);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DBPROPERTIES || _la == fugue_sqlParser::PROPERTIES)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1205);
      tablePropertyList();
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetNamespaceLocationContext>(_localctx);
      enterOuterAlt(_localctx, 6);
      setState(1207);
      match(fugue_sqlParser::ALTER);
      setState(1208);
      theNamespace();
      setState(1209);
      multipartIdentifier();
      setState(1210);
      match(fugue_sqlParser::SET);
      setState(1211);
      locationSpec();
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 7);
      setState(1213);
      match(fugue_sqlParser::DROP);
      setState(1214);
      theNamespace();
      setState(1217);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1219);
      multipartIdentifier();
      setState(1221);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::CASCADE || _la == fugue_sqlParser::RESTRICT) {
        setState(1220);
        _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(1223);
      match(fugue_sqlParser::SHOW);
      setState(1224);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DATABASES || _la == fugue_sqlParser::NAMESPACES)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1227);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1225);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1226);
        multipartIdentifier();
      }
      setState(1233);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LIKE || _la == fugue_sqlParser::STRING) {
        setState(1230);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::LIKE) {
          setState(1229);
          match(fugue_sqlParser::LIKE);
        }
        setState(1232);
        antlrcpp::downCast<ShowNamespacesContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateTableContext>(_localctx);
      enterOuterAlt(_localctx, 9);
      setState(1235);
      createTableHeader();
      setState(1240);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__4) {
        setState(1236);
        match(fugue_sqlParser::T__4);
        setState(1237);
        colTypeList();
        setState(1238);
        match(fugue_sqlParser::T__5);
      }
      setState(1242);
      tableProvider();
      setState(1243);
      createTableClauses();
      setState(1248);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la - 17) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 17)) & 2269395221545987) != 0 || (((_la - 99) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 99)) & 140737496743937) != 0 || (((_la - 182) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 182)) & 20266198323167361) != 0 || (((_la - 252) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 252)) & 73183502536802305) != 0) {
        setState(1245);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1244);
          match(fugue_sqlParser::AS);
        }
        setState(1247);
        query();
      }
      break;
    }

    case 10: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateHiveTableContext>(_localctx);
      enterOuterAlt(_localctx, 10);
      setState(1250);
      createTableHeader();
      setState(1255);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__4) {
        setState(1251);
        match(fugue_sqlParser::T__4);
        setState(1252);
        antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->columns = colTypeList();
        setState(1253);
        match(fugue_sqlParser::T__5);
      }
      setState(1278);
      _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 - 248) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 248)) & 269500417) != 0) {
        setState(1276);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::COMMENT: {
            setState(1257);
            commentSpec();
            break;
          }

          case fugue_sqlParser::PARTITIONED: {
            setState(1267);
            _errHandler->sync(this);
            switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 146, _ctx)) {
            case 1: {
              setState(1258);
              match(fugue_sqlParser::PARTITIONED);
              setState(1259);
              match(fugue_sqlParser::BY);
              setState(1260);
              match(fugue_sqlParser::T__4);
              setState(1261);
              antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->partitionColumns = colTypeList();
              setState(1262);
              match(fugue_sqlParser::T__5);
              break;
            }

            case 2: {
              setState(1264);
              match(fugue_sqlParser::PARTITIONED);
              setState(1265);
              match(fugue_sqlParser::BY);
              setState(1266);
              antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->partitionColumnNames = identifierList();
              break;
            }

            default:
              break;
            }
            break;
          }

          case fugue_sqlParser::CLUSTERED: {
            setState(1269);
            bucketSpec();
            break;
          }

          case fugue_sqlParser::SKEWED: {
            setState(1270);
            skewSpec();
            break;
          }

          case fugue_sqlParser::ROW: {
            setState(1271);
            rowFormat();
            break;
          }

          case fugue_sqlParser::STORED: {
            setState(1272);
            createFileFormat();
            break;
          }

          case fugue_sqlParser::LOCATION: {
            setState(1273);
            locationSpec();
            break;
          }

          case fugue_sqlParser::TBLPROPERTIES: {
            setState(1274);
            match(fugue_sqlParser::TBLPROPERTIES);
            setState(1275);
            antlrcpp::downCast<CreateHiveTableContext *>(_localctx)->tableProps = tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1280);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1285);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la - 17) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 17)) & 2269395221545987) != 0 || (((_la - 99) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 99)) & 140737496743937) != 0 || (((_la - 182) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 182)) & 20266198323167361) != 0 || (((_la - 252) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 252)) & 73183502536802305) != 0) {
        setState(1282);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1281);
          match(fugue_sqlParser::AS);
        }
        setState(1284);
        query();
      }
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateTableLikeContext>(_localctx);
      enterOuterAlt(_localctx, 11);
      setState(1287);
      match(fugue_sqlParser::CREATE);
      setState(1288);
      match(fugue_sqlParser::TABLE);
      setState(1292);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 151, _ctx)) {
      case 1: {
        setState(1289);
        match(fugue_sqlParser::IF);
        setState(1290);
        match(fugue_sqlParser::NOT);
        setState(1291);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1294);
      antlrcpp::downCast<CreateTableLikeContext *>(_localctx)->target = tableIdentifier();
      setState(1295);
      match(fugue_sqlParser::LIKE);
      setState(1296);
      antlrcpp::downCast<CreateTableLikeContext *>(_localctx)->source = tableIdentifier();
      setState(1305);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::LOCATION || (((_la - 248) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 248)) & 9007199524225025) != 0) {
        setState(1303);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::USING: {
            setState(1297);
            tableProvider();
            break;
          }

          case fugue_sqlParser::ROW: {
            setState(1298);
            rowFormat();
            break;
          }

          case fugue_sqlParser::STORED: {
            setState(1299);
            createFileFormat();
            break;
          }

          case fugue_sqlParser::LOCATION: {
            setState(1300);
            locationSpec();
            break;
          }

          case fugue_sqlParser::TBLPROPERTIES: {
            setState(1301);
            match(fugue_sqlParser::TBLPROPERTIES);
            setState(1302);
            antlrcpp::downCast<CreateTableLikeContext *>(_localctx)->tableProps = tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1307);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ReplaceTableContext>(_localctx);
      enterOuterAlt(_localctx, 12);
      setState(1308);
      replaceTableHeader();
      setState(1313);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__4) {
        setState(1309);
        match(fugue_sqlParser::T__4);
        setState(1310);
        colTypeList();
        setState(1311);
        match(fugue_sqlParser::T__5);
      }
      setState(1315);
      tableProvider();
      setState(1316);
      createTableClauses();
      setState(1321);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la - 17) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 17)) & 2269395221545987) != 0 || (((_la - 99) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 99)) & 140737496743937) != 0 || (((_la - 182) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 182)) & 20266198323167361) != 0 || (((_la - 252) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 252)) & 73183502536802305) != 0) {
        setState(1318);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1317);
          match(fugue_sqlParser::AS);
        }
        setState(1320);
        query();
      }
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AnalyzeContext>(_localctx);
      enterOuterAlt(_localctx, 13);
      setState(1323);
      match(fugue_sqlParser::ANALYZE);
      setState(1324);
      match(fugue_sqlParser::TABLE);
      setState(1325);
      multipartIdentifier();
      setState(1327);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1326);
        partitionSpec();
      }
      setState(1329);
      match(fugue_sqlParser::COMPUTE);
      setState(1330);
      match(fugue_sqlParser::STATISTICS);
      setState(1338);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 158, _ctx)) {
      case 1: {
        setState(1331);
        identifier();
        break;
      }

      case 2: {
        setState(1332);
        match(fugue_sqlParser::FOR);
        setState(1333);
        match(fugue_sqlParser::COLUMNS);
        setState(1334);
        identifierSeq();
        break;
      }

      case 3: {
        setState(1335);
        match(fugue_sqlParser::FOR);
        setState(1336);
        match(fugue_sqlParser::ALL);
        setState(1337);
        match(fugue_sqlParser::COLUMNS);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AddTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 14);
      setState(1340);
      match(fugue_sqlParser::ALTER);
      setState(1341);
      match(fugue_sqlParser::TABLE);
      setState(1342);
      multipartIdentifier();
      setState(1343);
      match(fugue_sqlParser::ADD);
      setState(1344);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1345);
      antlrcpp::downCast<AddTableColumnsContext *>(_localctx)->columns = qualifiedColTypeWithPositionList();
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AddTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 15);
      setState(1347);
      match(fugue_sqlParser::ALTER);
      setState(1348);
      match(fugue_sqlParser::TABLE);
      setState(1349);
      multipartIdentifier();
      setState(1350);
      match(fugue_sqlParser::ADD);
      setState(1351);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1352);
      match(fugue_sqlParser::T__4);
      setState(1353);
      antlrcpp::downCast<AddTableColumnsContext *>(_localctx)->columns = qualifiedColTypeWithPositionList();
      setState(1354);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RenameTableColumnContext>(_localctx);
      enterOuterAlt(_localctx, 16);
      setState(1356);
      match(fugue_sqlParser::ALTER);
      setState(1357);
      match(fugue_sqlParser::TABLE);
      setState(1358);
      antlrcpp::downCast<RenameTableColumnContext *>(_localctx)->table = multipartIdentifier();
      setState(1359);
      match(fugue_sqlParser::RENAME);
      setState(1360);
      match(fugue_sqlParser::COLUMN);
      setState(1361);
      antlrcpp::downCast<RenameTableColumnContext *>(_localctx)->ifrom = multipartIdentifier();
      setState(1362);
      match(fugue_sqlParser::TO);
      setState(1363);
      antlrcpp::downCast<RenameTableColumnContext *>(_localctx)->to = errorCapturingIdentifier();
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 17);
      setState(1365);
      match(fugue_sqlParser::ALTER);
      setState(1366);
      match(fugue_sqlParser::TABLE);
      setState(1367);
      multipartIdentifier();
      setState(1368);
      match(fugue_sqlParser::DROP);
      setState(1369);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1370);
      match(fugue_sqlParser::T__4);
      setState(1371);
      antlrcpp::downCast<DropTableColumnsContext *>(_localctx)->columns = multipartIdentifierList();
      setState(1372);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTableColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 18);
      setState(1374);
      match(fugue_sqlParser::ALTER);
      setState(1375);
      match(fugue_sqlParser::TABLE);
      setState(1376);
      multipartIdentifier();
      setState(1377);
      match(fugue_sqlParser::DROP);
      setState(1378);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::COLUMN

      || _la == fugue_sqlParser::COLUMNS)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1379);
      antlrcpp::downCast<DropTableColumnsContext *>(_localctx)->columns = multipartIdentifierList();
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RenameTableContext>(_localctx);
      enterOuterAlt(_localctx, 19);
      setState(1381);
      match(fugue_sqlParser::ALTER);
      setState(1382);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1383);
      antlrcpp::downCast<RenameTableContext *>(_localctx)->ifrom = multipartIdentifier();
      setState(1384);
      match(fugue_sqlParser::RENAME);
      setState(1385);
      match(fugue_sqlParser::TO);
      setState(1386);
      antlrcpp::downCast<RenameTableContext *>(_localctx)->to = multipartIdentifier();
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTablePropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 20);
      setState(1388);
      match(fugue_sqlParser::ALTER);
      setState(1389);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1390);
      multipartIdentifier();
      setState(1391);
      match(fugue_sqlParser::SET);
      setState(1392);
      match(fugue_sqlParser::TBLPROPERTIES);
      setState(1393);
      tablePropertyList();
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<fugue_sqlParser::UnsetTablePropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 21);
      setState(1395);
      match(fugue_sqlParser::ALTER);
      setState(1396);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1397);
      multipartIdentifier();
      setState(1398);
      match(fugue_sqlParser::UNSET);
      setState(1399);
      match(fugue_sqlParser::TBLPROPERTIES);
      setState(1402);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(1400);
        match(fugue_sqlParser::IF);
        setState(1401);
        match(fugue_sqlParser::EXISTS);
      }
      setState(1404);
      tablePropertyList();
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AlterTableAlterColumnContext>(_localctx);
      enterOuterAlt(_localctx, 22);
      setState(1406);
      match(fugue_sqlParser::ALTER);
      setState(1407);
      match(fugue_sqlParser::TABLE);
      setState(1408);
      antlrcpp::downCast<AlterTableAlterColumnContext *>(_localctx)->table = multipartIdentifier();
      setState(1409);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::ALTER

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 160, _ctx)) {
      case 1: {
        setState(1410);
        match(fugue_sqlParser::COLUMN);
        break;
      }

      default:
        break;
      }
      setState(1413);
      antlrcpp::downCast<AlterTableAlterColumnContext *>(_localctx)->column = multipartIdentifier();
      setState(1415);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AFTER || (((_la - 91) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 91)) & 562952100904961) != 0 || _la == fugue_sqlParser::SET

      || _la == fugue_sqlParser::TYPE) {
        setState(1414);
        alterColumnAction();
      }
      break;
    }

    case 23: {
      _localctx = _tracker.createInstance<fugue_sqlParser::HiveChangeColumnContext>(_localctx);
      enterOuterAlt(_localctx, 23);
      setState(1417);
      match(fugue_sqlParser::ALTER);
      setState(1418);
      match(fugue_sqlParser::TABLE);
      setState(1419);
      antlrcpp::downCast<HiveChangeColumnContext *>(_localctx)->table = multipartIdentifier();
      setState(1421);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1420);
        partitionSpec();
      }
      setState(1423);
      match(fugue_sqlParser::CHANGE);
      setState(1425);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 163, _ctx)) {
      case 1: {
        setState(1424);
        match(fugue_sqlParser::COLUMN);
        break;
      }

      default:
        break;
      }
      setState(1427);
      antlrcpp::downCast<HiveChangeColumnContext *>(_localctx)->colName = multipartIdentifier();
      setState(1428);
      colType();
      setState(1430);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AFTER || _la == fugue_sqlParser::FIRST) {
        setState(1429);
        colPosition();
      }
      break;
    }

    case 24: {
      _localctx = _tracker.createInstance<fugue_sqlParser::HiveReplaceColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 24);
      setState(1432);
      match(fugue_sqlParser::ALTER);
      setState(1433);
      match(fugue_sqlParser::TABLE);
      setState(1434);
      antlrcpp::downCast<HiveReplaceColumnsContext *>(_localctx)->table = multipartIdentifier();
      setState(1436);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1435);
        partitionSpec();
      }
      setState(1438);
      match(fugue_sqlParser::REPLACE);
      setState(1439);
      match(fugue_sqlParser::COLUMNS);
      setState(1440);
      match(fugue_sqlParser::T__4);
      setState(1441);
      antlrcpp::downCast<HiveReplaceColumnsContext *>(_localctx)->columns = qualifiedColTypeWithPositionList();
      setState(1442);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 25: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTableSerDeContext>(_localctx);
      enterOuterAlt(_localctx, 25);
      setState(1444);
      match(fugue_sqlParser::ALTER);
      setState(1445);
      match(fugue_sqlParser::TABLE);
      setState(1446);
      multipartIdentifier();
      setState(1448);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1447);
        partitionSpec();
      }
      setState(1450);
      match(fugue_sqlParser::SET);
      setState(1451);
      match(fugue_sqlParser::SERDE);
      setState(1452);
      match(fugue_sqlParser::STRING);
      setState(1456);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::WITH) {
        setState(1453);
        match(fugue_sqlParser::WITH);
        setState(1454);
        match(fugue_sqlParser::SERDEPROPERTIES);
        setState(1455);
        tablePropertyList();
      }
      break;
    }

    case 26: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTableSerDeContext>(_localctx);
      enterOuterAlt(_localctx, 26);
      setState(1458);
      match(fugue_sqlParser::ALTER);
      setState(1459);
      match(fugue_sqlParser::TABLE);
      setState(1460);
      multipartIdentifier();
      setState(1462);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1461);
        partitionSpec();
      }
      setState(1464);
      match(fugue_sqlParser::SET);
      setState(1465);
      match(fugue_sqlParser::SERDEPROPERTIES);
      setState(1466);
      tablePropertyList();
      break;
    }

    case 27: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AddTablePartitionContext>(_localctx);
      enterOuterAlt(_localctx, 27);
      setState(1468);
      match(fugue_sqlParser::ALTER);
      setState(1469);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1470);
      multipartIdentifier();
      setState(1471);
      match(fugue_sqlParser::ADD);
      setState(1475);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(1472);
        match(fugue_sqlParser::IF);
        setState(1473);
        match(fugue_sqlParser::NOT);
        setState(1474);
        match(fugue_sqlParser::EXISTS);
      }
      setState(1478); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(1477);
        partitionSpecLocation();
        setState(1480); 
        _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(1482);
      match(fugue_sqlParser::ALTER);
      setState(1483);
      match(fugue_sqlParser::TABLE);
      setState(1484);
      multipartIdentifier();
      setState(1485);
      antlrcpp::downCast<RenameTablePartitionContext *>(_localctx)->ifrom = partitionSpec();
      setState(1486);
      match(fugue_sqlParser::RENAME);
      setState(1487);
      match(fugue_sqlParser::TO);
      setState(1488);
      antlrcpp::downCast<RenameTablePartitionContext *>(_localctx)->to = partitionSpec();
      break;
    }

    case 29: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTablePartitionsContext>(_localctx);
      enterOuterAlt(_localctx, 29);
      setState(1490);
      match(fugue_sqlParser::ALTER);
      setState(1491);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::TABLE

      || _la == fugue_sqlParser::VIEW)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1492);
      multipartIdentifier();
      setState(1493);
      match(fugue_sqlParser::DROP);
      setState(1496);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(1494);
        match(fugue_sqlParser::IF);
        setState(1495);
        match(fugue_sqlParser::EXISTS);
      }
      setState(1498);
      partitionSpec();
      setState(1503);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(1499);
        match(fugue_sqlParser::T__1);
        setState(1500);
        partitionSpec();
        setState(1505);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1507);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PURGE) {
        setState(1506);
        match(fugue_sqlParser::PURGE);
      }
      break;
    }

    case 30: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetTableLocationContext>(_localctx);
      enterOuterAlt(_localctx, 30);
      setState(1509);
      match(fugue_sqlParser::ALTER);
      setState(1510);
      match(fugue_sqlParser::TABLE);
      setState(1511);
      multipartIdentifier();
      setState(1513);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1512);
        partitionSpec();
      }
      setState(1515);
      match(fugue_sqlParser::SET);
      setState(1516);
      locationSpec();
      break;
    }

    case 31: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RecoverPartitionsContext>(_localctx);
      enterOuterAlt(_localctx, 31);
      setState(1518);
      match(fugue_sqlParser::ALTER);
      setState(1519);
      match(fugue_sqlParser::TABLE);
      setState(1520);
      multipartIdentifier();
      setState(1521);
      match(fugue_sqlParser::RECOVER);
      setState(1522);
      match(fugue_sqlParser::PARTITIONS);
      break;
    }

    case 32: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropTableContext>(_localctx);
      enterOuterAlt(_localctx, 32);
      setState(1524);
      match(fugue_sqlParser::DROP);
      setState(1525);
      match(fugue_sqlParser::TABLE);
      setState(1528);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1530);
      multipartIdentifier();
      setState(1532);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PURGE) {
        setState(1531);
        match(fugue_sqlParser::PURGE);
      }
      break;
    }

    case 33: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropViewContext>(_localctx);
      enterOuterAlt(_localctx, 33);
      setState(1534);
      match(fugue_sqlParser::DROP);
      setState(1535);
      match(fugue_sqlParser::VIEW);
      setState(1538);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1540);
      multipartIdentifier();
      break;
    }

    case 34: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateViewContext>(_localctx);
      enterOuterAlt(_localctx, 34);
      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(1550);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::GLOBAL || _la == fugue_sqlParser::TEMPORARY) {
        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(1552);
      match(fugue_sqlParser::VIEW);
      setState(1556);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 181, _ctx)) {
      case 1: {
        setState(1553);
        match(fugue_sqlParser::IF);
        setState(1554);
        match(fugue_sqlParser::NOT);
        setState(1555);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1558);
      multipartIdentifier();
      setState(1560);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__4) {
        setState(1559);
        identifierCommentList();
      }
      setState(1570);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::COMMENT || _la == fugue_sqlParser::PARTITIONED

      || _la == fugue_sqlParser::TBLPROPERTIES) {
        setState(1568);
        _errHandler->sync(this);
        switch (_input->LA(1)) {
          case fugue_sqlParser::COMMENT: {
            setState(1562);
            commentSpec();
            break;
          }

          case fugue_sqlParser::PARTITIONED: {
            setState(1563);
            match(fugue_sqlParser::PARTITIONED);
            setState(1564);
            match(fugue_sqlParser::ON);
            setState(1565);
            identifierList();
            break;
          }

          case fugue_sqlParser::TBLPROPERTIES: {
            setState(1566);
            match(fugue_sqlParser::TBLPROPERTIES);
            setState(1567);
            tablePropertyList();
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(1572);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(1573);
      match(fugue_sqlParser::AS);
      setState(1574);
      query();
      break;
    }

    case 35: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateTempViewUsingContext>(_localctx);
      enterOuterAlt(_localctx, 35);
      setState(1576);
      match(fugue_sqlParser::CREATE);
      setState(1579);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OR) {
        setState(1577);
        match(fugue_sqlParser::OR);
        setState(1578);
        match(fugue_sqlParser::REPLACE);
      }
      setState(1582);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::GLOBAL) {
        setState(1581);
        match(fugue_sqlParser::GLOBAL);
      }
      setState(1584);
      match(fugue_sqlParser::TEMPORARY);
      setState(1585);
      match(fugue_sqlParser::VIEW);
      setState(1586);
      tableIdentifier();
      setState(1591);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__4) {
        setState(1587);
        match(fugue_sqlParser::T__4);
        setState(1588);
        colTypeList();
        setState(1589);
        match(fugue_sqlParser::T__5);
      }
      setState(1593);
      tableProvider();
      setState(1596);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OPTIONS) {
        setState(1594);
        match(fugue_sqlParser::OPTIONS);
        setState(1595);
        tablePropertyList();
      }
      break;
    }

    case 36: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AlterViewQueryContext>(_localctx);
      enterOuterAlt(_localctx, 36);
      setState(1598);
      match(fugue_sqlParser::ALTER);
      setState(1599);
      match(fugue_sqlParser::VIEW);
      setState(1600);
      multipartIdentifier();
      setState(1602);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AS) {
        setState(1601);
        match(fugue_sqlParser::AS);
      }
      setState(1604);
      query();
      break;
    }

    case 37: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CreateFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 37);
      setState(1606);
      match(fugue_sqlParser::CREATE);
      setState(1609);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OR) {
        setState(1607);
        match(fugue_sqlParser::OR);
        setState(1608);
        match(fugue_sqlParser::REPLACE);
      }
      setState(1612);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TEMPORARY) {
        setState(1611);
        match(fugue_sqlParser::TEMPORARY);
      }
      setState(1614);
      match(fugue_sqlParser::FUNCTION);
      setState(1618);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 192, _ctx)) {
      case 1: {
        setState(1615);
        match(fugue_sqlParser::IF);
        setState(1616);
        match(fugue_sqlParser::NOT);
        setState(1617);
        match(fugue_sqlParser::EXISTS);
        break;
      }

      default:
        break;
      }
      setState(1620);
      multipartIdentifier();
      setState(1621);
      match(fugue_sqlParser::AS);
      setState(1622);
      antlrcpp::downCast<CreateFunctionContext *>(_localctx)->className = match(fugue_sqlParser::STRING);
      setState(1632);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::USING) {
        setState(1623);
        match(fugue_sqlParser::USING);
        setState(1624);
        resource();
        setState(1629);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(1625);
          match(fugue_sqlParser::T__1);
          setState(1626);
          resource();
          setState(1631);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      break;
    }

    case 38: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DropFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 38);
      setState(1634);
      match(fugue_sqlParser::DROP);
      setState(1636);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::TEMPORARY) {
        setState(1635);
        match(fugue_sqlParser::TEMPORARY);
      }
      setState(1638);
      match(fugue_sqlParser::FUNCTION);
      setState(1641);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1643);
      multipartIdentifier();
      break;
    }

    case 39: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ExplainContext>(_localctx);
      enterOuterAlt(_localctx, 39);
      setState(1644);
      match(fugue_sqlParser::EXPLAIN);
      setState(1646);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la - 86) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 86)) & 576531121047605249) != 0 || _la == fugue_sqlParser::LOGICAL) {
        setState(1645);
        _la = _input->LA(1);
        if (!((((_la - 86) & ~ 0x3fULL) == 0) &&
          ((1ULL << (_la - 86)) & 576531121047605249) != 0 || _la == fugue_sqlParser::LOGICAL)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
      }
      setState(1648);
      statement();
      break;
    }

    case 40: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowTablesContext>(_localctx);
      enterOuterAlt(_localctx, 40);
      setState(1649);
      match(fugue_sqlParser::SHOW);
      setState(1650);
      match(fugue_sqlParser::TABLES);
      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);
        multipartIdentifier();
      }
      setState(1659);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LIKE || _la == fugue_sqlParser::STRING) {
        setState(1656);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::LIKE) {
          setState(1655);
          match(fugue_sqlParser::LIKE);
        }
        setState(1658);
        antlrcpp::downCast<ShowTablesContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 41: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowTableContext>(_localctx);
      enterOuterAlt(_localctx, 41);
      setState(1661);
      match(fugue_sqlParser::SHOW);
      setState(1662);
      match(fugue_sqlParser::TABLE);
      setState(1663);
      match(fugue_sqlParser::EXTENDED);
      setState(1666);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1664);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1665);
        antlrcpp::downCast<ShowTableContext *>(_localctx)->ns = multipartIdentifier();
      }
      setState(1668);
      match(fugue_sqlParser::LIKE);
      setState(1669);
      antlrcpp::downCast<ShowTableContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      setState(1671);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1670);
        partitionSpec();
      }
      break;
    }

    case 42: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowTblPropertiesContext>(_localctx);
      enterOuterAlt(_localctx, 42);
      setState(1673);
      match(fugue_sqlParser::SHOW);
      setState(1674);
      match(fugue_sqlParser::TBLPROPERTIES);
      setState(1675);
      antlrcpp::downCast<ShowTblPropertiesContext *>(_localctx)->table = multipartIdentifier();
      setState(1680);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__4) {
        setState(1676);
        match(fugue_sqlParser::T__4);
        setState(1677);
        antlrcpp::downCast<ShowTblPropertiesContext *>(_localctx)->key = tablePropertyKey();
        setState(1678);
        match(fugue_sqlParser::T__5);
      }
      break;
    }

    case 43: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowColumnsContext>(_localctx);
      enterOuterAlt(_localctx, 43);
      setState(1682);
      match(fugue_sqlParser::SHOW);
      setState(1683);
      match(fugue_sqlParser::COLUMNS);
      setState(1684);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1685);
      antlrcpp::downCast<ShowColumnsContext *>(_localctx)->table = multipartIdentifier();
      setState(1688);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1686);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1687);
        antlrcpp::downCast<ShowColumnsContext *>(_localctx)->ns = multipartIdentifier();
      }
      break;
    }

    case 44: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowViewsContext>(_localctx);
      enterOuterAlt(_localctx, 44);
      setState(1690);
      match(fugue_sqlParser::SHOW);
      setState(1691);
      match(fugue_sqlParser::VIEWS);
      setState(1694);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FROM

      || _la == fugue_sqlParser::IN) {
        setState(1692);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::FROM

        || _la == fugue_sqlParser::IN)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(1693);
        multipartIdentifier();
      }
      setState(1700);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LIKE || _la == fugue_sqlParser::STRING) {
        setState(1697);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::LIKE) {
          setState(1696);
          match(fugue_sqlParser::LIKE);
        }
        setState(1699);
        antlrcpp::downCast<ShowViewsContext *>(_localctx)->pattern = match(fugue_sqlParser::STRING);
      }
      break;
    }

    case 45: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowPartitionsContext>(_localctx);
      enterOuterAlt(_localctx, 45);
      setState(1702);
      match(fugue_sqlParser::SHOW);
      setState(1703);
      match(fugue_sqlParser::PARTITIONS);
      setState(1704);
      multipartIdentifier();
      setState(1706);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1705);
        partitionSpec();
      }
      break;
    }

    case 46: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowFunctionsContext>(_localctx);
      enterOuterAlt(_localctx, 46);
      setState(1708);
      match(fugue_sqlParser::SHOW);
      setState(1710);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 209, _ctx)) {
      case 1: {
        setState(1709);
        identifier();
        break;
      }

      default:
        break;
      }
      setState(1712);
      match(fugue_sqlParser::FUNCTIONS);
      setState(1720);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la - 58) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 58)) & -1) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 122)) & -1) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 186)) & -1) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 250)) & 1152921504606846975) != 0 || (((_la - 324) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 324)) & 98369) != 0) {
        setState(1714);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 210, _ctx)) {
        case 1: {
          setState(1713);
          match(fugue_sqlParser::LIKE);
          break;
        }

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

          case fugue_sqlParser::STRING: {
            setState(1717);
            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(1722);
      match(fugue_sqlParser::SHOW);
      setState(1723);
      match(fugue_sqlParser::CREATE);
      setState(1724);
      match(fugue_sqlParser::TABLE);
      setState(1725);
      multipartIdentifier();
      setState(1728);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::AS) {
        setState(1726);
        match(fugue_sqlParser::AS);
        setState(1727);
        match(fugue_sqlParser::SERDE);
      }
      break;
    }

    case 48: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ShowCurrentNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 48);
      setState(1730);
      match(fugue_sqlParser::SHOW);
      setState(1731);
      match(fugue_sqlParser::CURRENT);
      setState(1732);
      match(fugue_sqlParser::NAMESPACE);
      break;
    }

    case 49: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 49);
      setState(1733);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

      || _la == fugue_sqlParser::DESCRIBE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1734);
      match(fugue_sqlParser::FUNCTION);
      setState(1736);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 214, _ctx)) {
      case 1: {
        setState(1735);
        match(fugue_sqlParser::EXTENDED);
        break;
      }

      default:
        break;
      }
      setState(1738);
      describeFuncName();
      break;
    }

    case 50: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 50);
      setState(1739);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

      || _la == fugue_sqlParser::DESCRIBE)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(1740);
      theNamespace();
      setState(1742);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 215, _ctx)) {
      case 1: {
        setState(1741);
        match(fugue_sqlParser::EXTENDED);
        break;
      }

      default:
        break;
      }
      setState(1744);
      multipartIdentifier();
      break;
    }

    case 51: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeRelationContext>(_localctx);
      enterOuterAlt(_localctx, 51);
      setState(1746);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 216, _ctx)) {
      case 1: {
        setState(1747);
        match(fugue_sqlParser::TABLE);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 217, _ctx)) {
      case 1: {
        setState(1750);
        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(1753);
      multipartIdentifier();
      setState(1755);
      _errHandler->sync(this);

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

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

      _la = _input->LA(1);
      if ((((_la - 58) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 58)) & -1) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 122)) & -1) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 186)) & -1) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 250)) & 1152921504606846975) != 0 || (((_la - 324) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 324)) & 98305) != 0) {
        setState(1757);
        describeColName();
      }
      break;
    }

    case 52: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DescribeQueryContext>(_localctx);
      enterOuterAlt(_localctx, 52);
      setState(1760);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::DESC

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::QUERY) {
        setState(1761);
        match(fugue_sqlParser::QUERY);
      }
      setState(1764);
      query();
      break;
    }

    case 53: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CommentNamespaceContext>(_localctx);
      enterOuterAlt(_localctx, 53);
      setState(1765);
      match(fugue_sqlParser::COMMENT);
      setState(1766);
      match(fugue_sqlParser::ON);
      setState(1767);
      theNamespace();
      setState(1768);
      multipartIdentifier();
      setState(1769);
      match(fugue_sqlParser::IS);
      setState(1770);
      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(1772);
      match(fugue_sqlParser::COMMENT);
      setState(1773);
      match(fugue_sqlParser::ON);
      setState(1774);
      match(fugue_sqlParser::TABLE);
      setState(1775);
      multipartIdentifier();
      setState(1776);
      match(fugue_sqlParser::IS);
      setState(1777);
      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(1779);
      match(fugue_sqlParser::REFRESH);
      setState(1780);
      match(fugue_sqlParser::TABLE);
      setState(1781);
      multipartIdentifier();
      break;
    }

    case 56: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RefreshResourceContext>(_localctx);
      enterOuterAlt(_localctx, 56);
      setState(1782);
      match(fugue_sqlParser::REFRESH);
      setState(1790);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 222, _ctx)) {
      case 1: {
        setState(1783);
        match(fugue_sqlParser::STRING);
        break;
      }

      case 2: {
        setState(1787);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 221, _ctx);
        while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1 + 1) {
            setState(1784);
            matchWildcard(); 
          }
          setState(1789);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 221, _ctx);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 57: {
      _localctx = _tracker.createInstance<fugue_sqlParser::CacheTableContext>(_localctx);
      enterOuterAlt(_localctx, 57);
      setState(1792);
      match(fugue_sqlParser::CACHE);
      setState(1794);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LAZY) {
        setState(1793);
        match(fugue_sqlParser::LAZY);
      }
      setState(1796);
      match(fugue_sqlParser::TABLE);
      setState(1797);
      multipartIdentifier();
      setState(1800);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OPTIONS) {
        setState(1798);
        match(fugue_sqlParser::OPTIONS);
        setState(1799);
        antlrcpp::downCast<CacheTableContext *>(_localctx)->options = tablePropertyList();
      }
      setState(1806);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if ((((_la - 17) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 17)) & 2269395221545987) != 0 || (((_la - 99) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 99)) & 140737496743937) != 0 || (((_la - 182) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 182)) & 20266198323167361) != 0 || (((_la - 252) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 252)) & 73183502536802305) != 0) {
        setState(1803);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::AS) {
          setState(1802);
          match(fugue_sqlParser::AS);
        }
        setState(1805);
        query();
      }
      break;
    }

    case 58: {
      _localctx = _tracker.createInstance<fugue_sqlParser::UncacheTableContext>(_localctx);
      enterOuterAlt(_localctx, 58);
      setState(1808);
      match(fugue_sqlParser::UNCACHE);
      setState(1809);
      match(fugue_sqlParser::TABLE);
      setState(1812);
      _errHandler->sync(this);

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

      default:
        break;
      }
      setState(1814);
      multipartIdentifier();
      break;
    }

    case 59: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ClearCacheContext>(_localctx);
      enterOuterAlt(_localctx, 59);
      setState(1815);
      match(fugue_sqlParser::CLEAR);
      setState(1816);
      match(fugue_sqlParser::CACHE);
      break;
    }

    case 60: {
      _localctx = _tracker.createInstance<fugue_sqlParser::LoadDataContext>(_localctx);
      enterOuterAlt(_localctx, 60);
      setState(1817);
      match(fugue_sqlParser::LOAD);
      setState(1818);
      match(fugue_sqlParser::DATA);
      setState(1820);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(1819);
        match(fugue_sqlParser::LOCAL);
      }
      setState(1822);
      match(fugue_sqlParser::INPATH);
      setState(1823);
      antlrcpp::downCast<LoadDataContext *>(_localctx)->path = match(fugue_sqlParser::STRING);
      setState(1825);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OVERWRITE) {
        setState(1824);
        match(fugue_sqlParser::OVERWRITE);
      }
      setState(1827);
      match(fugue_sqlParser::INTO);
      setState(1828);
      match(fugue_sqlParser::TABLE);
      setState(1829);
      multipartIdentifier();
      setState(1831);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1830);
        partitionSpec();
      }
      break;
    }

    case 61: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TruncateTableContext>(_localctx);
      enterOuterAlt(_localctx, 61);
      setState(1833);
      match(fugue_sqlParser::TRUNCATE);
      setState(1834);
      match(fugue_sqlParser::TABLE);
      setState(1835);
      multipartIdentifier();
      setState(1837);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(1836);
        partitionSpec();
      }
      break;
    }

    case 62: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RepairTableContext>(_localctx);
      enterOuterAlt(_localctx, 62);
      setState(1839);
      match(fugue_sqlParser::MSCK);
      setState(1840);
      match(fugue_sqlParser::REPAIR);
      setState(1841);
      match(fugue_sqlParser::TABLE);
      setState(1842);
      multipartIdentifier();
      break;
    }

    case 63: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ManageResourceContext>(_localctx);
      enterOuterAlt(_localctx, 63);
      setState(1843);
      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(1844);
      identifier();
      setState(1852);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 233, _ctx)) {
      case 1: {
        setState(1845);
        match(fugue_sqlParser::STRING);
        break;
      }

      case 2: {
        setState(1849);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 232, _ctx);
        while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1 + 1) {
            setState(1846);
            matchWildcard(); 
          }
          setState(1851);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 232, _ctx);
        }
        break;
      }

      default:
        break;
      }
      break;
    }

    case 64: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FailNativeCommandContext>(_localctx);
      enterOuterAlt(_localctx, 64);
      setState(1854);
      match(fugue_sqlParser::SET);
      setState(1855);
      match(fugue_sqlParser::ROLE);
      setState(1859);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx);
      while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1 + 1) {
          setState(1856);
          matchWildcard(); 
        }
        setState(1861);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 234, _ctx);
      }
      break;
    }

    case 65: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SetConfigurationContext>(_localctx);
      enterOuterAlt(_localctx, 65);
      setState(1862);
      match(fugue_sqlParser::SET);
      setState(1866);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 235, _ctx);
      while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1 + 1) {
          setState(1863);
          matchWildcard(); 
        }
        setState(1868);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 235, _ctx);
      }
      break;
    }

    case 66: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ResetConfigurationContext>(_localctx);
      enterOuterAlt(_localctx, 66);
      setState(1869);
      match(fugue_sqlParser::RESET);
      break;
    }

    case 67: {
      _localctx = _tracker.createInstance<fugue_sqlParser::FailNativeCommandContext>(_localctx);
      enterOuterAlt(_localctx, 67);
      setState(1870);
      unsupportedHiveNativeCommands();
      setState(1874);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 236, _ctx);
      while (alt != 1 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1 + 1) {
          setState(1871);
          matchWildcard(); 
        }
        setState(1876);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 236, _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, 168, fugue_sqlParser::RuleUnsupportedHiveNativeCommands);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2047);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 245, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(1879);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::CREATE);
      setState(1880);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(1881);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DROP);
      setState(1882);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(1883);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::GRANT);
      setState(1885);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 238, _ctx)) {
      case 1: {
        setState(1884);
        antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(1887);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::REVOKE);
      setState(1889);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 239, _ctx)) {
      case 1: {
        setState(1888);
        antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(1891);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1892);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::GRANT);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(1893);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1894);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLE);
      setState(1896);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 240, _ctx)) {
      case 1: {
        setState(1895);
        antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::GRANT);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(1898);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1899);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::PRINCIPALS);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(1900);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1901);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::ROLES);
      break;
    }

    case 9: {
      enterOuterAlt(_localctx, 9);
      setState(1902);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1903);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::CURRENT);
      setState(1904);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::ROLES);
      break;
    }

    case 10: {
      enterOuterAlt(_localctx, 10);
      setState(1905);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::EXPORT);
      setState(1906);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 11: {
      enterOuterAlt(_localctx, 11);
      setState(1907);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::IMPORT);
      setState(1908);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 12: {
      enterOuterAlt(_localctx, 12);
      setState(1909);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1910);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::COMPACTIONS);
      break;
    }

    case 13: {
      enterOuterAlt(_localctx, 13);
      setState(1911);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1912);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::CREATE);
      setState(1913);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 14: {
      enterOuterAlt(_localctx, 14);
      setState(1914);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1915);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TRANSACTIONS);
      break;
    }

    case 15: {
      enterOuterAlt(_localctx, 15);
      setState(1916);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1917);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEXES);
      break;
    }

    case 16: {
      enterOuterAlt(_localctx, 16);
      setState(1918);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::SHOW);
      setState(1919);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::LOCKS);
      break;
    }

    case 17: {
      enterOuterAlt(_localctx, 17);
      setState(1920);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::CREATE);
      setState(1921);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEX);
      break;
    }

    case 18: {
      enterOuterAlt(_localctx, 18);
      setState(1922);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DROP);
      setState(1923);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEX);
      break;
    }

    case 19: {
      enterOuterAlt(_localctx, 19);
      setState(1924);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1925);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::INDEX);
      break;
    }

    case 20: {
      enterOuterAlt(_localctx, 20);
      setState(1926);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::LOCK);
      setState(1927);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 21: {
      enterOuterAlt(_localctx, 21);
      setState(1928);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::LOCK);
      setState(1929);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::DATABASE);
      break;
    }

    case 22: {
      enterOuterAlt(_localctx, 22);
      setState(1930);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::UNLOCK);
      setState(1931);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      break;
    }

    case 23: {
      enterOuterAlt(_localctx, 23);
      setState(1932);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::UNLOCK);
      setState(1933);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::DATABASE);
      break;
    }

    case 24: {
      enterOuterAlt(_localctx, 24);
      setState(1934);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::CREATE);
      setState(1935);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TEMPORARY);
      setState(1936);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::MACRO);
      break;
    }

    case 25: {
      enterOuterAlt(_localctx, 25);
      setState(1937);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::DROP);
      setState(1938);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TEMPORARY);
      setState(1939);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::MACRO);
      break;
    }

    case 26: {
      enterOuterAlt(_localctx, 26);
      setState(1940);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1941);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1942);
      tableIdentifier();
      setState(1943);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1944);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::CLUSTERED);
      break;
    }

    case 27: {
      enterOuterAlt(_localctx, 27);
      setState(1946);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1947);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1948);
      tableIdentifier();
      setState(1949);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::CLUSTERED);
      setState(1950);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::BY);
      break;
    }

    case 28: {
      enterOuterAlt(_localctx, 28);
      setState(1952);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1953);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1954);
      tableIdentifier();
      setState(1955);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1956);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::SORTED);
      break;
    }

    case 29: {
      enterOuterAlt(_localctx, 29);
      setState(1958);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1959);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1960);
      tableIdentifier();
      setState(1961);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::SKEWED);
      setState(1962);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::BY);
      break;
    }

    case 30: {
      enterOuterAlt(_localctx, 30);
      setState(1964);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1965);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1966);
      tableIdentifier();
      setState(1967);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1968);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::SKEWED);
      break;
    }

    case 31: {
      enterOuterAlt(_localctx, 31);
      setState(1970);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1971);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1972);
      tableIdentifier();
      setState(1973);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::NOT);
      setState(1974);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::STORED);
      setState(1975);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw5 = match(fugue_sqlParser::AS);
      setState(1976);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw6 = match(fugue_sqlParser::DIRECTORIES);
      break;
    }

    case 32: {
      enterOuterAlt(_localctx, 32);
      setState(1978);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1979);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1980);
      tableIdentifier();
      setState(1981);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::SET);
      setState(1982);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::SKEWED);
      setState(1983);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw5 = match(fugue_sqlParser::LOCATION);
      break;
    }

    case 33: {
      enterOuterAlt(_localctx, 33);
      setState(1985);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1986);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1987);
      tableIdentifier();
      setState(1988);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::EXCHANGE);
      setState(1989);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::PARTITION);
      break;
    }

    case 34: {
      enterOuterAlt(_localctx, 34);
      setState(1991);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1992);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1993);
      tableIdentifier();
      setState(1994);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::ARCHIVE);
      setState(1995);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::PARTITION);
      break;
    }

    case 35: {
      enterOuterAlt(_localctx, 35);
      setState(1997);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(1998);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(1999);
      tableIdentifier();
      setState(2000);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::UNARCHIVE);
      setState(2001);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::PARTITION);
      break;
    }

    case 36: {
      enterOuterAlt(_localctx, 36);
      setState(2003);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(2004);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(2005);
      tableIdentifier();
      setState(2006);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::TOUCH);
      break;
    }

    case 37: {
      enterOuterAlt(_localctx, 37);
      setState(2008);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(2009);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(2010);
      tableIdentifier();
      setState(2012);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2011);
        partitionSpec();
      }
      setState(2014);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::COMPACT);
      break;
    }

    case 38: {
      enterOuterAlt(_localctx, 38);
      setState(2016);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(2017);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(2018);
      tableIdentifier();
      setState(2020);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2019);
        partitionSpec();
      }
      setState(2022);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::CONCATENATE);
      break;
    }

    case 39: {
      enterOuterAlt(_localctx, 39);
      setState(2024);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(2025);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(2026);
      tableIdentifier();
      setState(2028);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2027);
        partitionSpec();
      }
      setState(2030);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::SET);
      setState(2031);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::FILEFORMAT);
      break;
    }

    case 40: {
      enterOuterAlt(_localctx, 40);
      setState(2033);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ALTER);
      setState(2034);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TABLE);
      setState(2035);
      tableIdentifier();
      setState(2037);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2036);
        partitionSpec();
      }
      setState(2039);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw3 = match(fugue_sqlParser::REPLACE);
      setState(2040);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw4 = match(fugue_sqlParser::COLUMNS);
      break;
    }

    case 41: {
      enterOuterAlt(_localctx, 41);
      setState(2042);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::START);
      setState(2043);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw2 = match(fugue_sqlParser::TRANSACTION);
      break;
    }

    case 42: {
      enterOuterAlt(_localctx, 42);
      setState(2044);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::COMMIT);
      break;
    }

    case 43: {
      enterOuterAlt(_localctx, 43);
      setState(2045);
      antlrcpp::downCast<UnsupportedHiveNativeCommandsContext *>(_localctx)->kw1 = match(fugue_sqlParser::ROLLBACK);
      break;
    }

    case 44: {
      enterOuterAlt(_localctx, 44);
      setState(2046);
      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, 170, 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(2049);
    match(fugue_sqlParser::CREATE);
    setState(2051);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::TEMPORARY) {
      setState(2050);
      match(fugue_sqlParser::TEMPORARY);
    }
    setState(2054);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::EXTERNAL) {
      setState(2053);
      match(fugue_sqlParser::EXTERNAL);
    }
    setState(2056);
    match(fugue_sqlParser::TABLE);
    setState(2060);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 248, _ctx)) {
    case 1: {
      setState(2057);
      match(fugue_sqlParser::IF);
      setState(2058);
      match(fugue_sqlParser::NOT);
      setState(2059);
      match(fugue_sqlParser::EXISTS);
      break;
    }

    default:
      break;
    }
    setState(2062);
    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, 172, 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(2066);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::CREATE) {
      setState(2064);
      match(fugue_sqlParser::CREATE);
      setState(2065);
      match(fugue_sqlParser::OR);
    }
    setState(2068);
    match(fugue_sqlParser::REPLACE);
    setState(2069);
    match(fugue_sqlParser::TABLE);
    setState(2070);
    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, 174, 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(2072);
    match(fugue_sqlParser::CLUSTERED);
    setState(2073);
    match(fugue_sqlParser::BY);
    setState(2074);
    identifierList();
    setState(2078);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::SORTED) {
      setState(2075);
      match(fugue_sqlParser::SORTED);
      setState(2076);
      match(fugue_sqlParser::BY);
      setState(2077);
      orderedIdentifierList();
    }
    setState(2080);
    match(fugue_sqlParser::INTO);
    setState(2081);
    match(fugue_sqlParser::INTEGER_VALUE);
    setState(2082);
    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, 176, fugue_sqlParser::RuleSkewSpec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2084);
    match(fugue_sqlParser::SKEWED);
    setState(2085);
    match(fugue_sqlParser::BY);
    setState(2086);
    identifierList();
    setState(2087);
    match(fugue_sqlParser::ON);
    setState(2090);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 251, _ctx)) {
    case 1: {
      setState(2088);
      constantList();
      break;
    }

    case 2: {
      setState(2089);
      nestedConstantList();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 252, _ctx)) {
    case 1: {
      setState(2092);
      match(fugue_sqlParser::STORED);
      setState(2093);
      match(fugue_sqlParser::AS);
      setState(2094);
      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, 178, fugue_sqlParser::RuleLocationSpec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2097);
    match(fugue_sqlParser::LOCATION);
    setState(2098);
    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, 180, fugue_sqlParser::RuleCommentSpec);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2100);
    match(fugue_sqlParser::COMMENT);
    setState(2101);
    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, 182, 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(2104);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::CONNECT) {
      setState(2103);
      fugueSqlEngine();
    }
    setState(2107);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::WITH) {
      setState(2106);
      ctes();
    }
    setState(2109);
    queryTerm(0);
    setState(2110);
    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, 184, fugue_sqlParser::RuleInsertInto);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2167);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 267, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertOverwriteTableContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2112);
      match(fugue_sqlParser::INSERT);
      setState(2113);
      match(fugue_sqlParser::OVERWRITE);
      setState(2115);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 255, _ctx)) {
      case 1: {
        setState(2114);
        match(fugue_sqlParser::TABLE);
        break;
      }

      default:
        break;
      }
      setState(2117);
      multipartIdentifier();
      setState(2124);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2118);
        partitionSpec();
        setState(2122);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::IF) {
          setState(2119);
          match(fugue_sqlParser::IF);
          setState(2120);
          match(fugue_sqlParser::NOT);
          setState(2121);
          match(fugue_sqlParser::EXISTS);
        }
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertIntoTableContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2126);
      match(fugue_sqlParser::INSERT);
      setState(2127);
      match(fugue_sqlParser::INTO);
      setState(2129);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 258, _ctx)) {
      case 1: {
        setState(2128);
        match(fugue_sqlParser::TABLE);
        break;
      }

      default:
        break;
      }
      setState(2131);
      multipartIdentifier();
      setState(2133);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::PARTITION) {
        setState(2132);
        partitionSpec();
      }
      setState(2138);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IF) {
        setState(2135);
        match(fugue_sqlParser::IF);
        setState(2136);
        match(fugue_sqlParser::NOT);
        setState(2137);
        match(fugue_sqlParser::EXISTS);
      }
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertOverwriteHiveDirContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(2140);
      match(fugue_sqlParser::INSERT);
      setState(2141);
      match(fugue_sqlParser::OVERWRITE);
      setState(2143);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(2142);
        match(fugue_sqlParser::LOCAL);
      }
      setState(2145);
      match(fugue_sqlParser::DIRECTORY);
      setState(2146);
      antlrcpp::downCast<InsertOverwriteHiveDirContext *>(_localctx)->path = match(fugue_sqlParser::STRING);
      setState(2148);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ROW) {
        setState(2147);
        rowFormat();
      }
      setState(2151);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STORED) {
        setState(2150);
        createFileFormat();
      }
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InsertOverwriteDirContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(2153);
      match(fugue_sqlParser::INSERT);
      setState(2154);
      match(fugue_sqlParser::OVERWRITE);
      setState(2156);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LOCAL) {
        setState(2155);
        match(fugue_sqlParser::LOCAL);
      }
      setState(2158);
      match(fugue_sqlParser::DIRECTORY);
      setState(2160);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::STRING) {
        setState(2159);
        antlrcpp::downCast<InsertOverwriteDirContext *>(_localctx)->path = match(fugue_sqlParser::STRING);
      }
      setState(2162);
      tableProvider();
      setState(2165);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OPTIONS) {
        setState(2163);
        match(fugue_sqlParser::OPTIONS);
        setState(2164);
        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, 186, 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(2169);
    partitionSpec();
    setState(2171);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::LOCATION) {
      setState(2170);
      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, 188, 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(2173);
    match(fugue_sqlParser::PARTITION);
    setState(2174);
    match(fugue_sqlParser::T__4);
    setState(2175);
    partitionVal();
    setState(2180);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2176);
      match(fugue_sqlParser::T__1);
      setState(2177);
      partitionVal();
      setState(2182);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2183);
    match(fugue_sqlParser::T__5);
   
  }
  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, 190, 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(2185);
    identifier();
    setState(2188);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::EQUAL) {
      setState(2186);
      match(fugue_sqlParser::EQUAL);
      setState(2187);
      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, 192, 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(2190);
    _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, 194, fugue_sqlParser::RuleDescribeFuncName);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2193);
      match(fugue_sqlParser::STRING);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2194);
      comparisonOperator();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(2195);
      arithmeticOperator();
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2196);
      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, 196, 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(2199);
    antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext = identifier();
    antlrcpp::downCast<DescribeColNameContext *>(_localctx)->nameParts.push_back(antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext);
    setState(2204);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__6) {
      setState(2200);
      match(fugue_sqlParser::T__6);
      setState(2201);
      antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext = identifier();
      antlrcpp::downCast<DescribeColNameContext *>(_localctx)->nameParts.push_back(antlrcpp::downCast<DescribeColNameContext *>(_localctx)->identifierContext);
      setState(2206);
      _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, 198, 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(2207);
    match(fugue_sqlParser::WITH);
    setState(2208);
    namedQuery();
    setState(2213);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2209);
      match(fugue_sqlParser::T__1);
      setState(2210);
      namedQuery();
      setState(2215);
      _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, 200, 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(2216);
    antlrcpp::downCast<NamedQueryContext *>(_localctx)->name = errorCapturingIdentifier();
    setState(2218);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 274, _ctx)) {
    case 1: {
      setState(2217);
      antlrcpp::downCast<NamedQueryContext *>(_localctx)->columnAliases = identifierList();
      break;
    }

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AS) {
      setState(2220);
      match(fugue_sqlParser::AS);
    }
    setState(2223);
    match(fugue_sqlParser::T__4);
    setState(2224);
    query();
    setState(2225);
    match(fugue_sqlParser::T__5);
   
  }
  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, 202, fugue_sqlParser::RuleTableProvider);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2227);
    match(fugue_sqlParser::USING);
    setState(2228);
    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, 204, 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(2242);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::CLUSTERED

    || _la == fugue_sqlParser::COMMENT || (((_la - 184) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 184)) & 8594128897) != 0 || _la == fugue_sqlParser::TBLPROPERTIES) {
      setState(2240);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::OPTIONS: {
          setState(2230);
          match(fugue_sqlParser::OPTIONS);
          setState(2231);
          antlrcpp::downCast<CreateTableClausesContext *>(_localctx)->options = tablePropertyList();
          break;
        }

        case fugue_sqlParser::PARTITIONED: {
          setState(2232);
          match(fugue_sqlParser::PARTITIONED);
          setState(2233);
          match(fugue_sqlParser::BY);
          setState(2234);
          antlrcpp::downCast<CreateTableClausesContext *>(_localctx)->partitioning = transformList();
          break;
        }

        case fugue_sqlParser::CLUSTERED: {
          setState(2235);
          bucketSpec();
          break;
        }

        case fugue_sqlParser::LOCATION: {
          setState(2236);
          locationSpec();
          break;
        }

        case fugue_sqlParser::COMMENT: {
          setState(2237);
          commentSpec();
          break;
        }

        case fugue_sqlParser::TBLPROPERTIES: {
          setState(2238);
          match(fugue_sqlParser::TBLPROPERTIES);
          setState(2239);
          antlrcpp::downCast<CreateTableClausesContext *>(_localctx)->tableProps = tablePropertyList();
          break;
        }

      default:
        throw NoViableAltException(this);
      }
      setState(2244);
      _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, 206, 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(2245);
    match(fugue_sqlParser::T__4);
    setState(2246);
    tableProperty();
    setState(2251);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2247);
      match(fugue_sqlParser::T__1);
      setState(2248);
      tableProperty();
      setState(2253);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2254);
    match(fugue_sqlParser::T__5);
   
  }
  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, 208, 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(2256);
    antlrcpp::downCast<TablePropertyContext *>(_localctx)->key = tablePropertyKey();
    setState(2261);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::FALSE || (((_la - 287) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 287)) & 712483543187457) != 0) {
      setState(2258);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::EQUAL) {
        setState(2257);
        match(fugue_sqlParser::EQUAL);
      }
      setState(2260);
      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, 210, fugue_sqlParser::RuleTablePropertyKey);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2272);
    _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(2263);
        identifier();
        setState(2268);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__6) {
          setState(2264);
          match(fugue_sqlParser::T__6);
          setState(2265);
          identifier();
          setState(2270);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        break;
      }

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 2);
        setState(2271);
        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, 212, fugue_sqlParser::RuleTablePropertyValue);

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

      case fugue_sqlParser::DECIMAL_VALUE: {
        enterOuterAlt(_localctx, 2);
        setState(2275);
        match(fugue_sqlParser::DECIMAL_VALUE);
        break;
      }

      case fugue_sqlParser::FALSE:
      case fugue_sqlParser::TRUE: {
        enterOuterAlt(_localctx, 3);
        setState(2276);
        booleanValue();
        break;
      }

      case fugue_sqlParser::STRING: {
        enterOuterAlt(_localctx, 4);
        setState(2277);
        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, 214, 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(2280);
    match(fugue_sqlParser::T__4);
    setState(2281);
    constant();
    setState(2286);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2282);
      match(fugue_sqlParser::T__1);
      setState(2283);
      constant();
      setState(2288);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2289);
    match(fugue_sqlParser::T__5);
   
  }
  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, 216, 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(2291);
    match(fugue_sqlParser::T__4);
    setState(2292);
    constantList();
    setState(2297);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2293);
      match(fugue_sqlParser::T__1);
      setState(2294);
      constantList();
      setState(2299);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2300);
    match(fugue_sqlParser::T__5);
   
  }
  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, 218, fugue_sqlParser::RuleCreateFileFormat);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2308);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 286, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2302);
      match(fugue_sqlParser::STORED);
      setState(2303);
      match(fugue_sqlParser::AS);
      setState(2304);
      fileFormat();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2305);
      match(fugue_sqlParser::STORED);
      setState(2306);
      match(fugue_sqlParser::BY);
      setState(2307);
      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, 220, fugue_sqlParser::RuleFileFormat);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2315);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 287, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TableFileFormatContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2310);
      match(fugue_sqlParser::INPUTFORMAT);
      setState(2311);
      antlrcpp::downCast<TableFileFormatContext *>(_localctx)->inFmt = match(fugue_sqlParser::STRING);
      setState(2312);
      match(fugue_sqlParser::OUTPUTFORMAT);
      setState(2313);
      antlrcpp::downCast<TableFileFormatContext *>(_localctx)->outFmt = match(fugue_sqlParser::STRING);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::GenericFileFormatContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2314);
      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, 222, fugue_sqlParser::RuleStorageHandler);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 288, _ctx)) {
    case 1: {
      setState(2318);
      match(fugue_sqlParser::WITH);
      setState(2319);
      match(fugue_sqlParser::SERDEPROPERTIES);
      setState(2320);
      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, 224, fugue_sqlParser::RuleResource);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2323);
    identifier();
    setState(2324);
    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, 226, 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(2377);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::INSERT: {
        _localctx = _tracker.createInstance<fugue_sqlParser::SingleInsertQueryContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(2326);
        insertInto();
        setState(2327);
        queryTerm(0);
        setState(2328);
        queryOrganization();
        break;
      }

      case fugue_sqlParser::FROM: {
        _localctx = _tracker.createInstance<fugue_sqlParser::MultiInsertQueryContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(2330);
        fromClause();
        setState(2332); 
        _errHandler->sync(this);
        _la = _input->LA(1);
        do {
          setState(2331);
          multiInsertQueryBody();
          setState(2334); 
          _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(2336);
        match(fugue_sqlParser::DELETE);
        setState(2337);
        match(fugue_sqlParser::FROM);
        setState(2338);
        multipartIdentifier();
        setState(2339);
        tableAlias();
        setState(2341);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::WHERE) {
          setState(2340);
          whereClause();
        }
        break;
      }

      case fugue_sqlParser::UPDATE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::UpdateTableContext>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(2343);
        match(fugue_sqlParser::UPDATE);
        setState(2344);
        multipartIdentifier();
        setState(2345);
        tableAlias();
        setState(2346);
        setClause();
        setState(2348);
        _errHandler->sync(this);

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::WHERE) {
          setState(2347);
          whereClause();
        }
        break;
      }

      case fugue_sqlParser::MERGE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::MergeIntoTableContext>(_localctx);
        enterOuterAlt(_localctx, 5);
        setState(2350);
        match(fugue_sqlParser::MERGE);
        setState(2351);
        match(fugue_sqlParser::INTO);
        setState(2352);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->target = multipartIdentifier();
        setState(2353);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->targetAlias = tableAlias();
        setState(2354);
        match(fugue_sqlParser::USING);
        setState(2360);
        _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(2355);
            antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->source = multipartIdentifier();
            break;
          }

          case fugue_sqlParser::T__4: {
            setState(2356);
            match(fugue_sqlParser::T__4);
            setState(2357);
            antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->sourceQuery = query();
            setState(2358);
            match(fugue_sqlParser::T__5);
            break;
          }

        default:
          throw NoViableAltException(this);
        }
        setState(2362);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->sourceAlias = tableAlias();
        setState(2363);
        match(fugue_sqlParser::ON);
        setState(2364);
        antlrcpp::downCast<MergeIntoTableContext *>(_localctx)->mergeCondition = booleanExpression(0);
        setState(2368);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx);
        while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
          if (alt == 1) {
            setState(2365);
            matchedClause(); 
          }
          setState(2370);
          _errHandler->sync(this);
          alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 293, _ctx);
        }
        setState(2374);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::WHEN) {
          setState(2371);
          notMatchedClause();
          setState(2376);
          _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, 228, fugue_sqlParser::RuleQueryOrganization);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 297, _ctx)) {
    case 1: {
      setState(2379);
      match(fugue_sqlParser::ORDER);
      setState(2380);
      match(fugue_sqlParser::BY);
      setState(2381);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->order.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext);
      setState(2386);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 296, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2382);
          match(fugue_sqlParser::T__1);
          setState(2383);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->order.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext); 
        }
        setState(2388);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 296, _ctx);
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 299, _ctx)) {
    case 1: {
      setState(2391);
      match(fugue_sqlParser::CLUSTER);
      setState(2392);
      match(fugue_sqlParser::BY);
      setState(2393);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->clusterBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext);
      setState(2398);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2394);
          match(fugue_sqlParser::T__1);
          setState(2395);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->clusterBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext); 
        }
        setState(2400);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 298, _ctx);
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 301, _ctx)) {
    case 1: {
      setState(2403);
      match(fugue_sqlParser::DISTRIBUTE);
      setState(2404);
      match(fugue_sqlParser::BY);
      setState(2405);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->distributeBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext);
      setState(2410);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 300, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2406);
          match(fugue_sqlParser::T__1);
          setState(2407);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->distributeBy.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->expressionContext); 
        }
        setState(2412);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 300, _ctx);
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 303, _ctx)) {
    case 1: {
      setState(2415);
      match(fugue_sqlParser::SORT);
      setState(2416);
      match(fugue_sqlParser::BY);
      setState(2417);
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
      antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sort.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext);
      setState(2422);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 302, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2418);
          match(fugue_sqlParser::T__1);
          setState(2419);
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext = sortItem();
          antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sort.push_back(antlrcpp::downCast<QueryOrganizationContext *>(_localctx)->sortItemContext); 
        }
        setState(2424);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 302, _ctx);
      }
      break;
    }

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

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

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 306, _ctx)) {
    case 1: {
      setState(2430);
      match(fugue_sqlParser::LIMIT);
      setState(2433);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 305, _ctx)) {
      case 1: {
        setState(2431);
        match(fugue_sqlParser::ALL);
        break;
      }

      case 2: {
        setState(2432);
        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, 230, fugue_sqlParser::RuleMultiInsertQueryBody);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2437);
    insertInto();
    setState(2438);
    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 = 232;
  enterRecursionRule(_localctx, 232, 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(2443);
    _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(2441);
        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(2442);
        fugueNestableTaskCollectionNoSelect();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(2465);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 312, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(2463);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 311, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<SetOperationContext>(_tracker.createInstance<QueryTermContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleQueryTerm);
          setState(2445);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(2446);
          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(2448);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ALL

          || _la == fugue_sqlParser::DISTINCT) {
            setState(2447);
            setQuantifier();
          }
          setState(2450);
          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(2451);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(2452);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->theOperator = match(fugue_sqlParser::INTERSECT);
          setState(2454);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ALL

          || _la == fugue_sqlParser::DISTINCT) {
            setState(2453);
            setQuantifier();
          }
          setState(2456);
          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(2457);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(2458);
          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(2460);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ALL

          || _la == fugue_sqlParser::DISTINCT) {
            setState(2459);
            setQuantifier();
          }
          setState(2462);
          antlrcpp::downCast<SetOperationContext *>(_localctx)->right = queryTerm(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(2467);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 312, _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, 234, fugue_sqlParser::RuleQueryPrimary);

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

      case fugue_sqlParser::FROM: {
        _localctx = _tracker.createInstance<fugue_sqlParser::FromStmtContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(2469);
        fromStatement();
        break;
      }

      case fugue_sqlParser::TABLE: {
        _localctx = _tracker.createInstance<fugue_sqlParser::TableContext>(_localctx);
        enterOuterAlt(_localctx, 3);
        setState(2470);
        match(fugue_sqlParser::TABLE);
        setState(2471);
        multipartIdentifier();
        break;
      }

      case fugue_sqlParser::VALUES: {
        _localctx = _tracker.createInstance<fugue_sqlParser::InlineTableDefault1Context>(_localctx);
        enterOuterAlt(_localctx, 4);
        setState(2472);
        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, 236, 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(2475);
    expression();
    setState(2477);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 314, _ctx)) {
    case 1: {
      setState(2476);
      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(2481);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 315, _ctx)) {
    case 1: {
      setState(2479);
      match(fugue_sqlParser::THENULLS);
      setState(2480);
      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, 238, fugue_sqlParser::RuleFromStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2483);
    fromClause();
    setState(2485); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(2484);
              fromStatementBody();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(2487); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 316, _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, 240, fugue_sqlParser::RuleFromStatementBody);

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

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

      default:
        break;
      }
      setState(2493);
      queryOrganization();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2495);
      selectClause();
      setState(2499);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 318, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2496);
          lateralView(); 
        }
        setState(2501);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 318, _ctx);
      }
      setState(2503);
      _errHandler->sync(this);

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 320, _ctx)) {
      case 1: {
        setState(2505);
        aggregationClause();
        break;
      }

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

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 322, _ctx)) {
      case 1: {
        setState(2511);
        windowClause();
        break;
      }

      default:
        break;
      }
      setState(2514);
      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, 242, fugue_sqlParser::RuleQuerySpecification);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(2543);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 330, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TransformQuerySpecificationContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(2518);
      transformClause();
      setState(2519);
      optionalFromClause();
      setState(2521);
      _errHandler->sync(this);

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

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RegularQuerySpecificationContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2523);
      selectClause();
      setState(2524);
      optionalFromClause();
      setState(2528);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 325, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2525);
          lateralView(); 
        }
        setState(2530);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 325, _ctx);
      }
      setState(2532);
      _errHandler->sync(this);

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 327, _ctx)) {
      case 1: {
        setState(2534);
        aggregationClause();
        break;
      }

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

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 329, _ctx)) {
      case 1: {
        setState(2540);
        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, 244, fugue_sqlParser::RuleOptionalFromClause);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 331, _ctx)) {
    case 1: {
      setState(2545);
      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, 246, 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(2558);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::SELECT: {
        setState(2548);
        match(fugue_sqlParser::SELECT);
        setState(2549);
        antlrcpp::downCast<TransformClauseContext *>(_localctx)->kind = match(fugue_sqlParser::TRANSFORM);
        setState(2550);
        match(fugue_sqlParser::T__4);
        setState(2551);
        namedExpressionSeq();
        setState(2552);
        match(fugue_sqlParser::T__5);
        break;
      }

      case fugue_sqlParser::MAP: {
        setState(2554);
        antlrcpp::downCast<TransformClauseContext *>(_localctx)->kind = match(fugue_sqlParser::MAP);
        setState(2555);
        namedExpressionSeq();
        break;
      }

      case fugue_sqlParser::REDUCE: {
        setState(2556);
        antlrcpp::downCast<TransformClauseContext *>(_localctx)->kind = match(fugue_sqlParser::REDUCE);
        setState(2557);
        namedExpressionSeq();
        break;
      }

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

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::ROW) {
      setState(2560);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->inRowFormat = rowFormat();
    }
    setState(2565);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::RECORDWRITER) {
      setState(2563);
      match(fugue_sqlParser::RECORDWRITER);
      setState(2564);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->recordWriter = match(fugue_sqlParser::STRING);
    }
    setState(2567);
    match(fugue_sqlParser::USING);
    setState(2568);
    antlrcpp::downCast<TransformClauseContext *>(_localctx)->script = match(fugue_sqlParser::STRING);
    setState(2581);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 337, _ctx)) {
    case 1: {
      setState(2569);
      match(fugue_sqlParser::AS);
      setState(2579);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 336, _ctx)) {
      case 1: {
        setState(2570);
        identifierSeq();
        break;
      }

      case 2: {
        setState(2571);
        colTypeList();
        break;
      }

      case 3: {
        setState(2572);
        match(fugue_sqlParser::T__4);
        setState(2575);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 335, _ctx)) {
        case 1: {
          setState(2573);
          identifierSeq();
          break;
        }

        case 2: {
          setState(2574);
          colTypeList();
          break;
        }

        default:
          break;
        }
        setState(2577);
        match(fugue_sqlParser::T__5);
        break;
      }

      default:
        break;
      }
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 338, _ctx)) {
    case 1: {
      setState(2583);
      antlrcpp::downCast<TransformClauseContext *>(_localctx)->outRowFormat = rowFormat();
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 339, _ctx)) {
    case 1: {
      setState(2586);
      match(fugue_sqlParser::RECORDREADER);
      setState(2587);
      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, 248, 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(2590);
    match(fugue_sqlParser::SELECT);
    setState(2594);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__13) {
      setState(2591);
      antlrcpp::downCast<SelectClauseContext *>(_localctx)->hintContext = hint();
      antlrcpp::downCast<SelectClauseContext *>(_localctx)->hints.push_back(antlrcpp::downCast<SelectClauseContext *>(_localctx)->hintContext);
      setState(2596);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2598);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 341, _ctx)) {
    case 1: {
      setState(2597);
      setQuantifier();
      break;
    }

    default:
      break;
    }
    setState(2600);
    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, 250, fugue_sqlParser::RuleSetClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2602);
    match(fugue_sqlParser::SET);
    setState(2603);
    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, 252, 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(2605);
    match(fugue_sqlParser::WHEN);
    setState(2606);
    match(fugue_sqlParser::MATCHED);
    setState(2609);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AND) {
      setState(2607);
      match(fugue_sqlParser::AND);
      setState(2608);
      antlrcpp::downCast<MatchedClauseContext *>(_localctx)->matchedCond = booleanExpression(0);
    }
    setState(2611);
    match(fugue_sqlParser::THEN);
    setState(2612);
    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, 254, 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(2614);
    match(fugue_sqlParser::WHEN);
    setState(2615);
    match(fugue_sqlParser::NOT);
    setState(2616);
    match(fugue_sqlParser::MATCHED);
    setState(2619);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AND) {
      setState(2617);
      match(fugue_sqlParser::AND);
      setState(2618);
      antlrcpp::downCast<NotMatchedClauseContext *>(_localctx)->notMatchedCond = booleanExpression(0);
    }
    setState(2621);
    match(fugue_sqlParser::THEN);
    setState(2622);
    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, 256, fugue_sqlParser::RuleMatchedAction);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2625);
      match(fugue_sqlParser::UPDATE);
      setState(2626);
      match(fugue_sqlParser::SET);
      setState(2627);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2628);
      match(fugue_sqlParser::UPDATE);
      setState(2629);
      match(fugue_sqlParser::SET);
      setState(2630);
      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, 258, fugue_sqlParser::RuleNotMatchedAction);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2651);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 346, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2633);
      match(fugue_sqlParser::INSERT);
      setState(2634);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2635);
      match(fugue_sqlParser::INSERT);
      setState(2636);
      match(fugue_sqlParser::T__4);
      setState(2637);
      antlrcpp::downCast<NotMatchedActionContext *>(_localctx)->columns = multipartIdentifierList();
      setState(2638);
      match(fugue_sqlParser::T__5);
      setState(2639);
      match(fugue_sqlParser::VALUES);
      setState(2640);
      match(fugue_sqlParser::T__4);
      setState(2641);
      expression();
      setState(2646);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(2642);
        match(fugue_sqlParser::T__1);
        setState(2643);
        expression();
        setState(2648);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2649);
      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;
}

//----------------- 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, 260, 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(2653);
    assignment();
    setState(2658);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2654);
      match(fugue_sqlParser::T__1);
      setState(2655);
      assignment();
      setState(2660);
      _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, 262, fugue_sqlParser::RuleAssignment);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2661);
    antlrcpp::downCast<AssignmentContext *>(_localctx)->key = multipartIdentifier();
    setState(2662);
    match(fugue_sqlParser::EQUAL);
    setState(2663);
    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, 264, fugue_sqlParser::RuleWhereClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2665);
    match(fugue_sqlParser::WHERE);
    setState(2666);
    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, 266, fugue_sqlParser::RuleHavingClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2668);
    match(fugue_sqlParser::HAVING);
    setState(2669);
    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, 268, 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(2671);
    match(fugue_sqlParser::T__13);
    setState(2672);
    antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext = hintStatement();
    antlrcpp::downCast<HintContext *>(_localctx)->hintStatements.push_back(antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext);
    setState(2679);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -288230376151711740) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & 18014398509481983) != 0 || (((_la - 324) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 324)) & 98305) != 0) {
      setState(2674);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__1) {
        setState(2673);
        match(fugue_sqlParser::T__1);
      }
      setState(2676);
      antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext = hintStatement();
      antlrcpp::downCast<HintContext *>(_localctx)->hintStatements.push_back(antlrcpp::downCast<HintContext *>(_localctx)->hintStatementContext);
      setState(2681);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2682);
    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, 270, fugue_sqlParser::RuleHintStatement);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2697);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 351, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2684);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->hintName = identifier();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2685);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->hintName = identifier();
      setState(2686);
      match(fugue_sqlParser::T__4);
      setState(2687);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext = primaryExpression(0);
      antlrcpp::downCast<HintStatementContext *>(_localctx)->parameters.push_back(antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext);
      setState(2692);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(2688);
        match(fugue_sqlParser::T__1);
        setState(2689);
        antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext = primaryExpression(0);
        antlrcpp::downCast<HintStatementContext *>(_localctx)->parameters.push_back(antlrcpp::downCast<HintStatementContext *>(_localctx)->primaryExpressionContext);
        setState(2694);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2695);
      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;
}

//----------------- 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, 272, fugue_sqlParser::RuleFromClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2699);
    match(fugue_sqlParser::FROM);
    setState(2700);
    relation();
    setState(2705);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 352, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2701);
        match(fugue_sqlParser::T__1);
        setState(2702);
        relation(); 
      }
      setState(2707);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 352, _ctx);
    }
    setState(2711);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 353, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2708);
        lateralView(); 
      }
      setState(2713);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 353, _ctx);
    }
    setState(2715);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 354, _ctx)) {
    case 1: {
      setState(2714);
      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, 274, 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(2761);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 359, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(2717);
      match(fugue_sqlParser::GROUP);
      setState(2718);
      match(fugue_sqlParser::BY);
      setState(2719);
      antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext = expression();
      antlrcpp::downCast<AggregationClauseContext *>(_localctx)->groupingExpressions.push_back(antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext);
      setState(2724);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 355, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2720);
          match(fugue_sqlParser::T__1);
          setState(2721);
          antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<AggregationClauseContext *>(_localctx)->groupingExpressions.push_back(antlrcpp::downCast<AggregationClauseContext *>(_localctx)->expressionContext); 
        }
        setState(2726);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 355, _ctx);
      }
      setState(2744);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 357, _ctx)) {
      case 1: {
        setState(2727);
        match(fugue_sqlParser::WITH);
        setState(2728);
        antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::ROLLUP);
        break;
      }

      case 2: {
        setState(2729);
        match(fugue_sqlParser::WITH);
        setState(2730);
        antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::CUBE);
        break;
      }

      case 3: {
        setState(2731);
        antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::GROUPING);
        setState(2732);
        match(fugue_sqlParser::SETS);
        setState(2733);
        match(fugue_sqlParser::T__4);
        setState(2734);
        groupingSet();
        setState(2739);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(2735);
          match(fugue_sqlParser::T__1);
          setState(2736);
          groupingSet();
          setState(2741);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2742);
        match(fugue_sqlParser::T__5);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2746);
      match(fugue_sqlParser::GROUP);
      setState(2747);
      match(fugue_sqlParser::BY);
      setState(2748);
      antlrcpp::downCast<AggregationClauseContext *>(_localctx)->kind = match(fugue_sqlParser::GROUPING);
      setState(2749);
      match(fugue_sqlParser::SETS);
      setState(2750);
      match(fugue_sqlParser::T__4);
      setState(2751);
      groupingSet();
      setState(2756);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(2752);
        match(fugue_sqlParser::T__1);
        setState(2753);
        groupingSet();
        setState(2758);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(2759);
      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;
}

//----------------- 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, 276, fugue_sqlParser::RuleGroupingSet);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -288230376151711712) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 256)) & -9205357638345293825) != 0 || (((_la - 320) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 320)) & 2096179) != 0) {
        setState(2764);
        expression();
        setState(2769);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(2765);
          match(fugue_sqlParser::T__1);
          setState(2766);
          expression();
          setState(2771);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(2774);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2775);
      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, 278, 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(2778);
    match(fugue_sqlParser::PIVOT);
    setState(2779);
    match(fugue_sqlParser::T__4);
    setState(2780);
    antlrcpp::downCast<PivotClauseContext *>(_localctx)->aggregates = namedExpressionSeq();
    setState(2781);
    match(fugue_sqlParser::FOR);
    setState(2782);
    pivotColumn();
    setState(2783);
    match(fugue_sqlParser::IN);
    setState(2784);
    match(fugue_sqlParser::T__4);
    setState(2785);
    antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext = pivotValue();
    antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValues.push_back(antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext);
    setState(2790);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2786);
      match(fugue_sqlParser::T__1);
      setState(2787);
      antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext = pivotValue();
      antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValues.push_back(antlrcpp::downCast<PivotClauseContext *>(_localctx)->pivotValueContext);
      setState(2792);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2793);
    match(fugue_sqlParser::T__5);
    setState(2794);
    match(fugue_sqlParser::T__5);
   
  }
  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, 280, fugue_sqlParser::RulePivotColumn);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2808);
    _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(2796);
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext = identifier();
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifiers.push_back(antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext);
        break;
      }

      case fugue_sqlParser::T__4: {
        enterOuterAlt(_localctx, 2);
        setState(2797);
        match(fugue_sqlParser::T__4);
        setState(2798);
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext = identifier();
        antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifiers.push_back(antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext);
        setState(2803);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(2799);
          match(fugue_sqlParser::T__1);
          setState(2800);
          antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext = identifier();
          antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifiers.push_back(antlrcpp::downCast<PivotColumnContext *>(_localctx)->identifierContext);
          setState(2805);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(2806);
        match(fugue_sqlParser::T__5);
        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, 282, 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(2810);
    expression();
    setState(2815);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la - 58) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 58)) & -1) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 122)) & -1) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 186)) & -1) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 250)) & 1152921504606846975) != 0 || (((_la - 324) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 324)) & 98305) != 0) {
      setState(2812);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 366, _ctx)) {
      case 1: {
        setState(2811);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(2814);
      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, 284, 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(2817);
    match(fugue_sqlParser::LATERAL);
    setState(2818);
    match(fugue_sqlParser::VIEW);
    setState(2820);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 368, _ctx)) {
    case 1: {
      setState(2819);
      match(fugue_sqlParser::OUTER);
      break;
    }

    default:
      break;
    }
    setState(2822);
    qualifiedName();
    setState(2823);
    match(fugue_sqlParser::T__4);
    setState(2832);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -288230376151711712) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & -9205357638345293825) != 0 || (((_la - 320) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 320)) & 2096179) != 0) {
      setState(2824);
      expression();
      setState(2829);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(2825);
        match(fugue_sqlParser::T__1);
        setState(2826);
        expression();
        setState(2831);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(2834);
    match(fugue_sqlParser::T__5);
    setState(2835);
    antlrcpp::downCast<LateralViewContext *>(_localctx)->tblName = identifier();
    setState(2847);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 373, _ctx)) {
    case 1: {
      setState(2837);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 371, _ctx)) {
      case 1: {
        setState(2836);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(2839);
      antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext = identifier();
      antlrcpp::downCast<LateralViewContext *>(_localctx)->colName.push_back(antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext);
      setState(2844);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _ctx);
      while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
        if (alt == 1) {
          setState(2840);
          match(fugue_sqlParser::T__1);
          setState(2841);
          antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext = identifier();
          antlrcpp::downCast<LateralViewContext *>(_localctx)->colName.push_back(antlrcpp::downCast<LateralViewContext *>(_localctx)->identifierContext); 
        }
        setState(2846);
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 372, _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, 286, 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(2849);
    _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, 288, fugue_sqlParser::RuleRelation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2851);
    relationPrimary();
    setState(2855);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 374, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2852);
        joinRelation(); 
      }
      setState(2857);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 374, _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, 290, fugue_sqlParser::RuleJoinRelation);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(2869);
    _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(2858);
        joinType();
        setState(2859);
        match(fugue_sqlParser::JOIN);
        setState(2860);
        antlrcpp::downCast<JoinRelationContext *>(_localctx)->right = relationPrimary();
        setState(2862);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 375, _ctx)) {
        case 1: {
          setState(2861);
          joinCriteria();
          break;
        }

        default:
          break;
        }
        break;
      }

      case fugue_sqlParser::NATURAL: {
        enterOuterAlt(_localctx, 2);
        setState(2864);
        match(fugue_sqlParser::NATURAL);
        setState(2865);
        joinType();
        setState(2866);
        match(fugue_sqlParser::JOIN);
        setState(2867);
        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, 292, fugue_sqlParser::RuleJoinType);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::INNER) {
        setState(2871);
        match(fugue_sqlParser::INNER);
      }
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(2874);
      match(fugue_sqlParser::CROSS);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(2875);
      match(fugue_sqlParser::LEFT);
      setState(2877);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OUTER) {
        setState(2876);
        match(fugue_sqlParser::OUTER);
      }
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LEFT) {
        setState(2879);
        match(fugue_sqlParser::LEFT);
      }
      setState(2882);
      match(fugue_sqlParser::SEMI);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(2883);
      match(fugue_sqlParser::RIGHT);
      setState(2885);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OUTER) {
        setState(2884);
        match(fugue_sqlParser::OUTER);
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(2887);
      match(fugue_sqlParser::FULL);
      setState(2889);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::OUTER) {
        setState(2888);
        match(fugue_sqlParser::OUTER);
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(2892);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::LEFT) {
        setState(2891);
        match(fugue_sqlParser::LEFT);
      }
      setState(2894);
      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, 294, fugue_sqlParser::RuleJoinCriteria);

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

      case fugue_sqlParser::USING: {
        enterOuterAlt(_localctx, 2);
        setState(2899);
        match(fugue_sqlParser::USING);
        setState(2900);
        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);
}

tree::TerminalNode* fugue_sqlParser::SampleContext::SYSTEM() {
  return getToken(fugue_sqlParser::SYSTEM, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleContext::BERNOULLI() {
  return getToken(fugue_sqlParser::BERNOULLI, 0);
}

tree::TerminalNode* fugue_sqlParser::SampleContext::RESERVOIR() {
  return getToken(fugue_sqlParser::RESERVOIR, 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, 296, 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(2903);
    match(fugue_sqlParser::TABLESAMPLE);
    setState(2905);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 15762598695796736) != 0) {
      setState(2904);
      _la = _input->LA(1);
      if (!(((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & 15762598695796736) != 0)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
    }
    setState(2907);
    match(fugue_sqlParser::T__4);
    setState(2909);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -288230376151711712) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & -9205357638345293825) != 0 || (((_la - 320) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 320)) & 2096179) != 0) {
      setState(2908);
      sampleMethod();
    }
    setState(2911);
    match(fugue_sqlParser::T__5);
   
  }
  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::PERCENT() {
  return getToken(fugue_sqlParser::PERCENT, 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, 298, fugue_sqlParser::RuleSampleMethod);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(2913);
        antlrcpp::downCast<SampleByPercentileContext *>(_localctx)->negativeSign = match(fugue_sqlParser::MINUS);
      }
      setState(2916);
      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(2917);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::PERCENTLIT || _la == fugue_sqlParser::PERCENT)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByRowsContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2918);
      expression();
      setState(2919);
      match(fugue_sqlParser::ROWS);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByBucketContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(2921);
      antlrcpp::downCast<SampleByBucketContext *>(_localctx)->sampleType = match(fugue_sqlParser::BUCKET);
      setState(2922);
      antlrcpp::downCast<SampleByBucketContext *>(_localctx)->numerator = match(fugue_sqlParser::INTEGER_VALUE);
      setState(2923);
      match(fugue_sqlParser::OUT);
      setState(2924);
      match(fugue_sqlParser::OF);
      setState(2925);
      antlrcpp::downCast<SampleByBucketContext *>(_localctx)->denominator = match(fugue_sqlParser::INTEGER_VALUE);
      setState(2934);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ON) {
        setState(2926);
        match(fugue_sqlParser::ON);
        setState(2932);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 388, _ctx)) {
        case 1: {
          setState(2927);
          identifier();
          break;
        }

        case 2: {
          setState(2928);
          qualifiedName();
          setState(2929);
          match(fugue_sqlParser::T__4);
          setState(2930);
          match(fugue_sqlParser::T__5);
          break;
        }

        default:
          break;
        }
      }
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SampleByBytesContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(2936);
      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, 300, fugue_sqlParser::RuleIdentifierList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(2939);
    match(fugue_sqlParser::T__4);
    setState(2940);
    identifierSeq();
    setState(2941);
    match(fugue_sqlParser::T__5);
   
  }
  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, 302, fugue_sqlParser::RuleIdentifierSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(2943);
    antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
    antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->ident.push_back(antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext);
    setState(2948);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 391, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(2944);
        match(fugue_sqlParser::T__1);
        setState(2945);
        antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
        antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->ident.push_back(antlrcpp::downCast<IdentifierSeqContext *>(_localctx)->errorCapturingIdentifierContext); 
      }
      setState(2950);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 391, _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, 304, 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(2951);
    match(fugue_sqlParser::T__4);
    setState(2952);
    orderedIdentifier();
    setState(2957);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2953);
      match(fugue_sqlParser::T__1);
      setState(2954);
      orderedIdentifier();
      setState(2959);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2960);
    match(fugue_sqlParser::T__5);
   
  }
  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, 306, 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(2962);
    antlrcpp::downCast<OrderedIdentifierContext *>(_localctx)->ident = errorCapturingIdentifier();
    setState(2964);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::ASC

    || _la == fugue_sqlParser::DESC) {
      setState(2963);
      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, 308, 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(2966);
    match(fugue_sqlParser::T__4);
    setState(2967);
    identifierComment();
    setState(2972);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(2968);
      match(fugue_sqlParser::T__1);
      setState(2969);
      identifierComment();
      setState(2974);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(2975);
    match(fugue_sqlParser::T__5);
   
  }
  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, 310, 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(2977);
    identifier();
    setState(2979);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::COMMENT) {
      setState(2978);
      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, 312, fugue_sqlParser::RuleRelationPrimary);

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

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

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 397, _ctx)) {
      case 1: {
        setState(2985);
        sample();
        break;
      }

      default:
        break;
      }
      setState(2988);
      tableAlias();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AliasedQueryContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(2990);
      match(fugue_sqlParser::T__4);
      setState(2991);
      query();
      setState(2992);
      match(fugue_sqlParser::T__5);
      setState(2994);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 398, _ctx)) {
      case 1: {
        setState(2993);
        sample();
        break;
      }

      default:
        break;
      }
      setState(2996);
      tableAlias();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::AliasedRelationContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(2998);
      match(fugue_sqlParser::T__4);
      setState(2999);
      relation();
      setState(3000);
      match(fugue_sqlParser::T__5);
      setState(3002);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 399, _ctx)) {
      case 1: {
        setState(3001);
        sample();
        break;
      }

      default:
        break;
      }
      setState(3004);
      tableAlias();
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::InlineTableDefault2Context>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(3006);
      inlineTable();
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TableValuedFunctionContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(3007);
      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, 314, fugue_sqlParser::RuleInlineTable);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3010);
    match(fugue_sqlParser::VALUES);
    setState(3011);
    expression();
    setState(3016);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 401, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3012);
        match(fugue_sqlParser::T__1);
        setState(3013);
        expression(); 
      }
      setState(3018);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 401, _ctx);
    }
    setState(3019);
    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, 316, 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(3021);
    antlrcpp::downCast<FunctionTableContext *>(_localctx)->funcName = errorCapturingIdentifier();
    setState(3022);
    match(fugue_sqlParser::T__4);
    setState(3031);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & -288230376151711712) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 256)) & -9205357638345293825) != 0 || (((_la - 320) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 320)) & 2096179) != 0) {
      setState(3023);
      expression();
      setState(3028);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(3024);
        match(fugue_sqlParser::T__1);
        setState(3025);
        expression();
        setState(3030);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
    }
    setState(3033);
    match(fugue_sqlParser::T__5);
    setState(3034);
    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, 318, fugue_sqlParser::RuleTableAlias);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 406, _ctx)) {
    case 1: {
      setState(3037);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 404, _ctx)) {
      case 1: {
        setState(3036);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(3039);
      strictIdentifier();
      setState(3041);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 405, _ctx)) {
      case 1: {
        setState(3040);
        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, 320, fugue_sqlParser::RuleRowFormat);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3094);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 414, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RowFormatSerdeContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3045);
      match(fugue_sqlParser::ROW);
      setState(3046);
      match(fugue_sqlParser::FORMAT);
      setState(3047);
      match(fugue_sqlParser::SERDE);
      setState(3048);
      antlrcpp::downCast<RowFormatSerdeContext *>(_localctx)->name = match(fugue_sqlParser::STRING);
      setState(3052);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 407, _ctx)) {
      case 1: {
        setState(3049);
        match(fugue_sqlParser::WITH);
        setState(3050);
        match(fugue_sqlParser::SERDEPROPERTIES);
        setState(3051);
        antlrcpp::downCast<RowFormatSerdeContext *>(_localctx)->props = tablePropertyList();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::RowFormatDelimitedContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3054);
      match(fugue_sqlParser::ROW);
      setState(3055);
      match(fugue_sqlParser::FORMAT);
      setState(3056);
      match(fugue_sqlParser::DELIMITED);
      setState(3066);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 409, _ctx)) {
      case 1: {
        setState(3057);
        match(fugue_sqlParser::FIELDS);
        setState(3058);
        match(fugue_sqlParser::TERMINATED);
        setState(3059);
        match(fugue_sqlParser::BY);
        setState(3060);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->fieldsTerminatedBy = match(fugue_sqlParser::STRING);
        setState(3064);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 408, _ctx)) {
        case 1: {
          setState(3061);
          match(fugue_sqlParser::ESCAPED);
          setState(3062);
          match(fugue_sqlParser::BY);
          setState(3063);
          antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->escapedBy = match(fugue_sqlParser::STRING);
          break;
        }

        default:
          break;
        }
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 410, _ctx)) {
      case 1: {
        setState(3068);
        match(fugue_sqlParser::COLLECTION);
        setState(3069);
        match(fugue_sqlParser::ITEMS);
        setState(3070);
        match(fugue_sqlParser::TERMINATED);
        setState(3071);
        match(fugue_sqlParser::BY);
        setState(3072);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->collectionItemsTerminatedBy = match(fugue_sqlParser::STRING);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 411, _ctx)) {
      case 1: {
        setState(3075);
        match(fugue_sqlParser::MAP);
        setState(3076);
        match(fugue_sqlParser::KEYS);
        setState(3077);
        match(fugue_sqlParser::TERMINATED);
        setState(3078);
        match(fugue_sqlParser::BY);
        setState(3079);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->keysTerminatedBy = match(fugue_sqlParser::STRING);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 412, _ctx)) {
      case 1: {
        setState(3082);
        match(fugue_sqlParser::LINES);
        setState(3083);
        match(fugue_sqlParser::TERMINATED);
        setState(3084);
        match(fugue_sqlParser::BY);
        setState(3085);
        antlrcpp::downCast<RowFormatDelimitedContext *>(_localctx)->linesSeparatedBy = match(fugue_sqlParser::STRING);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 413, _ctx)) {
      case 1: {
        setState(3088);
        match(fugue_sqlParser::THENULL);
        setState(3089);
        match(fugue_sqlParser::DEFINED);
        setState(3090);
        match(fugue_sqlParser::AS);
        setState(3091);
        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, 322, 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(3096);
    multipartIdentifier();
    setState(3101);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(3097);
      match(fugue_sqlParser::T__1);
      setState(3098);
      multipartIdentifier();
      setState(3103);
      _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, 324, fugue_sqlParser::RuleMultipartIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3104);
    antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
    antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->parts.push_back(antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext);
    setState(3109);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 416, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3105);
        match(fugue_sqlParser::T__6);
        setState(3106);
        antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext = errorCapturingIdentifier();
        antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->parts.push_back(antlrcpp::downCast<MultipartIdentifierContext *>(_localctx)->errorCapturingIdentifierContext); 
      }
      setState(3111);
      _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;
}

//----------------- 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, 326, fugue_sqlParser::RuleTableIdentifier);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 417, _ctx)) {
    case 1: {
      setState(3112);
      antlrcpp::downCast<TableIdentifierContext *>(_localctx)->db = errorCapturingIdentifier();
      setState(3113);
      match(fugue_sqlParser::T__6);
      break;
    }

    default:
      break;
    }
    setState(3117);
    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, 328, fugue_sqlParser::RuleFunctionIdentifier);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 418, _ctx)) {
    case 1: {
      setState(3119);
      antlrcpp::downCast<FunctionIdentifierContext *>(_localctx)->db = errorCapturingIdentifier();
      setState(3120);
      match(fugue_sqlParser::T__6);
      break;
    }

    default:
      break;
    }
    setState(3124);
    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, 330, fugue_sqlParser::RuleNamedExpression);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 421, _ctx)) {
    case 1: {
      setState(3128);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 419, _ctx)) {
      case 1: {
        setState(3127);
        match(fugue_sqlParser::AS);
        break;
      }

      default:
        break;
      }
      setState(3132);
      _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(3130);
          antlrcpp::downCast<NamedExpressionContext *>(_localctx)->name = errorCapturingIdentifier();
          break;
        }

        case fugue_sqlParser::T__4: {
          setState(3131);
          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, 332, fugue_sqlParser::RuleNamedExpressionSeq);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3136);
    namedExpression();
    setState(3141);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 422, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3137);
        match(fugue_sqlParser::T__1);
        setState(3138);
        namedExpression(); 
      }
      setState(3143);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 422, _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, 334, 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(3144);
    match(fugue_sqlParser::T__4);
    setState(3145);
    antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext = transform();
    antlrcpp::downCast<TransformListContext *>(_localctx)->transforms.push_back(antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext);
    setState(3150);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(3146);
      match(fugue_sqlParser::T__1);
      setState(3147);
      antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext = transform();
      antlrcpp::downCast<TransformListContext *>(_localctx)->transforms.push_back(antlrcpp::downCast<TransformListContext *>(_localctx)->transformContext);
      setState(3152);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(3153);
    match(fugue_sqlParser::T__5);
   
  }
  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, 336, fugue_sqlParser::RuleTransform);
  size_t _la = 0;

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

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ApplyTransformContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3156);
      antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformName = identifier();
      setState(3157);
      match(fugue_sqlParser::T__4);
      setState(3158);
      antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext = transformArgument();
      antlrcpp::downCast<ApplyTransformContext *>(_localctx)->argument.push_back(antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext);
      setState(3163);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(3159);
        match(fugue_sqlParser::T__1);
        setState(3160);
        antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext = transformArgument();
        antlrcpp::downCast<ApplyTransformContext *>(_localctx)->argument.push_back(antlrcpp::downCast<ApplyTransformContext *>(_localctx)->transformArgumentContext);
        setState(3165);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(3166);
      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;
}

//----------------- 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, 338, fugue_sqlParser::RuleTransformArgument);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3171);
      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, 340, fugue_sqlParser::RuleExpression);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3174);
    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 = 342;
  enterRecursionRule(_localctx, 342, 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(3188);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 428, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<LogicalNotContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(3177);
      match(fugue_sqlParser::NOT);
      setState(3178);
      booleanExpression(5);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<ExistsContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3179);
      match(fugue_sqlParser::EXISTS);
      setState(3180);
      match(fugue_sqlParser::T__4);
      setState(3181);
      query();
      setState(3182);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<PredicatedContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3184);
      valueExpression(0);
      setState(3186);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 427, _ctx)) {
      case 1: {
        setState(3185);
        predicate();
        break;
      }

      default:
        break;
      }
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(3198);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 430, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3196);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 429, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<LogicalBinaryContext>(_tracker.createInstance<BooleanExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleBooleanExpression);
          setState(3190);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(3191);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::AND);
          setState(3192);
          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(3193);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(3194);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::OR);
          setState(3195);
          antlrcpp::downCast<LogicalBinaryContext *>(_localctx)->right = booleanExpression(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(3200);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 430, _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, 344, fugue_sqlParser::RulePredicate);
  size_t _la = 0;

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3201);
        match(fugue_sqlParser::NOT);
      }
      setState(3204);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::BETWEEN);
      setState(3205);
      antlrcpp::downCast<PredicateContext *>(_localctx)->lower = valueExpression(0);
      setState(3206);
      match(fugue_sqlParser::AND);
      setState(3207);
      antlrcpp::downCast<PredicateContext *>(_localctx)->upper = valueExpression(0);
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3209);
        match(fugue_sqlParser::NOT);
      }
      setState(3212);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::IN);
      setState(3213);
      match(fugue_sqlParser::T__4);
      setState(3214);
      expression();
      setState(3219);
      _errHandler->sync(this);
      _la = _input->LA(1);
      while (_la == fugue_sqlParser::T__1) {
        setState(3215);
        match(fugue_sqlParser::T__1);
        setState(3216);
        expression();
        setState(3221);
        _errHandler->sync(this);
        _la = _input->LA(1);
      }
      setState(3222);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3225);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3224);
        match(fugue_sqlParser::NOT);
      }
      setState(3227);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::IN);
      setState(3228);
      match(fugue_sqlParser::T__4);
      setState(3229);
      query();
      setState(3230);
      match(fugue_sqlParser::T__5);
      break;
    }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3232);
        match(fugue_sqlParser::NOT);
      }
      setState(3235);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::RLIKE);
      setState(3236);
      antlrcpp::downCast<PredicateContext *>(_localctx)->pattern = valueExpression(0);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3238);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3237);
        match(fugue_sqlParser::NOT);
      }
      setState(3240);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::LIKE);
      setState(3241);
      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(3255);
      _errHandler->sync(this);
      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 438, _ctx)) {
      case 1: {
        setState(3242);
        match(fugue_sqlParser::T__4);
        setState(3243);
        match(fugue_sqlParser::T__5);
        break;
      }

      case 2: {
        setState(3244);
        match(fugue_sqlParser::T__4);
        setState(3245);
        expression();
        setState(3250);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(3246);
          match(fugue_sqlParser::T__1);
          setState(3247);
          expression();
          setState(3252);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(3253);
        match(fugue_sqlParser::T__5);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(3258);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3257);
        match(fugue_sqlParser::NOT);
      }
      setState(3260);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::LIKE);
      setState(3261);
      antlrcpp::downCast<PredicateContext *>(_localctx)->pattern = valueExpression(0);
      setState(3264);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 440, _ctx)) {
      case 1: {
        setState(3262);
        match(fugue_sqlParser::ESCAPE);
        setState(3263);
        antlrcpp::downCast<PredicateContext *>(_localctx)->escapeChar = match(fugue_sqlParser::STRING);
        break;
      }

      default:
        break;
      }
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(3266);
      match(fugue_sqlParser::IS);
      setState(3268);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3267);
        match(fugue_sqlParser::NOT);
      }
      setState(3270);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::THENULL);
      break;
    }

    case 8: {
      enterOuterAlt(_localctx, 8);
      setState(3271);
      match(fugue_sqlParser::IS);
      setState(3273);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3272);
        match(fugue_sqlParser::NOT);
      }
      setState(3275);
      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(3276);
      match(fugue_sqlParser::IS);
      setState(3278);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::NOT) {
        setState(3277);
        match(fugue_sqlParser::NOT);
      }
      setState(3280);
      antlrcpp::downCast<PredicateContext *>(_localctx)->kind = match(fugue_sqlParser::DISTINCT);
      setState(3281);
      match(fugue_sqlParser::FROM);
      setState(3282);
      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 = 346;
  enterRecursionRule(_localctx, 346, 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(3289);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 445, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<ValueExpressionDefaultContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(3286);
      primaryExpression(0);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<ArithmeticUnaryContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3287);
      antlrcpp::downCast<ArithmeticUnaryContext *>(_localctx)->theOperator = _input->LT(1);
      _la = _input->LA(1);
      if (!((((_la - 319) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 319)) & 67) != 0)) {
        antlrcpp::downCast<ArithmeticUnaryContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3288);
      valueExpression(7);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(3312);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 447, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3310);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 446, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<ArithmeticBinaryContext>(_tracker.createInstance<ValueExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->left = previousContext;
          pushNewRecursionContext(newContext, startState, RuleValueExpression);
          setState(3291);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(3292);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _input->LT(1);
          _la = _input->LA(1);
          if (!((((_la - 321) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 321)) & 15) != 0)) {
            antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(3293);
          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(3294);

          if (!(precpred(_ctx, 5))) throw FailedPredicateException(this, "precpred(_ctx, 5)");
          setState(3295);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _input->LT(1);
          _la = _input->LA(1);
          if (!((((_la - 319) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 319)) & 515) != 0)) {
            antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
          setState(3296);
          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(3297);

          if (!(precpred(_ctx, 4))) throw FailedPredicateException(this, "precpred(_ctx, 4)");
          setState(3298);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::AMPERSAND);
          setState(3299);
          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(3300);

          if (!(precpred(_ctx, 3))) throw FailedPredicateException(this, "precpred(_ctx, 3)");
          setState(3301);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::HAT);
          setState(3302);
          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(3303);

          if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
          setState(3304);
          antlrcpp::downCast<ArithmeticBinaryContext *>(_localctx)->theOperator = match(fugue_sqlParser::PIPE);
          setState(3305);
          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(3306);

          if (!(precpred(_ctx, 1))) throw FailedPredicateException(this, "precpred(_ctx, 1)");
          setState(3307);
          comparisonOperator();
          setState(3308);
          antlrcpp::downCast<ComparisonContext *>(_localctx)->right = valueExpression(2);
          break;
        }

        default:
          break;
        } 
      }
      setState(3314);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 447, _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 = 348;
  enterRecursionRule(_localctx, 348, 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(3499);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 467, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<CurrentDatetimeContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;

      setState(3316);
      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(3317);
      match(fugue_sqlParser::CASE);
      setState(3319); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3318);
        whenClause();
        setState(3321); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::WHEN);
      setState(3325);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ELSE) {
        setState(3323);
        match(fugue_sqlParser::ELSE);
        setState(3324);
        antlrcpp::downCast<SearchedCaseContext *>(_localctx)->elseExpression = expression();
      }
      setState(3327);
      match(fugue_sqlParser::END);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<SimpleCaseContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3329);
      match(fugue_sqlParser::CASE);
      setState(3330);
      antlrcpp::downCast<SimpleCaseContext *>(_localctx)->value = expression();
      setState(3332); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3331);
        whenClause();
        setState(3334); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::WHEN);
      setState(3338);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::ELSE) {
        setState(3336);
        match(fugue_sqlParser::ELSE);
        setState(3337);
        antlrcpp::downCast<SimpleCaseContext *>(_localctx)->elseExpression = expression();
      }
      setState(3340);
      match(fugue_sqlParser::END);
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<CastContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3342);
      match(fugue_sqlParser::CAST);
      setState(3343);
      match(fugue_sqlParser::T__4);
      setState(3344);
      expression();
      setState(3345);
      match(fugue_sqlParser::AS);
      setState(3346);
      dataType();
      setState(3347);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<StructContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3349);
      match(fugue_sqlParser::STRUCT);
      setState(3350);
      match(fugue_sqlParser::T__4);
      setState(3359);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -288230376151711712) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 256)) & -9205357638345293825) != 0 || (((_la - 320) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 320)) & 2096179) != 0) {
        setState(3351);
        antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext = namedExpression();
        antlrcpp::downCast<StructContext *>(_localctx)->argument.push_back(antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext);
        setState(3356);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(3352);
          match(fugue_sqlParser::T__1);
          setState(3353);
          antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext = namedExpression();
          antlrcpp::downCast<StructContext *>(_localctx)->argument.push_back(antlrcpp::downCast<StructContext *>(_localctx)->namedExpressionContext);
          setState(3358);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(3361);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<FirstContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3362);
      match(fugue_sqlParser::FIRST);
      setState(3363);
      match(fugue_sqlParser::T__4);
      setState(3364);
      expression();
      setState(3367);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IGNORE) {
        setState(3365);
        match(fugue_sqlParser::IGNORE);
        setState(3366);
        match(fugue_sqlParser::THENULLS);
      }
      setState(3369);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<LastContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3371);
      match(fugue_sqlParser::LAST);
      setState(3372);
      match(fugue_sqlParser::T__4);
      setState(3373);
      expression();
      setState(3376);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::IGNORE) {
        setState(3374);
        match(fugue_sqlParser::IGNORE);
        setState(3375);
        match(fugue_sqlParser::THENULLS);
      }
      setState(3378);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<PositionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3380);
      match(fugue_sqlParser::POSITION);
      setState(3381);
      match(fugue_sqlParser::T__4);
      setState(3382);
      antlrcpp::downCast<PositionContext *>(_localctx)->substr = valueExpression(0);
      setState(3383);
      match(fugue_sqlParser::IN);
      setState(3384);
      antlrcpp::downCast<PositionContext *>(_localctx)->istr = valueExpression(0);
      setState(3385);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<ConstantDefaultContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3387);
      constant();
      break;
    }

    case 10: {
      _localctx = _tracker.createInstance<StarContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3388);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 11: {
      _localctx = _tracker.createInstance<StarContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3389);
      qualifiedName();
      setState(3390);
      match(fugue_sqlParser::T__6);
      setState(3391);
      match(fugue_sqlParser::ASTERISK);
      break;
    }

    case 12: {
      _localctx = _tracker.createInstance<RowConstructorContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3393);
      match(fugue_sqlParser::T__4);
      setState(3394);
      namedExpression();
      setState(3397); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3395);
        match(fugue_sqlParser::T__1);
        setState(3396);
        namedExpression();
        setState(3399); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::T__1);
      setState(3401);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 13: {
      _localctx = _tracker.createInstance<SubqueryExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3403);
      match(fugue_sqlParser::T__4);
      setState(3404);
      query();
      setState(3405);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 14: {
      _localctx = _tracker.createInstance<FunctionCallContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3407);
      functionName();
      setState(3408);
      match(fugue_sqlParser::T__4);
      setState(3420);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (((_la & ~ 0x3fULL) == 0) &&
        ((1ULL << _la) & -288230376151711712) != 0 || (((_la - 64) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 64)) & -1) != 0 || (((_la - 128) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 128)) & -1) != 0 || (((_la - 192) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 192)) & -1) != 0 || (((_la - 256) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 256)) & -9205357638345293825) != 0 || (((_la - 320) & ~ 0x3fULL) == 0) &&
        ((1ULL << (_la - 320)) & 2096179) != 0) {
        setState(3410);
        _errHandler->sync(this);

        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 457, _ctx)) {
        case 1: {
          setState(3409);
          setQuantifier();
          break;
        }

        default:
          break;
        }
        setState(3412);
        antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext = expression();
        antlrcpp::downCast<FunctionCallContext *>(_localctx)->argument.push_back(antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext);
        setState(3417);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(3413);
          match(fugue_sqlParser::T__1);
          setState(3414);
          antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<FunctionCallContext *>(_localctx)->argument.push_back(antlrcpp::downCast<FunctionCallContext *>(_localctx)->expressionContext);
          setState(3419);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
      }
      setState(3422);
      match(fugue_sqlParser::T__5);
      setState(3429);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 460, _ctx)) {
      case 1: {
        setState(3423);
        match(fugue_sqlParser::FILTER);
        setState(3424);
        match(fugue_sqlParser::T__4);
        setState(3425);
        match(fugue_sqlParser::WHERE);
        setState(3426);
        antlrcpp::downCast<FunctionCallContext *>(_localctx)->where = booleanExpression(0);
        setState(3427);
        match(fugue_sqlParser::T__5);
        break;
      }

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

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 461, _ctx)) {
      case 1: {
        setState(3431);
        match(fugue_sqlParser::OVER);
        setState(3432);
        windowSpec();
        break;
      }

      default:
        break;
      }
      break;
    }

    case 15: {
      _localctx = _tracker.createInstance<LambdaContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3435);
      identifier();
      setState(3436);
      match(fugue_sqlParser::T__15);
      setState(3437);
      expression();
      break;
    }

    case 16: {
      _localctx = _tracker.createInstance<LambdaContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3439);
      match(fugue_sqlParser::T__4);
      setState(3440);
      identifier();
      setState(3443); 
      _errHandler->sync(this);
      _la = _input->LA(1);
      do {
        setState(3441);
        match(fugue_sqlParser::T__1);
        setState(3442);
        identifier();
        setState(3445); 
        _errHandler->sync(this);
        _la = _input->LA(1);
      } while (_la == fugue_sqlParser::T__1);
      setState(3447);
      match(fugue_sqlParser::T__5);
      setState(3448);
      match(fugue_sqlParser::T__15);
      setState(3449);
      expression();
      break;
    }

    case 17: {
      _localctx = _tracker.createInstance<ColumnReferenceContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3451);
      identifier();
      break;
    }

    case 18: {
      _localctx = _tracker.createInstance<ParenthesizedExpressionContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3452);
      match(fugue_sqlParser::T__4);
      setState(3453);
      expression();
      setState(3454);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 19: {
      _localctx = _tracker.createInstance<ExtractContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3456);
      match(fugue_sqlParser::EXTRACT);
      setState(3457);
      match(fugue_sqlParser::T__4);
      setState(3458);
      antlrcpp::downCast<ExtractContext *>(_localctx)->field = identifier();
      setState(3459);
      match(fugue_sqlParser::FROM);
      setState(3460);
      antlrcpp::downCast<ExtractContext *>(_localctx)->source = valueExpression(0);
      setState(3461);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 20: {
      _localctx = _tracker.createInstance<SubstringContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3463);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::SUBSTR

      || _la == fugue_sqlParser::SUBSTRING)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3464);
      match(fugue_sqlParser::T__4);
      setState(3465);
      antlrcpp::downCast<SubstringContext *>(_localctx)->istr = valueExpression(0);
      setState(3466);
      _la = _input->LA(1);
      if (!(_la == fugue_sqlParser::T__1 || _la == fugue_sqlParser::FROM)) {
      _errHandler->recoverInline(this);
      }
      else {
        _errHandler->reportMatch(this);
        consume();
      }
      setState(3467);
      antlrcpp::downCast<SubstringContext *>(_localctx)->pos = valueExpression(0);
      setState(3470);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::T__1 || _la == fugue_sqlParser::FOR) {
        setState(3468);
        _la = _input->LA(1);
        if (!(_la == fugue_sqlParser::T__1 || _la == fugue_sqlParser::FOR)) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(3469);
        antlrcpp::downCast<SubstringContext *>(_localctx)->ilen = valueExpression(0);
      }
      setState(3472);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 21: {
      _localctx = _tracker.createInstance<TrimContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3474);
      match(fugue_sqlParser::TRIM);
      setState(3475);
      match(fugue_sqlParser::T__4);
      setState(3477);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 464, _ctx)) {
      case 1: {
        setState(3476);
        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(3480);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 465, _ctx)) {
      case 1: {
        setState(3479);
        antlrcpp::downCast<TrimContext *>(_localctx)->trimStr = valueExpression(0);
        break;
      }

      default:
        break;
      }
      setState(3482);
      match(fugue_sqlParser::FROM);
      setState(3483);
      antlrcpp::downCast<TrimContext *>(_localctx)->srcStr = valueExpression(0);
      setState(3484);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 22: {
      _localctx = _tracker.createInstance<OverlayContext>(_localctx);
      _ctx = _localctx;
      previousContext = _localctx;
      setState(3486);
      match(fugue_sqlParser::OVERLAY);
      setState(3487);
      match(fugue_sqlParser::T__4);
      setState(3488);
      antlrcpp::downCast<OverlayContext *>(_localctx)->iinput = valueExpression(0);
      setState(3489);
      match(fugue_sqlParser::PLACING);
      setState(3490);
      antlrcpp::downCast<OverlayContext *>(_localctx)->replace = valueExpression(0);
      setState(3491);
      match(fugue_sqlParser::FROM);
      setState(3492);
      antlrcpp::downCast<OverlayContext *>(_localctx)->position = valueExpression(0);
      setState(3495);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::FOR) {
        setState(3493);
        match(fugue_sqlParser::FOR);
        setState(3494);
        antlrcpp::downCast<OverlayContext *>(_localctx)->length = valueExpression(0);
      }
      setState(3497);
      match(fugue_sqlParser::T__5);
      break;
    }

    default:
      break;
    }
    _ctx->stop = _input->LT(-1);
    setState(3511);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 469, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        setState(3509);
        _errHandler->sync(this);
        switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 468, _ctx)) {
        case 1: {
          auto newContext = _tracker.createInstance<SubscriptContext>(_tracker.createInstance<PrimaryExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->value = previousContext;
          pushNewRecursionContext(newContext, startState, RulePrimaryExpression);
          setState(3501);

          if (!(precpred(_ctx, 8))) throw FailedPredicateException(this, "precpred(_ctx, 8)");
          setState(3502);
          match(fugue_sqlParser::T__0);
          setState(3503);
          antlrcpp::downCast<SubscriptContext *>(_localctx)->index = valueExpression(0);
          setState(3504);
          match(fugue_sqlParser::T__2);
          break;
        }

        case 2: {
          auto newContext = _tracker.createInstance<DereferenceContext>(_tracker.createInstance<PrimaryExpressionContext>(parentContext, parentState));
          _localctx = newContext;
          newContext->base = previousContext;
          pushNewRecursionContext(newContext, startState, RulePrimaryExpression);
          setState(3506);

          if (!(precpred(_ctx, 6))) throw FailedPredicateException(this, "precpred(_ctx, 6)");
          setState(3507);
          match(fugue_sqlParser::T__6);
          setState(3508);
          antlrcpp::downCast<DereferenceContext *>(_localctx)->fieldName = identifier();
          break;
        }

        default:
          break;
        } 
      }
      setState(3513);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 469, _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, 350, fugue_sqlParser::RuleConstant);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    setState(3526);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 471, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::NullLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3514);
      match(fugue_sqlParser::THENULL);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::IntervalLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3515);
      interval();
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TypeConstructorContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3516);
      identifier();
      setState(3517);
      match(fugue_sqlParser::STRING);
      break;
    }

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::NumericLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(3519);
      number();
      break;
    }

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::BooleanLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(3520);
      booleanValue();
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<fugue_sqlParser::StringLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 6);
      setState(3522); 
      _errHandler->sync(this);
      alt = 1;
      do {
        switch (alt) {
          case 1: {
                setState(3521);
                match(fugue_sqlParser::STRING);
                break;
              }

        default:
          throw NoViableAltException(this);
        }
        setState(3524); 
        _errHandler->sync(this);
        alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 470, _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, 352, fugue_sqlParser::RuleComparisonOperator);

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

      case fugue_sqlParser::NEQ: {
        enterOuterAlt(_localctx, 2);
        setState(3529);
        match(fugue_sqlParser::NEQ);
        break;
      }

      case fugue_sqlParser::NEQJ: {
        enterOuterAlt(_localctx, 3);
        setState(3530);
        match(fugue_sqlParser::NEQJ);
        break;
      }

      case fugue_sqlParser::LT: {
        enterOuterAlt(_localctx, 4);
        setState(3531);
        match(fugue_sqlParser::LT);
        break;
      }

      case fugue_sqlParser::LTE: {
        enterOuterAlt(_localctx, 5);
        setState(3532);
        match(fugue_sqlParser::LTE);
        break;
      }

      case fugue_sqlParser::GT: {
        enterOuterAlt(_localctx, 6);
        setState(3533);
        match(fugue_sqlParser::GT);
        break;
      }

      case fugue_sqlParser::GTE: {
        enterOuterAlt(_localctx, 7);
        setState(3534);
        match(fugue_sqlParser::GTE);
        break;
      }

      case fugue_sqlParser::NSEQ: {
        enterOuterAlt(_localctx, 8);
        setState(3535);
        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, 354, 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(3538);
    _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, 356, 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(3540);
    _la = _input->LA(1);
    if (!((((_la - 319) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 319)) & 2047) != 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, 358, 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(3542);
    _la = _input->LA(1);
    if (!(_la == fugue_sqlParser::AND || (((_la - 159) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 159)) & 282574488338433) != 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, 360, 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(3544);
    _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, 362, fugue_sqlParser::RuleInterval);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 473, _ctx)) {
    case 1: {
      setState(3547);
      errorCapturingMultiUnitsInterval();
      break;
    }

    case 2: {
      setState(3548);
      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, 364, fugue_sqlParser::RuleErrorCapturingMultiUnitsInterval);

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 474, _ctx)) {
    case 1: {
      setState(3552);
      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, 366, fugue_sqlParser::RuleMultiUnitsInterval);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3558); 
    _errHandler->sync(this);
    alt = 1;
    do {
      switch (alt) {
        case 1: {
              setState(3555);
              intervalValue();
              setState(3556);
              intervalUnit();
              break;
            }

      default:
        throw NoViableAltException(this);
      }
      setState(3560); 
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 475, _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, 368, fugue_sqlParser::RuleErrorCapturingUnitToUnitInterval);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3562);
    antlrcpp::downCast<ErrorCapturingUnitToUnitIntervalContext *>(_localctx)->body = unitToUnitInterval();
    setState(3565);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 476, _ctx)) {
    case 1: {
      setState(3563);
      antlrcpp::downCast<ErrorCapturingUnitToUnitIntervalContext *>(_localctx)->error1 = multiUnitsInterval();
      break;
    }

    case 2: {
      setState(3564);
      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, 370, fugue_sqlParser::RuleUnitToUnitInterval);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3567);
    antlrcpp::downCast<UnitToUnitIntervalContext *>(_localctx)->value = intervalValue();
    setState(3568);
    antlrcpp::downCast<UnitToUnitIntervalContext *>(_localctx)->ifrom = intervalUnit();
    setState(3569);
    match(fugue_sqlParser::TO);
    setState(3570);
    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, 372, fugue_sqlParser::RuleIntervalValue);
  size_t _la = 0;

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

        _la = _input->LA(1);
        if (_la == fugue_sqlParser::PLUS

        || _la == fugue_sqlParser::MINUS) {
          setState(3572);
          _la = _input->LA(1);
          if (!(_la == fugue_sqlParser::PLUS

          || _la == fugue_sqlParser::MINUS)) {
          _errHandler->recoverInline(this);
          }
          else {
            _errHandler->reportMatch(this);
            consume();
          }
        }
        setState(3575);
        _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(3576);
        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, 374, fugue_sqlParser::RuleIntervalUnit);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3580);
      match(fugue_sqlParser::HOUR);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3581);
      match(fugue_sqlParser::MINUTE);
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3582);
      match(fugue_sqlParser::MONTH);
      break;
    }

    case 5: {
      enterOuterAlt(_localctx, 5);
      setState(3583);
      match(fugue_sqlParser::SECOND);
      break;
    }

    case 6: {
      enterOuterAlt(_localctx, 6);
      setState(3584);
      match(fugue_sqlParser::YEAR);
      break;
    }

    case 7: {
      enterOuterAlt(_localctx, 7);
      setState(3585);
      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, 376, fugue_sqlParser::RuleColPosition);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3591);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::FIRST: {
        enterOuterAlt(_localctx, 1);
        setState(3588);
        antlrcpp::downCast<ColPositionContext *>(_localctx)->position = match(fugue_sqlParser::FIRST);
        break;
      }

      case fugue_sqlParser::AFTER: {
        enterOuterAlt(_localctx, 2);
        setState(3589);
        antlrcpp::downCast<ColPositionContext *>(_localctx)->position = match(fugue_sqlParser::AFTER);
        setState(3590);
        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, 378, fugue_sqlParser::RuleDataType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3627);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 485, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ComplexDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3593);
      antlrcpp::downCast<ComplexDataTypeContext *>(_localctx)->icomplex = match(fugue_sqlParser::ARRAY);
      setState(3594);
      match(fugue_sqlParser::LT);
      setState(3595);
      dataType();
      setState(3596);
      match(fugue_sqlParser::GT);
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ComplexDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3598);
      antlrcpp::downCast<ComplexDataTypeContext *>(_localctx)->icomplex = match(fugue_sqlParser::MAP);
      setState(3599);
      match(fugue_sqlParser::LT);
      setState(3600);
      dataType();
      setState(3601);
      match(fugue_sqlParser::T__1);
      setState(3602);
      dataType();
      setState(3603);
      match(fugue_sqlParser::GT);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::ComplexDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3605);
      antlrcpp::downCast<ComplexDataTypeContext *>(_localctx)->icomplex = match(fugue_sqlParser::STRUCT);
      setState(3612);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::LT: {
          setState(3606);
          match(fugue_sqlParser::LT);
          setState(3608);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if ((((_la - 58) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 58)) & -1) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 122)) & -1) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 186)) & -1) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 250)) & 1152921504606846975) != 0 || (((_la - 324) & ~ 0x3fULL) == 0) &&
            ((1ULL << (_la - 324)) & 98305) != 0) {
            setState(3607);
            complexColTypeList();
          }
          setState(3610);
          match(fugue_sqlParser::GT);
          break;
        }

        case fugue_sqlParser::NEQ: {
          setState(3611);
          match(fugue_sqlParser::NEQ);
          break;
        }

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

    case 4: {
      _localctx = _tracker.createInstance<fugue_sqlParser::PrimitiveDataTypeContext>(_localctx);
      enterOuterAlt(_localctx, 4);
      setState(3614);
      identifier();
      setState(3625);
      _errHandler->sync(this);

      switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 484, _ctx)) {
      case 1: {
        setState(3615);
        match(fugue_sqlParser::T__4);
        setState(3616);
        match(fugue_sqlParser::INTEGER_VALUE);
        setState(3621);
        _errHandler->sync(this);
        _la = _input->LA(1);
        while (_la == fugue_sqlParser::T__1) {
          setState(3617);
          match(fugue_sqlParser::T__1);
          setState(3618);
          match(fugue_sqlParser::INTEGER_VALUE);
          setState(3623);
          _errHandler->sync(this);
          _la = _input->LA(1);
        }
        setState(3624);
        match(fugue_sqlParser::T__5);
        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, 380, 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(3629);
    qualifiedColTypeWithPosition();
    setState(3634);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(3630);
      match(fugue_sqlParser::T__1);
      setState(3631);
      qualifiedColTypeWithPosition();
      setState(3636);
      _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, 382, 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(3637);
    antlrcpp::downCast<QualifiedColTypeWithPositionContext *>(_localctx)->name = multipartIdentifier();
    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();
    }
    setState(3647);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::AFTER || _la == fugue_sqlParser::FIRST) {
      setState(3646);
      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, 384, fugue_sqlParser::RuleColTypeList);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3649);
    colType();
    setState(3654);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 490, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3650);
        match(fugue_sqlParser::T__1);
        setState(3651);
        colType(); 
      }
      setState(3656);
      _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;
}

//----------------- 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, 386, fugue_sqlParser::RuleColType);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3657);
    antlrcpp::downCast<ColTypeContext *>(_localctx)->colName = errorCapturingIdentifier();
    setState(3658);
    dataType();
    setState(3661);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 491, _ctx)) {
    case 1: {
      setState(3659);
      match(fugue_sqlParser::NOT);
      setState(3660);
      match(fugue_sqlParser::THENULL);
      break;
    }

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

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 492, _ctx)) {
    case 1: {
      setState(3663);
      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, 388, 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(3666);
    complexColType();
    setState(3671);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(3667);
      match(fugue_sqlParser::T__1);
      setState(3668);
      complexColType();
      setState(3673);
      _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, 390, 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(3674);
    identifier();
    setState(3675);
    match(fugue_sqlParser::T__3);
    setState(3676);
    dataType();
    setState(3679);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::NOT) {
      setState(3677);
      match(fugue_sqlParser::NOT);
      setState(3678);
      match(fugue_sqlParser::THENULL);
    }
    setState(3682);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if (_la == fugue_sqlParser::COMMENT) {
      setState(3681);
      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, 392, fugue_sqlParser::RuleWhenClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3684);
    match(fugue_sqlParser::WHEN);
    setState(3685);
    antlrcpp::downCast<WhenClauseContext *>(_localctx)->condition = expression();
    setState(3686);
    match(fugue_sqlParser::THEN);
    setState(3687);
    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, 394, fugue_sqlParser::RuleWindowClause);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3689);
    match(fugue_sqlParser::WINDOW);
    setState(3690);
    namedWindow();
    setState(3695);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 496, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3691);
        match(fugue_sqlParser::T__1);
        setState(3692);
        namedWindow(); 
      }
      setState(3697);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 496, _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, 396, fugue_sqlParser::RuleNamedWindow);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3698);
    antlrcpp::downCast<NamedWindowContext *>(_localctx)->name = errorCapturingIdentifier();
    setState(3699);
    match(fugue_sqlParser::AS);
    setState(3700);
    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, 398, fugue_sqlParser::RuleWindowSpec);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3748);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 504, _ctx)) {
    case 1: {
      _localctx = _tracker.createInstance<fugue_sqlParser::WindowRefContext>(_localctx);
      enterOuterAlt(_localctx, 1);
      setState(3702);
      antlrcpp::downCast<WindowRefContext *>(_localctx)->name = errorCapturingIdentifier();
      break;
    }

    case 2: {
      _localctx = _tracker.createInstance<fugue_sqlParser::WindowRefContext>(_localctx);
      enterOuterAlt(_localctx, 2);
      setState(3703);
      match(fugue_sqlParser::T__4);
      setState(3704);
      antlrcpp::downCast<WindowRefContext *>(_localctx)->name = errorCapturingIdentifier();
      setState(3705);
      match(fugue_sqlParser::T__5);
      break;
    }

    case 3: {
      _localctx = _tracker.createInstance<fugue_sqlParser::WindowDefContext>(_localctx);
      enterOuterAlt(_localctx, 3);
      setState(3707);
      match(fugue_sqlParser::T__4);
      setState(3742);
      _errHandler->sync(this);
      switch (_input->LA(1)) {
        case fugue_sqlParser::CLUSTER: {
          setState(3708);
          match(fugue_sqlParser::CLUSTER);
          setState(3709);
          match(fugue_sqlParser::BY);
          setState(3710);
          antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
          antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
          setState(3715);
          _errHandler->sync(this);
          _la = _input->LA(1);
          while (_la == fugue_sqlParser::T__1) {
            setState(3711);
            match(fugue_sqlParser::T__1);
            setState(3712);
            antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
            antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
            setState(3717);
            _errHandler->sync(this);
            _la = _input->LA(1);
          }
          break;
        }

        case fugue_sqlParser::T__5:
        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(3728);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::DISTRIBUTE || _la == fugue_sqlParser::PARTITION) {
            setState(3718);
            _la = _input->LA(1);
            if (!(_la == fugue_sqlParser::DISTRIBUTE || _la == fugue_sqlParser::PARTITION)) {
            _errHandler->recoverInline(this);
            }
            else {
              _errHandler->reportMatch(this);
              consume();
            }
            setState(3719);
            match(fugue_sqlParser::BY);
            setState(3720);
            antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
            antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
            setState(3725);
            _errHandler->sync(this);
            _la = _input->LA(1);
            while (_la == fugue_sqlParser::T__1) {
              setState(3721);
              match(fugue_sqlParser::T__1);
              setState(3722);
              antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext = expression();
              antlrcpp::downCast<WindowDefContext *>(_localctx)->partition.push_back(antlrcpp::downCast<WindowDefContext *>(_localctx)->expressionContext);
              setState(3727);
              _errHandler->sync(this);
              _la = _input->LA(1);
            }
          }
          setState(3740);
          _errHandler->sync(this);

          _la = _input->LA(1);
          if (_la == fugue_sqlParser::ORDER

          || _la == fugue_sqlParser::SORT) {
            setState(3730);
            _la = _input->LA(1);
            if (!(_la == fugue_sqlParser::ORDER

            || _la == fugue_sqlParser::SORT)) {
            _errHandler->recoverInline(this);
            }
            else {
              _errHandler->reportMatch(this);
              consume();
            }
            setState(3731);
            match(fugue_sqlParser::BY);
            setState(3732);
            sortItem();
            setState(3737);
            _errHandler->sync(this);
            _la = _input->LA(1);
            while (_la == fugue_sqlParser::T__1) {
              setState(3733);
              match(fugue_sqlParser::T__1);
              setState(3734);
              sortItem();
              setState(3739);
              _errHandler->sync(this);
              _la = _input->LA(1);
            }
          }
          break;
        }

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::RANGE

      || _la == fugue_sqlParser::ROWS) {
        setState(3744);
        windowFrame();
      }
      setState(3747);
      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;
}

//----------------- 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, 400, fugue_sqlParser::RuleWindowFrame);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3766);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 505, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3750);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::RANGE);
      setState(3751);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      break;
    }

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3752);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::ROWS);
      setState(3753);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3754);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::RANGE);
      setState(3755);
      match(fugue_sqlParser::BETWEEN);
      setState(3756);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      setState(3757);
      match(fugue_sqlParser::AND);
      setState(3758);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->end = frameBound();
      break;
    }

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3760);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->frameType = match(fugue_sqlParser::ROWS);
      setState(3761);
      match(fugue_sqlParser::BETWEEN);
      setState(3762);
      antlrcpp::downCast<WindowFrameContext *>(_localctx)->start = frameBound();
      setState(3763);
      match(fugue_sqlParser::AND);
      setState(3764);
      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, 402, fugue_sqlParser::RuleFrameBound);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3775);
    _errHandler->sync(this);
    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 506, _ctx)) {
    case 1: {
      enterOuterAlt(_localctx, 1);
      setState(3768);
      match(fugue_sqlParser::UNBOUNDED);
      setState(3769);
      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(3770);
      antlrcpp::downCast<FrameBoundContext *>(_localctx)->boundType = match(fugue_sqlParser::CURRENT);
      setState(3771);
      match(fugue_sqlParser::ROW);
      break;
    }

    case 3: {
      enterOuterAlt(_localctx, 3);
      setState(3772);
      expression();
      setState(3773);
      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, 404, 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(3777);
    qualifiedName();
    setState(3782);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == fugue_sqlParser::T__1) {
      setState(3778);
      match(fugue_sqlParser::T__1);
      setState(3779);
      qualifiedName();
      setState(3784);
      _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, 406, fugue_sqlParser::RuleFunctionName);

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

    case 2: {
      enterOuterAlt(_localctx, 2);
      setState(3786);
      match(fugue_sqlParser::FILTER);
      break;
    }

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

    case 4: {
      enterOuterAlt(_localctx, 4);
      setState(3788);
      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, 408, fugue_sqlParser::RuleQualifiedName);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(3791);
    identifier();
    setState(3796);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 509, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        setState(3792);
        match(fugue_sqlParser::T__6);
        setState(3793);
        identifier(); 
      }
      setState(3798);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 509, _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, 410, fugue_sqlParser::RuleErrorCapturingIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(3799);
    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, 412, 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(3803); 
    _errHandler->sync(this);
    _la = _input->LA(1);
    do {
      setState(3801);
      match(fugue_sqlParser::MINUS);
      setState(3802);
      identifier();
      setState(3805); 
      _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, 414, fugue_sqlParser::RuleIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3809);
    _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(3807);
        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(3808);
        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, 416, fugue_sqlParser::RuleStrictIdentifier);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(3814);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case fugue_sqlParser::IDENTIFIER: {
        _localctx = _tracker.createInstance<fugue_sqlParser::UnquotedIdentifierContext>(_localctx);
        enterOuterAlt(_localctx, 1);
        setState(3811);
        match(fugue_sqlParser::IDENTIFIER);
        break;
      }

      case fugue_sqlParser::BACKQUOTED_IDENTIFIER: {
        _localctx = _tracker.createInstance<fugue_sqlParser::QuotedIdentifierAlternativeContext>(_localctx);
        enterOuterAlt(_localctx, 2);
        setState(3812);
        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(3813);
        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, 418, fugue_sqlParser::RuleQuotedIdentifier);

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

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3818);
        match(fugue_sqlParser::MINUS);
      }
      setState(3821);
      match(fugue_sqlParser::EXPONENT_VALUE);
      break;
    }

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

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

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

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3826);
        match(fugue_sqlParser::MINUS);
      }
      setState(3829);
      _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(3831);
      _errHandler->sync(this);

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

    case 5: {
      _localctx = _tracker.createInstance<fugue_sqlParser::BigIntLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 5);
      setState(3835);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3834);
        match(fugue_sqlParser::MINUS);
      }
      setState(3837);
      match(fugue_sqlParser::BIGINT_LITERAL);
      break;
    }

    case 6: {
      _localctx = _tracker.createInstance<fugue_sqlParser::SmallIntLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 6);
      setState(3839);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3838);
        match(fugue_sqlParser::MINUS);
      }
      setState(3841);
      match(fugue_sqlParser::SMALLINT_LITERAL);
      break;
    }

    case 7: {
      _localctx = _tracker.createInstance<fugue_sqlParser::TinyIntLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 7);
      setState(3843);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3842);
        match(fugue_sqlParser::MINUS);
      }
      setState(3845);
      match(fugue_sqlParser::TINYINT_LITERAL);
      break;
    }

    case 8: {
      _localctx = _tracker.createInstance<fugue_sqlParser::DoubleLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 8);
      setState(3847);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3846);
        match(fugue_sqlParser::MINUS);
      }
      setState(3849);
      match(fugue_sqlParser::DOUBLE_LITERAL);
      break;
    }

    case 9: {
      _localctx = _tracker.createInstance<fugue_sqlParser::BigDecimalLiteralContext>(_localctx);
      enterOuterAlt(_localctx, 9);
      setState(3851);
      _errHandler->sync(this);

      _la = _input->LA(1);
      if (_la == fugue_sqlParser::MINUS) {
        setState(3850);
        match(fugue_sqlParser::MINUS);
      }
      setState(3853);
      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, 422, fugue_sqlParser::RuleAlterColumnAction);
  size_t _la = 0;

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

      case fugue_sqlParser::COMMENT: {
        enterOuterAlt(_localctx, 2);
        setState(3858);
        commentSpec();
        break;
      }

      case fugue_sqlParser::AFTER:
      case fugue_sqlParser::FIRST: {
        enterOuterAlt(_localctx, 3);
        setState(3859);
        colPosition();
        break;
      }

      case fugue_sqlParser::DROP:
      case fugue_sqlParser::SET: {
        enterOuterAlt(_localctx, 4);
        setState(3860);
        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(3861);
        match(fugue_sqlParser::NOT);
        setState(3862);
        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, 424, 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(3865);
    _la = _input->LA(1);
    if (!((((_la - 58) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 58)) & -4616724533169136869) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 122)) & -54836095400108079) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 186)) & -72339344050251969) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 250)) & 176704157053345137) != 0 || _la == fugue_sqlParser::DIV)) {
    _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, 426, 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(3867);
    _la = _input->LA(1);
    if (!((((_la - 64) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 64)) & -9223371968135299071) != 0 || (((_la - 147) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 147)) & 73183495035846657) != 0 || (((_la - 242) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 242)) & 578712552117241857) != 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, 428, 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(3869);
    _la = _input->LA(1);
    if (!((((_la - 58) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 58)) & -4398046511169) != 0 || (((_la - 122) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 122)) & -36610438703611937) != 0 || (((_la - 186) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 186)) & -72057594038061057) != 0 || (((_la - 250) & ~ 0x3fULL) == 0) &&
      ((1ULL << (_la - 250)) & 1150660908700138999) != 0 || _la == fugue_sqlParser::DIV)) {
    _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 48: return fuguePartitionNumSempred(antlrcpp::downCast<FuguePartitionNumContext *>(context), predicateIndex);
    case 116: return queryTermSempred(antlrcpp::downCast<QueryTermContext *>(context), predicateIndex);
    case 171: return booleanExpressionSempred(antlrcpp::downCast<BooleanExpressionContext *>(context), predicateIndex);
    case 173: return valueExpressionSempred(antlrcpp::downCast<ValueExpressionContext *>(context), predicateIndex);
    case 174: 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() {
  ::antlr4::internal::call_once(fugue_sqlParserOnceFlag, fugue_sqlParserInitialize);
}
