// Generated from dt-sql-parser/src/grammar/spark/SparkSqlParser.g4 by ANTLR 4.9.0-SNAPSHOT


import { ATN } from "antlr4ts/atn/ATN";
import { ATNDeserializer } from "antlr4ts/atn/ATNDeserializer";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { NotNull } from "antlr4ts/Decorators";
import { NoViableAltException } from "antlr4ts/NoViableAltException";
import { Override } from "antlr4ts/Decorators";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { ParserATNSimulator } from "antlr4ts/atn/ParserATNSimulator";
import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener";
import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor";
import { RecognitionException } from "antlr4ts/RecognitionException";
import { RuleContext } from "antlr4ts/RuleContext";
//import { RuleVersion } from "antlr4ts/RuleVersion";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { Token } from "antlr4ts/Token";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { VocabularyImpl } from "antlr4ts/VocabularyImpl";

import * as Utils from "antlr4ts/misc/Utils";

import { SparkSqlParserListener } from "./SparkSqlParserListener";
import { SparkSqlParserVisitor } from "./SparkSqlParserVisitor";


export class SparkSqlParser extends Parser {
	public static readonly SEMICOLON = 1;
	public static readonly LEFT_PAREN = 2;
	public static readonly RIGHT_PAREN = 3;
	public static readonly COMMA = 4;
	public static readonly DOT = 5;
	public static readonly LEFT_BRACKET = 6;
	public static readonly RIGHT_BRACKET = 7;
	public static readonly KW_ADD = 8;
	public static readonly KW_AFTER = 9;
	public static readonly KW_ALL = 10;
	public static readonly KW_ALTER = 11;
	public static readonly KW_ALWAYS = 12;
	public static readonly KW_ANALYZE = 13;
	public static readonly KW_AND = 14;
	public static readonly KW_ANTI = 15;
	public static readonly KW_ANY = 16;
	public static readonly KW_ANY_VALUE = 17;
	public static readonly KW_ARCHIVE = 18;
	public static readonly KW_ARRAY = 19;
	public static readonly KW_AS = 20;
	public static readonly KW_ASC = 21;
	public static readonly KW_AT = 22;
	public static readonly KW_AUTHORIZATION = 23;
	public static readonly KW_BETWEEN = 24;
	public static readonly KW_BIGINT = 25;
	public static readonly KW_BINARY = 26;
	public static readonly KW_BOOLEAN = 27;
	public static readonly KW_BOTH = 28;
	public static readonly KW_BUCKET = 29;
	public static readonly KW_BUCKETS = 30;
	public static readonly KW_BY = 31;
	public static readonly KW_BYTE = 32;
	public static readonly KW_CACHE = 33;
	public static readonly KW_CASCADE = 34;
	public static readonly KW_CASE = 35;
	public static readonly KW_CAST = 36;
	public static readonly KW_CATALOG = 37;
	public static readonly KW_CATALOGS = 38;
	public static readonly KW_CHANGE = 39;
	public static readonly KW_CHAR = 40;
	public static readonly KW_CHARACTER = 41;
	public static readonly KW_CHECK = 42;
	public static readonly KW_CLEAR = 43;
	public static readonly KW_CLUSTER = 44;
	public static readonly KW_CLUSTERED = 45;
	public static readonly KW_CODEGEN = 46;
	public static readonly KW_COLLATE = 47;
	public static readonly KW_COLLECTION = 48;
	public static readonly KW_COLUMN = 49;
	public static readonly KW_COLUMNS = 50;
	public static readonly KW_COMMENT = 51;
	public static readonly KW_COMMIT = 52;
	public static readonly KW_COMPACT = 53;
	public static readonly KW_COMPACTIONS = 54;
	public static readonly KW_COMPUTE = 55;
	public static readonly KW_CONCATENATE = 56;
	public static readonly KW_CONSTRAINT = 57;
	public static readonly KW_COST = 58;
	public static readonly KW_CREATE = 59;
	public static readonly KW_CROSS = 60;
	public static readonly KW_CUBE = 61;
	public static readonly KW_CURRENT = 62;
	public static readonly KW_CURRENT_DATE = 63;
	public static readonly KW_CURRENT_TIME = 64;
	public static readonly KW_CURRENT_TIMESTAMP = 65;
	public static readonly KW_CURRENT_USER = 66;
	public static readonly KW_DAY = 67;
	public static readonly KW_DAYS = 68;
	public static readonly KW_DAYOFYEAR = 69;
	public static readonly KW_DATA = 70;
	public static readonly KW_DATE = 71;
	public static readonly KW_DATABASE = 72;
	public static readonly KW_DATABASES = 73;
	public static readonly KW_DATEADD = 74;
	public static readonly KW_DATE_ADD = 75;
	public static readonly KW_DATEDIFF = 76;
	public static readonly KW_DATE_DIFF = 77;
	public static readonly KW_DBPROPERTIES = 78;
	public static readonly KW_DEC = 79;
	public static readonly KW_DECIMAL = 80;
	public static readonly KW_DECLARE = 81;
	public static readonly KW_DEFAULT = 82;
	public static readonly KW_DEFINED = 83;
	public static readonly KW_DELETE = 84;
	public static readonly KW_DELIMITED = 85;
	public static readonly KW_DESC = 86;
	public static readonly KW_DESCRIBE = 87;
	public static readonly KW_DFS = 88;
	public static readonly KW_DIRECTORIES = 89;
	public static readonly KW_DIRECTORY = 90;
	public static readonly KW_DISTINCT = 91;
	public static readonly KW_DISTRIBUTE = 92;
	public static readonly KW_DIV = 93;
	public static readonly KW_DOUBLE = 94;
	public static readonly KW_DROP = 95;
	public static readonly KW_ELSE = 96;
	public static readonly KW_END = 97;
	public static readonly KW_ESCAPE = 98;
	public static readonly KW_ESCAPED = 99;
	public static readonly KW_EXCEPT = 100;
	public static readonly KW_EXCHANGE = 101;
	public static readonly KW_EXCLUDE = 102;
	public static readonly KW_EXISTS = 103;
	public static readonly KW_EXPLAIN = 104;
	public static readonly KW_EXPORT = 105;
	public static readonly KW_EXTENDED = 106;
	public static readonly KW_EXTERNAL = 107;
	public static readonly KW_EXTRACT = 108;
	public static readonly KW_FALSE = 109;
	public static readonly KW_FETCH = 110;
	public static readonly KW_FIELDS = 111;
	public static readonly KW_FILTER = 112;
	public static readonly KW_FILEFORMAT = 113;
	public static readonly KW_FIRST = 114;
	public static readonly KW_FLOAT = 115;
	public static readonly KW_FOLLOWING = 116;
	public static readonly KW_FOR = 117;
	public static readonly KW_FOREIGN = 118;
	public static readonly KW_FORMAT = 119;
	public static readonly KW_FORMATTED = 120;
	public static readonly KW_FROM = 121;
	public static readonly KW_FULL = 122;
	public static readonly KW_FUNCTION = 123;
	public static readonly KW_FUNCTIONS = 124;
	public static readonly KW_GENERATED = 125;
	public static readonly KW_GLOBAL = 126;
	public static readonly KW_GRANT = 127;
	public static readonly KW_GROUP = 128;
	public static readonly KW_GROUPING = 129;
	public static readonly KW_HAVING = 130;
	public static readonly KW_BINARY_HEX = 131;
	public static readonly KW_HOUR = 132;
	public static readonly KW_HOURS = 133;
	public static readonly KW_IDENTIFIER = 134;
	public static readonly KW_IF = 135;
	public static readonly KW_IGNORE = 136;
	public static readonly KW_IMPORT = 137;
	public static readonly KW_IN = 138;
	public static readonly KW_INCLUDE = 139;
	public static readonly KW_INDEX = 140;
	public static readonly KW_INDEXES = 141;
	public static readonly KW_INNER = 142;
	public static readonly KW_INPATH = 143;
	public static readonly KW_INPUTFORMAT = 144;
	public static readonly KW_INSERT = 145;
	public static readonly KW_INTERSECT = 146;
	public static readonly KW_INTERVAL = 147;
	public static readonly KW_INT = 148;
	public static readonly KW_INTEGER = 149;
	public static readonly KW_INTO = 150;
	public static readonly KW_IS = 151;
	public static readonly KW_ITEMS = 152;
	public static readonly KW_JOIN = 153;
	public static readonly KW_KEYS = 154;
	public static readonly KW_LAST = 155;
	public static readonly KW_LATERAL = 156;
	public static readonly KW_LAZY = 157;
	public static readonly KW_LEADING = 158;
	public static readonly KW_LEFT = 159;
	public static readonly KW_LIKE = 160;
	public static readonly KW_ILIKE = 161;
	public static readonly KW_LIMIT = 162;
	public static readonly KW_LINES = 163;
	public static readonly KW_LIST = 164;
	public static readonly KW_LOAD = 165;
	public static readonly KW_LOCAL = 166;
	public static readonly KW_LOCATION = 167;
	public static readonly KW_LOCK = 168;
	public static readonly KW_LOCKS = 169;
	public static readonly KW_LOGICAL = 170;
	public static readonly KW_LONG = 171;
	public static readonly KW_MACRO = 172;
	public static readonly KW_MAP = 173;
	public static readonly KW_MATCHED = 174;
	public static readonly KW_MERGE = 175;
	public static readonly KW_MICROSECOND = 176;
	public static readonly KW_MICROSECONDS = 177;
	public static readonly KW_MILLISECOND = 178;
	public static readonly KW_MILLISECONDS = 179;
	public static readonly KW_MINUTE = 180;
	public static readonly KW_MINUTES = 181;
	public static readonly KW_MONTH = 182;
	public static readonly KW_MONTHS = 183;
	public static readonly KW_MSCK = 184;
	public static readonly KW_NAME = 185;
	public static readonly KW_NAMESPACE = 186;
	public static readonly KW_NAMESPACES = 187;
	public static readonly KW_NANOSECOND = 188;
	public static readonly KW_NANOSECONDS = 189;
	public static readonly KW_NATURAL = 190;
	public static readonly KW_NO = 191;
	public static readonly KW_NOSCAN = 192;
	public static readonly KW_NOT = 193;
	public static readonly KW_NULL = 194;
	public static readonly KW_NULLS = 195;
	public static readonly KW_NUMERIC = 196;
	public static readonly KW_OF = 197;
	public static readonly KW_OFFSET = 198;
	public static readonly KW_ON = 199;
	public static readonly KW_ONLY = 200;
	public static readonly KW_OPTION = 201;
	public static readonly KW_OPTIONS = 202;
	public static readonly KW_OR = 203;
	public static readonly KW_ORDER = 204;
	public static readonly KW_OUT = 205;
	public static readonly KW_OUTER = 206;
	public static readonly KW_OUTPUTFORMAT = 207;
	public static readonly KW_OVER = 208;
	public static readonly KW_OVERLAPS = 209;
	public static readonly KW_OVERLAY = 210;
	public static readonly KW_OVERWRITE = 211;
	public static readonly KW_PARTITION = 212;
	public static readonly KW_PARTITIONED = 213;
	public static readonly KW_PARTITIONS = 214;
	public static readonly KW_PERCENTILE_CONT = 215;
	public static readonly KW_PERCENTILE_DISC = 216;
	public static readonly KW_PERCENTLIT = 217;
	public static readonly KW_PIVOT = 218;
	public static readonly KW_PLACING = 219;
	public static readonly KW_POSITION = 220;
	public static readonly KW_PRECEDING = 221;
	public static readonly KW_PRIMARY = 222;
	public static readonly KW_PRINCIPALS = 223;
	public static readonly KW_PROPERTIES = 224;
	public static readonly KW_PURGE = 225;
	public static readonly KW_QUARTER = 226;
	public static readonly KW_QUERY = 227;
	public static readonly KW_RANGE = 228;
	public static readonly KW_REAL = 229;
	public static readonly KW_RECORDREADER = 230;
	public static readonly KW_RECORDWRITER = 231;
	public static readonly KW_RECOVER = 232;
	public static readonly KW_REDUCE = 233;
	public static readonly KW_REFERENCES = 234;
	public static readonly KW_REFRESH = 235;
	public static readonly KW_RENAME = 236;
	public static readonly KW_REPAIR = 237;
	public static readonly KW_REPEATABLE = 238;
	public static readonly KW_REPLACE = 239;
	public static readonly KW_RESET = 240;
	public static readonly KW_RESPECT = 241;
	public static readonly KW_RESTRICT = 242;
	public static readonly KW_REVOKE = 243;
	public static readonly KW_RIGHT = 244;
	public static readonly KW_RLIKE = 245;
	public static readonly KW_REGEXP = 246;
	public static readonly KW_ROLE = 247;
	public static readonly KW_ROLES = 248;
	public static readonly KW_ROLLBACK = 249;
	public static readonly KW_ROLLUP = 250;
	public static readonly KW_ROW = 251;
	public static readonly KW_ROWS = 252;
	public static readonly KW_SECOND = 253;
	public static readonly KW_SECONDS = 254;
	public static readonly KW_SCHEMA = 255;
	public static readonly KW_SCHEMAS = 256;
	public static readonly KW_SELECT = 257;
	public static readonly KW_SEMI = 258;
	public static readonly KW_SEPARATED = 259;
	public static readonly KW_SERDE = 260;
	public static readonly KW_SERDEPROPERTIES = 261;
	public static readonly KW_SESSION_USER = 262;
	public static readonly KW_SET = 263;
	public static readonly KW_MINUS = 264;
	public static readonly KW_SETS = 265;
	public static readonly KW_SHORT = 266;
	public static readonly KW_SHOW = 267;
	public static readonly KW_SINGLE = 268;
	public static readonly KW_SKEWED = 269;
	public static readonly KW_SMALLINT = 270;
	public static readonly KW_SOME = 271;
	public static readonly KW_SORT = 272;
	public static readonly KW_SORTED = 273;
	public static readonly KW_SOURCE = 274;
	public static readonly KW_START = 275;
	public static readonly KW_STATISTICS = 276;
	public static readonly KW_STORED = 277;
	public static readonly KW_STRATIFY = 278;
	public static readonly KW_STRING = 279;
	public static readonly KW_STRUCT = 280;
	public static readonly KW_SUBSTR = 281;
	public static readonly KW_SUBSTRING = 282;
	public static readonly KW_SYNC = 283;
	public static readonly KW_SYSTEM = 284;
	public static readonly KW_SYSTEM_TIME = 285;
	public static readonly KW_SYSTEM_VERSION = 286;
	public static readonly KW_TABLE = 287;
	public static readonly KW_TABLES = 288;
	public static readonly KW_TABLESAMPLE = 289;
	public static readonly KW_TARGET = 290;
	public static readonly KW_TBLPROPERTIES = 291;
	public static readonly KW_TEMPORARY = 292;
	public static readonly KW_TERMINATED = 293;
	public static readonly KW_THEN = 294;
	public static readonly KW_TIME = 295;
	public static readonly KW_TIMEDIFF = 296;
	public static readonly KW_TIMESTAMP = 297;
	public static readonly KW_TIMESTAMP_LTZ = 298;
	public static readonly KW_TIMESTAMP_NTZ = 299;
	public static readonly KW_TIMESTAMPADD = 300;
	public static readonly KW_TIMESTAMPDIFF = 301;
	public static readonly KW_TINYINT = 302;
	public static readonly KW_TO = 303;
	public static readonly KW_TOUCH = 304;
	public static readonly KW_TRAILING = 305;
	public static readonly KW_TRANSACTION = 306;
	public static readonly KW_TRANSACTIONS = 307;
	public static readonly KW_TRANSFORM = 308;
	public static readonly KW_TRIM = 309;
	public static readonly KW_TRUE = 310;
	public static readonly KW_TRUNCATE = 311;
	public static readonly KW_TRY_CAST = 312;
	public static readonly KW_TYPE = 313;
	public static readonly KW_UNARCHIVE = 314;
	public static readonly KW_UNBOUNDED = 315;
	public static readonly KW_UNCACHE = 316;
	public static readonly KW_UNION = 317;
	public static readonly KW_UNIQUE = 318;
	public static readonly KW_UNKNOWN = 319;
	public static readonly KW_UNLOCK = 320;
	public static readonly KW_UNPIVOT = 321;
	public static readonly KW_UNSET = 322;
	public static readonly KW_UPDATE = 323;
	public static readonly KW_USE = 324;
	public static readonly KW_USER = 325;
	public static readonly KW_USING = 326;
	public static readonly KW_VALUES = 327;
	public static readonly KW_VARCHAR = 328;
	public static readonly KW_VAR = 329;
	public static readonly KW_VARIABLE = 330;
	public static readonly KW_VERSION = 331;
	public static readonly KW_VIEW = 332;
	public static readonly KW_VIEWS = 333;
	public static readonly KW_VOID = 334;
	public static readonly KW_WEEK = 335;
	public static readonly KW_WEEKS = 336;
	public static readonly KW_WHEN = 337;
	public static readonly KW_WHERE = 338;
	public static readonly KW_WINDOW = 339;
	public static readonly KW_WITH = 340;
	public static readonly KW_WITHIN = 341;
	public static readonly KW_YEAR = 342;
	public static readonly KW_YEARS = 343;
	public static readonly KW_ZONE = 344;
	public static readonly EQ = 345;
	public static readonly NSEQ = 346;
	public static readonly NEQ = 347;
	public static readonly NEQJ = 348;
	public static readonly LT = 349;
	public static readonly LTE = 350;
	public static readonly GT = 351;
	public static readonly GTE = 352;
	public static readonly NOT = 353;
	public static readonly PLUS = 354;
	public static readonly MINUS = 355;
	public static readonly ASTERISK = 356;
	public static readonly SLASH = 357;
	public static readonly PERCENT = 358;
	public static readonly TILDE = 359;
	public static readonly AMPERSAND = 360;
	public static readonly PIPE = 361;
	public static readonly CONCAT_PIPE = 362;
	public static readonly HAT = 363;
	public static readonly COLON = 364;
	public static readonly ARROW = 365;
	public static readonly FAT_ARROW = 366;
	public static readonly HENT_START = 367;
	public static readonly HENT_END = 368;
	public static readonly QUESTION = 369;
	public static readonly STRING_LITERAL = 370;
	public static readonly DOUBLEQUOTED_STRING = 371;
	public static readonly BIGINT_LITERAL = 372;
	public static readonly SMALLINT_LITERAL = 373;
	public static readonly TINYINT_LITERAL = 374;
	public static readonly INTEGER_VALUE = 375;
	public static readonly EXPONENT_VALUE = 376;
	public static readonly DECIMAL_VALUE = 377;
	public static readonly FLOAT_LITERAL = 378;
	public static readonly DOUBLE_LITERAL = 379;
	public static readonly BIGDECIMAL_LITERAL = 380;
	public static readonly IDENTIFIER = 381;
	public static readonly BACKQUOTED_IDENTIFIER = 382;
	public static readonly SIMPLE_COMMENT = 383;
	public static readonly BRACKETED_COMMENT = 384;
	public static readonly WS = 385;
	public static readonly UNRECOGNIZED = 386;
	public static readonly RULE_program = 0;
	public static readonly RULE_singleStatement = 1;
	public static readonly RULE_statement = 2;
	public static readonly RULE_timezone = 3;
	public static readonly RULE_configKey = 4;
	public static readonly RULE_configValue = 5;
	public static readonly RULE_unsupportedHiveNativeCommands = 6;
	public static readonly RULE_createTableHeader = 7;
	public static readonly RULE_replaceTableHeader = 8;
	public static readonly RULE_bucketSpec = 9;
	public static readonly RULE_skewSpec = 10;
	public static readonly RULE_locationSpec = 11;
	public static readonly RULE_commentSpec = 12;
	public static readonly RULE_query = 13;
	public static readonly RULE_insertInto = 14;
	public static readonly RULE_partitionSpecLocation = 15;
	public static readonly RULE_partitionSpec = 16;
	public static readonly RULE_partitionVal = 17;
	public static readonly RULE_dbSchema = 18;
	public static readonly RULE_dbSchemas = 19;
	public static readonly RULE_describeFuncName = 20;
	public static readonly RULE_describeColName = 21;
	public static readonly RULE_ctes = 22;
	public static readonly RULE_namedQuery = 23;
	public static readonly RULE_tableProvider = 24;
	public static readonly RULE_createTableClauses = 25;
	public static readonly RULE_propertyList = 26;
	public static readonly RULE_property = 27;
	public static readonly RULE_propertyKey = 28;
	public static readonly RULE_propertyValue = 29;
	public static readonly RULE_expressionPropertyList = 30;
	public static readonly RULE_expressionProperty = 31;
	public static readonly RULE_constantList = 32;
	public static readonly RULE_nestedConstantList = 33;
	public static readonly RULE_createFileFormat = 34;
	public static readonly RULE_fileFormat = 35;
	public static readonly RULE_storageHandler = 36;
	public static readonly RULE_resource = 37;
	public static readonly RULE_dmlStatementNoWith = 38;
	public static readonly RULE_dbSchemaName = 39;
	public static readonly RULE_dbSchemaNameCreate = 40;
	public static readonly RULE_tableNameCreate = 41;
	public static readonly RULE_tableName = 42;
	public static readonly RULE_viewNameCreate = 43;
	public static readonly RULE_viewName = 44;
	public static readonly RULE_columnName = 45;
	public static readonly RULE_columnNameSeq = 46;
	public static readonly RULE_columnNameCreate = 47;
	public static readonly RULE_identifierReference = 48;
	public static readonly RULE_queryOrganization = 49;
	public static readonly RULE_multiInsertQueryBody = 50;
	public static readonly RULE_queryTerm = 51;
	public static readonly RULE_queryPrimary = 52;
	public static readonly RULE_sortItem = 53;
	public static readonly RULE_fromStatement = 54;
	public static readonly RULE_fromStatementBody = 55;
	public static readonly RULE_querySpecification = 56;
	public static readonly RULE_transformClause = 57;
	public static readonly RULE_selectClause = 58;
	public static readonly RULE_setClause = 59;
	public static readonly RULE_matchedClause = 60;
	public static readonly RULE_notMatchedClause = 61;
	public static readonly RULE_notMatchedBySourceClause = 62;
	public static readonly RULE_matchedAction = 63;
	public static readonly RULE_notMatchedAction = 64;
	public static readonly RULE_notMatchedBySourceAction = 65;
	public static readonly RULE_assignmentList = 66;
	public static readonly RULE_assignment = 67;
	public static readonly RULE_whereClause = 68;
	public static readonly RULE_havingClause = 69;
	public static readonly RULE_hint = 70;
	public static readonly RULE_hintStatement = 71;
	public static readonly RULE_fromClause = 72;
	public static readonly RULE_functionKind = 73;
	public static readonly RULE_temporalClause = 74;
	public static readonly RULE_aggregationClause = 75;
	public static readonly RULE_groupByClause = 76;
	public static readonly RULE_groupingAnalytics = 77;
	public static readonly RULE_groupingElement = 78;
	public static readonly RULE_groupingSet = 79;
	public static readonly RULE_pivotClause = 80;
	public static readonly RULE_pivotColumn = 81;
	public static readonly RULE_pivotValue = 82;
	public static readonly RULE_unpivotClause = 83;
	public static readonly RULE_unpivotNullClause = 84;
	public static readonly RULE_unpivotOperator = 85;
	public static readonly RULE_unpivotSingleValueColumnClause = 86;
	public static readonly RULE_unpivotMultiValueColumnClause = 87;
	public static readonly RULE_unpivotColumnSet = 88;
	public static readonly RULE_unpivotValueColumn = 89;
	public static readonly RULE_unpivotNameColumn = 90;
	public static readonly RULE_unpivotColumnAndAlias = 91;
	public static readonly RULE_unpivotColumn = 92;
	public static readonly RULE_unpivotAlias = 93;
	public static readonly RULE_ifNotExists = 94;
	public static readonly RULE_ifExists = 95;
	public static readonly RULE_lateralView = 96;
	public static readonly RULE_setQuantifier = 97;
	public static readonly RULE_relation = 98;
	public static readonly RULE_relationExtension = 99;
	public static readonly RULE_joinRelation = 100;
	public static readonly RULE_joinType = 101;
	public static readonly RULE_joinCriteria = 102;
	public static readonly RULE_sample = 103;
	public static readonly RULE_sampleMethod = 104;
	public static readonly RULE_identifierList = 105;
	public static readonly RULE_identifierSeq = 106;
	public static readonly RULE_orderedIdentifierList = 107;
	public static readonly RULE_orderedIdentifier = 108;
	public static readonly RULE_identifierCommentList = 109;
	public static readonly RULE_identifierComment = 110;
	public static readonly RULE_relationPrimary = 111;
	public static readonly RULE_inlineTable = 112;
	public static readonly RULE_functionTableSubqueryArgument = 113;
	public static readonly RULE_tableArgumentPartitioning = 114;
	public static readonly RULE_functionTableNamedArgumentExpression = 115;
	public static readonly RULE_functionTableReferenceArgument = 116;
	public static readonly RULE_functionTableArgument = 117;
	public static readonly RULE_functionTable = 118;
	public static readonly RULE_tableAlias = 119;
	public static readonly RULE_rowFormat = 120;
	public static readonly RULE_multipartIdentifierList = 121;
	public static readonly RULE_multipartIdentifier = 122;
	public static readonly RULE_multipartIdentifierPropertyList = 123;
	public static readonly RULE_multipartIdentifierProperty = 124;
	public static readonly RULE_tableIdentifier = 125;
	public static readonly RULE_viewIdentifier = 126;
	public static readonly RULE_namedExpression = 127;
	public static readonly RULE_namedExpressionSeq = 128;
	public static readonly RULE_partitionFieldList = 129;
	public static readonly RULE_partitionField = 130;
	public static readonly RULE_transform = 131;
	public static readonly RULE_transformArgument = 132;
	public static readonly RULE_expression = 133;
	public static readonly RULE_namedArgumentExpression = 134;
	public static readonly RULE_functionArgument = 135;
	public static readonly RULE_expressionSeq = 136;
	public static readonly RULE_booleanExpression = 137;
	public static readonly RULE_predicate = 138;
	public static readonly RULE_valueExpression = 139;
	public static readonly RULE_datetimeUnit = 140;
	public static readonly RULE_primaryExpression = 141;
	public static readonly RULE_literalType = 142;
	public static readonly RULE_constant = 143;
	public static readonly RULE_comparisonOperator = 144;
	public static readonly RULE_arithmeticOperator = 145;
	public static readonly RULE_predicateOperator = 146;
	public static readonly RULE_booleanValue = 147;
	public static readonly RULE_interval = 148;
	public static readonly RULE_errorCapturingMultiUnitsInterval = 149;
	public static readonly RULE_multiUnitsInterval = 150;
	public static readonly RULE_errorCapturingUnitToUnitInterval = 151;
	public static readonly RULE_unitToUnitInterval = 152;
	public static readonly RULE_intervalValue = 153;
	public static readonly RULE_unitInMultiUnits = 154;
	public static readonly RULE_unitInUnitToUnit = 155;
	public static readonly RULE_colPosition = 156;
	public static readonly RULE_type = 157;
	public static readonly RULE_dataType = 158;
	public static readonly RULE_qualifiedColTypeWithPositionSeqForAdd = 159;
	public static readonly RULE_qualifiedColTypeWithPositionForAdd = 160;
	public static readonly RULE_qualifiedColTypeWithPositionSeqForReplace = 161;
	public static readonly RULE_qualifiedColTypeWithPositionForReplace = 162;
	public static readonly RULE_colDefinitionDescriptorWithPosition = 163;
	public static readonly RULE_defaultExpression = 164;
	public static readonly RULE_variableDefaultExpression = 165;
	public static readonly RULE_colTypeList = 166;
	public static readonly RULE_colType = 167;
	public static readonly RULE_createOrReplaceTableColTypeList = 168;
	public static readonly RULE_createOrReplaceTableColType = 169;
	public static readonly RULE_colDefinitionOption = 170;
	public static readonly RULE_generationExpression = 171;
	public static readonly RULE_complexColTypeList = 172;
	public static readonly RULE_complexColType = 173;
	public static readonly RULE_whenClause = 174;
	public static readonly RULE_windowClause = 175;
	public static readonly RULE_namedWindow = 176;
	public static readonly RULE_windowSpec = 177;
	public static readonly RULE_windowFrame = 178;
	public static readonly RULE_frameBound = 179;
	public static readonly RULE_qualifiedNameList = 180;
	public static readonly RULE_functionName = 181;
	public static readonly RULE_functionNameCreate = 182;
	public static readonly RULE_qualifiedName = 183;
	public static readonly RULE_errorCapturingIdentifier = 184;
	public static readonly RULE_errorCapturingIdentifierExtra = 185;
	public static readonly RULE_identifier = 186;
	public static readonly RULE_strictIdentifier = 187;
	public static readonly RULE_quotedIdentifier = 188;
	public static readonly RULE_backQuotedIdentifier = 189;
	public static readonly RULE_number = 190;
	public static readonly RULE_alterColumnAction = 191;
	public static readonly RULE_stringLit = 192;
	public static readonly RULE_comment = 193;
	public static readonly RULE_version = 194;
	public static readonly RULE_ansiNonReserved = 195;
	public static readonly RULE_strictNonReserved = 196;
	public static readonly RULE_nonReserved = 197;
	// tslint:disable:no-trailing-whitespace
	public static readonly ruleNames: string[] = [
		"program", "singleStatement", "statement", "timezone", "configKey", "configValue", 
		"unsupportedHiveNativeCommands", "createTableHeader", "replaceTableHeader", 
		"bucketSpec", "skewSpec", "locationSpec", "commentSpec", "query", "insertInto", 
		"partitionSpecLocation", "partitionSpec", "partitionVal", "dbSchema", 
		"dbSchemas", "describeFuncName", "describeColName", "ctes", "namedQuery", 
		"tableProvider", "createTableClauses", "propertyList", "property", "propertyKey", 
		"propertyValue", "expressionPropertyList", "expressionProperty", "constantList", 
		"nestedConstantList", "createFileFormat", "fileFormat", "storageHandler", 
		"resource", "dmlStatementNoWith", "dbSchemaName", "dbSchemaNameCreate", 
		"tableNameCreate", "tableName", "viewNameCreate", "viewName", "columnName", 
		"columnNameSeq", "columnNameCreate", "identifierReference", "queryOrganization", 
		"multiInsertQueryBody", "queryTerm", "queryPrimary", "sortItem", "fromStatement", 
		"fromStatementBody", "querySpecification", "transformClause", "selectClause", 
		"setClause", "matchedClause", "notMatchedClause", "notMatchedBySourceClause", 
		"matchedAction", "notMatchedAction", "notMatchedBySourceAction", "assignmentList", 
		"assignment", "whereClause", "havingClause", "hint", "hintStatement", 
		"fromClause", "functionKind", "temporalClause", "aggregationClause", "groupByClause", 
		"groupingAnalytics", "groupingElement", "groupingSet", "pivotClause", 
		"pivotColumn", "pivotValue", "unpivotClause", "unpivotNullClause", "unpivotOperator", 
		"unpivotSingleValueColumnClause", "unpivotMultiValueColumnClause", "unpivotColumnSet", 
		"unpivotValueColumn", "unpivotNameColumn", "unpivotColumnAndAlias", "unpivotColumn", 
		"unpivotAlias", "ifNotExists", "ifExists", "lateralView", "setQuantifier", 
		"relation", "relationExtension", "joinRelation", "joinType", "joinCriteria", 
		"sample", "sampleMethod", "identifierList", "identifierSeq", "orderedIdentifierList", 
		"orderedIdentifier", "identifierCommentList", "identifierComment", "relationPrimary", 
		"inlineTable", "functionTableSubqueryArgument", "tableArgumentPartitioning", 
		"functionTableNamedArgumentExpression", "functionTableReferenceArgument", 
		"functionTableArgument", "functionTable", "tableAlias", "rowFormat", "multipartIdentifierList", 
		"multipartIdentifier", "multipartIdentifierPropertyList", "multipartIdentifierProperty", 
		"tableIdentifier", "viewIdentifier", "namedExpression", "namedExpressionSeq", 
		"partitionFieldList", "partitionField", "transform", "transformArgument", 
		"expression", "namedArgumentExpression", "functionArgument", "expressionSeq", 
		"booleanExpression", "predicate", "valueExpression", "datetimeUnit", "primaryExpression", 
		"literalType", "constant", "comparisonOperator", "arithmeticOperator", 
		"predicateOperator", "booleanValue", "interval", "errorCapturingMultiUnitsInterval", 
		"multiUnitsInterval", "errorCapturingUnitToUnitInterval", "unitToUnitInterval", 
		"intervalValue", "unitInMultiUnits", "unitInUnitToUnit", "colPosition", 
		"type", "dataType", "qualifiedColTypeWithPositionSeqForAdd", "qualifiedColTypeWithPositionForAdd", 
		"qualifiedColTypeWithPositionSeqForReplace", "qualifiedColTypeWithPositionForReplace", 
		"colDefinitionDescriptorWithPosition", "defaultExpression", "variableDefaultExpression", 
		"colTypeList", "colType", "createOrReplaceTableColTypeList", "createOrReplaceTableColType", 
		"colDefinitionOption", "generationExpression", "complexColTypeList", "complexColType", 
		"whenClause", "windowClause", "namedWindow", "windowSpec", "windowFrame", 
		"frameBound", "qualifiedNameList", "functionName", "functionNameCreate", 
		"qualifiedName", "errorCapturingIdentifier", "errorCapturingIdentifierExtra", 
		"identifier", "strictIdentifier", "quotedIdentifier", "backQuotedIdentifier", 
		"number", "alterColumnAction", "stringLit", "comment", "version", "ansiNonReserved", 
		"strictNonReserved", "nonReserved",
	];

	private static readonly _LITERAL_NAMES: Array<string | undefined> = [
		undefined, "';'", "'('", "')'", "','", "'.'", "'['", "']'", "'ADD'", "'AFTER'", 
		"'ALL'", "'ALTER'", "'ALWAYS'", "'ANALYZE'", "'AND'", "'ANTI'", "'ANY'", 
		"'ANY_VALUE'", "'ARCHIVE'", "'ARRAY'", "'AS'", "'ASC'", "'AT'", "'AUTHORIZATION'", 
		"'BETWEEN'", "'BIGINT'", "'BINARY'", "'BOOLEAN'", "'BOTH'", "'BUCKET'", 
		"'BUCKETS'", "'BY'", "'BYTE'", "'CACHE'", "'CASCADE'", "'CASE'", "'CAST'", 
		"'CATALOG'", "'CATALOGS'", "'CHANGE'", "'CHAR'", "'CHARACTER'", "'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'", "'DAY'", "'DAYS'", "'DAYOFYEAR'", "'DATA'", "'DATE'", 
		"'DATABASE'", "'DATABASES'", "'DATEADD'", "'DATE_ADD'", "'DATEDIFF'", 
		"'DATE_DIFF'", "'DBPROPERTIES'", "'DEC'", "'DECIMAL'", "'DECLARE'", "'DEFAULT'", 
		"'DEFINED'", "'DELETE'", "'DELIMITED'", "'DESC'", "'DESCRIBE'", "'DFS'", 
		"'DIRECTORIES'", "'DIRECTORY'", "'DISTINCT'", "'DISTRIBUTE'", "'DIV'", 
		"'DOUBLE'", "'DROP'", "'ELSE'", "'END'", "'ESCAPE'", "'ESCAPED'", "'EXCEPT'", 
		"'EXCHANGE'", "'EXCLUDE'", "'EXISTS'", "'EXPLAIN'", "'EXPORT'", "'EXTENDED'", 
		"'EXTERNAL'", "'EXTRACT'", "'FALSE'", "'FETCH'", "'FIELDS'", "'FILTER'", 
		"'FILEFORMAT'", "'FIRST'", "'FLOAT'", "'FOLLOWING'", "'FOR'", "'FOREIGN'", 
		"'FORMAT'", "'FORMATTED'", "'FROM'", "'FULL'", "'FUNCTION'", "'FUNCTIONS'", 
		"'GENERATED'", "'GLOBAL'", "'GRANT'", "'GROUP'", "'GROUPING'", "'HAVING'", 
		"'X'", "'HOUR'", "'HOURS'", "'IDENTIFIER'", "'IF'", "'IGNORE'", "'IMPORT'", 
		"'IN'", "'INCLUDE'", "'INDEX'", "'INDEXES'", "'INNER'", "'INPATH'", "'INPUTFORMAT'", 
		"'INSERT'", "'INTERSECT'", "'INTERVAL'", "'INT'", "'INTEGER'", "'INTO'", 
		"'IS'", "'ITEMS'", "'JOIN'", "'KEYS'", "'LAST'", "'LATERAL'", "'LAZY'", 
		"'LEADING'", "'LEFT'", "'LIKE'", "'ILIKE'", "'LIMIT'", "'LINES'", "'LIST'", 
		"'LOAD'", "'LOCAL'", "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'", "'LONG'", 
		"'MACRO'", "'MAP'", "'MATCHED'", "'MERGE'", "'MICROSECOND'", "'MICROSECONDS'", 
		"'MILLISECOND'", "'MILLISECONDS'", "'MINUTE'", "'MINUTES'", "'MONTH'", 
		"'MONTHS'", "'MSCK'", "'NAME'", "'NAMESPACE'", "'NAMESPACES'", "'NANOSECOND'", 
		"'NANOSECONDS'", "'NATURAL'", "'NO'", "'NOSCAN'", "'NOT'", "'NULL'", "'NULLS'", 
		"'NUMERIC'", "'OF'", "'OFFSET'", "'ON'", "'ONLY'", "'OPTION'", "'OPTIONS'", 
		"'OR'", "'ORDER'", "'OUT'", "'OUTER'", "'OUTPUTFORMAT'", "'OVER'", "'OVERLAPS'", 
		"'OVERLAY'", "'OVERWRITE'", "'PARTITION'", "'PARTITIONED'", "'PARTITIONS'", 
		"'PERCENTILE_CONT'", "'PERCENTILE_DISC'", "'PERCENT'", "'PIVOT'", "'PLACING'", 
		"'POSITION'", "'PRECEDING'", "'PRIMARY'", "'PRINCIPALS'", "'PROPERTIES'", 
		"'PURGE'", "'QUARTER'", "'QUERY'", "'RANGE'", "'REAL'", "'RECORDREADER'", 
		"'RECORDWRITER'", "'RECOVER'", "'REDUCE'", "'REFERENCES'", "'REFRESH'", 
		"'RENAME'", "'REPAIR'", "'REPEATABLE'", "'REPLACE'", "'RESET'", "'RESPECT'", 
		"'RESTRICT'", "'REVOKE'", "'RIGHT'", "'RLIKE'", "'REGEXP'", "'ROLE'", 
		"'ROLES'", "'ROLLBACK'", "'ROLLUP'", "'ROW'", "'ROWS'", "'SECOND'", "'SECONDS'", 
		"'SCHEMA'", "'SCHEMAS'", "'SELECT'", "'SEMI'", "'SEPARATED'", "'SERDE'", 
		"'SERDEPROPERTIES'", "'SESSION_USER'", "'SET'", "'MINUS'", "'SETS'", "'SHORT'", 
		"'SHOW'", "'SINGLE'", "'SKEWED'", "'SMALLINT'", "'SOME'", "'SORT'", "'SORTED'", 
		"'SOURCE'", "'START'", "'STATISTICS'", "'STORED'", "'STRATIFY'", "'STRING'", 
		"'STRUCT'", "'SUBSTR'", "'SUBSTRING'", "'SYNC'", "'SYSTEM'", "'SYSTEM_TIME'", 
		"'SYSTEM_VERSION'", "'TABLE'", "'TABLES'", "'TABLESAMPLE'", "'TARGET'", 
		"'TBLPROPERTIES'", "'TEMPORARY'", "'TERMINATED'", "'THEN'", "'TIME'", 
		"'TIMEDIFF'", "'TIMESTAMP'", "'TIMESTAMP_LTZ'", "'TIMESTAMP_NTZ'", "'TIMESTAMPADD'", 
		"'TIMESTAMPDIFF'", "'TINYINT'", "'TO'", "'TOUCH'", "'TRAILING'", "'TRANSACTION'", 
		"'TRANSACTIONS'", "'TRANSFORM'", "'TRIM'", "'TRUE'", "'TRUNCATE'", "'TRY_CAST'", 
		"'TYPE'", "'UNARCHIVE'", "'UNBOUNDED'", "'UNCACHE'", "'UNION'", "'UNIQUE'", 
		"'UNKNOWN'", "'UNLOCK'", "'UNPIVOT'", "'UNSET'", "'UPDATE'", "'USE'", 
		"'USER'", "'USING'", "'VALUES'", "'VARCHAR'", "'VAR'", "'VARIABLE'", "'VERSION'", 
		"'VIEW'", "'VIEWS'", "'VOID'", "'WEEK'", "'WEEKS'", "'WHEN'", "'WHERE'", 
		"'WINDOW'", "'WITH'", "'WITHIN'", "'YEAR'", "'YEARS'", "'ZONE'", undefined, 
		"'<=>'", "'<>'", "'!='", "'<'", undefined, "'>'", undefined, "'!'", "'+'", 
		"'-'", "'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'", "'^'", "':'", 
		"'->'", "'=>'", "'/*+'", "'*/'", "'?'",
	];
	private static readonly _SYMBOLIC_NAMES: Array<string | undefined> = [
		undefined, "SEMICOLON", "LEFT_PAREN", "RIGHT_PAREN", "COMMA", "DOT", "LEFT_BRACKET", 
		"RIGHT_BRACKET", "KW_ADD", "KW_AFTER", "KW_ALL", "KW_ALTER", "KW_ALWAYS", 
		"KW_ANALYZE", "KW_AND", "KW_ANTI", "KW_ANY", "KW_ANY_VALUE", "KW_ARCHIVE", 
		"KW_ARRAY", "KW_AS", "KW_ASC", "KW_AT", "KW_AUTHORIZATION", "KW_BETWEEN", 
		"KW_BIGINT", "KW_BINARY", "KW_BOOLEAN", "KW_BOTH", "KW_BUCKET", "KW_BUCKETS", 
		"KW_BY", "KW_BYTE", "KW_CACHE", "KW_CASCADE", "KW_CASE", "KW_CAST", "KW_CATALOG", 
		"KW_CATALOGS", "KW_CHANGE", "KW_CHAR", "KW_CHARACTER", "KW_CHECK", "KW_CLEAR", 
		"KW_CLUSTER", "KW_CLUSTERED", "KW_CODEGEN", "KW_COLLATE", "KW_COLLECTION", 
		"KW_COLUMN", "KW_COLUMNS", "KW_COMMENT", "KW_COMMIT", "KW_COMPACT", "KW_COMPACTIONS", 
		"KW_COMPUTE", "KW_CONCATENATE", "KW_CONSTRAINT", "KW_COST", "KW_CREATE", 
		"KW_CROSS", "KW_CUBE", "KW_CURRENT", "KW_CURRENT_DATE", "KW_CURRENT_TIME", 
		"KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", "KW_DAY", "KW_DAYS", "KW_DAYOFYEAR", 
		"KW_DATA", "KW_DATE", "KW_DATABASE", "KW_DATABASES", "KW_DATEADD", "KW_DATE_ADD", 
		"KW_DATEDIFF", "KW_DATE_DIFF", "KW_DBPROPERTIES", "KW_DEC", "KW_DECIMAL", 
		"KW_DECLARE", "KW_DEFAULT", "KW_DEFINED", "KW_DELETE", "KW_DELIMITED", 
		"KW_DESC", "KW_DESCRIBE", "KW_DFS", "KW_DIRECTORIES", "KW_DIRECTORY", 
		"KW_DISTINCT", "KW_DISTRIBUTE", "KW_DIV", "KW_DOUBLE", "KW_DROP", "KW_ELSE", 
		"KW_END", "KW_ESCAPE", "KW_ESCAPED", "KW_EXCEPT", "KW_EXCHANGE", "KW_EXCLUDE", 
		"KW_EXISTS", "KW_EXPLAIN", "KW_EXPORT", "KW_EXTENDED", "KW_EXTERNAL", 
		"KW_EXTRACT", "KW_FALSE", "KW_FETCH", "KW_FIELDS", "KW_FILTER", "KW_FILEFORMAT", 
		"KW_FIRST", "KW_FLOAT", "KW_FOLLOWING", "KW_FOR", "KW_FOREIGN", "KW_FORMAT", 
		"KW_FORMATTED", "KW_FROM", "KW_FULL", "KW_FUNCTION", "KW_FUNCTIONS", "KW_GENERATED", 
		"KW_GLOBAL", "KW_GRANT", "KW_GROUP", "KW_GROUPING", "KW_HAVING", "KW_BINARY_HEX", 
		"KW_HOUR", "KW_HOURS", "KW_IDENTIFIER", "KW_IF", "KW_IGNORE", "KW_IMPORT", 
		"KW_IN", "KW_INCLUDE", "KW_INDEX", "KW_INDEXES", "KW_INNER", "KW_INPATH", 
		"KW_INPUTFORMAT", "KW_INSERT", "KW_INTERSECT", "KW_INTERVAL", "KW_INT", 
		"KW_INTEGER", "KW_INTO", "KW_IS", "KW_ITEMS", "KW_JOIN", "KW_KEYS", "KW_LAST", 
		"KW_LATERAL", "KW_LAZY", "KW_LEADING", "KW_LEFT", "KW_LIKE", "KW_ILIKE", 
		"KW_LIMIT", "KW_LINES", "KW_LIST", "KW_LOAD", "KW_LOCAL", "KW_LOCATION", 
		"KW_LOCK", "KW_LOCKS", "KW_LOGICAL", "KW_LONG", "KW_MACRO", "KW_MAP", 
		"KW_MATCHED", "KW_MERGE", "KW_MICROSECOND", "KW_MICROSECONDS", "KW_MILLISECOND", 
		"KW_MILLISECONDS", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS", 
		"KW_MSCK", "KW_NAME", "KW_NAMESPACE", "KW_NAMESPACES", "KW_NANOSECOND", 
		"KW_NANOSECONDS", "KW_NATURAL", "KW_NO", "KW_NOSCAN", "KW_NOT", "KW_NULL", 
		"KW_NULLS", "KW_NUMERIC", "KW_OF", "KW_OFFSET", "KW_ON", "KW_ONLY", "KW_OPTION", 
		"KW_OPTIONS", "KW_OR", "KW_ORDER", "KW_OUT", "KW_OUTER", "KW_OUTPUTFORMAT", 
		"KW_OVER", "KW_OVERLAPS", "KW_OVERLAY", "KW_OVERWRITE", "KW_PARTITION", 
		"KW_PARTITIONED", "KW_PARTITIONS", "KW_PERCENTILE_CONT", "KW_PERCENTILE_DISC", 
		"KW_PERCENTLIT", "KW_PIVOT", "KW_PLACING", "KW_POSITION", "KW_PRECEDING", 
		"KW_PRIMARY", "KW_PRINCIPALS", "KW_PROPERTIES", "KW_PURGE", "KW_QUARTER", 
		"KW_QUERY", "KW_RANGE", "KW_REAL", "KW_RECORDREADER", "KW_RECORDWRITER", 
		"KW_RECOVER", "KW_REDUCE", "KW_REFERENCES", "KW_REFRESH", "KW_RENAME", 
		"KW_REPAIR", "KW_REPEATABLE", "KW_REPLACE", "KW_RESET", "KW_RESPECT", 
		"KW_RESTRICT", "KW_REVOKE", "KW_RIGHT", "KW_RLIKE", "KW_REGEXP", "KW_ROLE", 
		"KW_ROLES", "KW_ROLLBACK", "KW_ROLLUP", "KW_ROW", "KW_ROWS", "KW_SECOND", 
		"KW_SECONDS", "KW_SCHEMA", "KW_SCHEMAS", "KW_SELECT", "KW_SEMI", "KW_SEPARATED", 
		"KW_SERDE", "KW_SERDEPROPERTIES", "KW_SESSION_USER", "KW_SET", "KW_MINUS", 
		"KW_SETS", "KW_SHORT", "KW_SHOW", "KW_SINGLE", "KW_SKEWED", "KW_SMALLINT", 
		"KW_SOME", "KW_SORT", "KW_SORTED", "KW_SOURCE", "KW_START", "KW_STATISTICS", 
		"KW_STORED", "KW_STRATIFY", "KW_STRING", "KW_STRUCT", "KW_SUBSTR", "KW_SUBSTRING", 
		"KW_SYNC", "KW_SYSTEM", "KW_SYSTEM_TIME", "KW_SYSTEM_VERSION", "KW_TABLE", 
		"KW_TABLES", "KW_TABLESAMPLE", "KW_TARGET", "KW_TBLPROPERTIES", "KW_TEMPORARY", 
		"KW_TERMINATED", "KW_THEN", "KW_TIME", "KW_TIMEDIFF", "KW_TIMESTAMP", 
		"KW_TIMESTAMP_LTZ", "KW_TIMESTAMP_NTZ", "KW_TIMESTAMPADD", "KW_TIMESTAMPDIFF", 
		"KW_TINYINT", "KW_TO", "KW_TOUCH", "KW_TRAILING", "KW_TRANSACTION", "KW_TRANSACTIONS", 
		"KW_TRANSFORM", "KW_TRIM", "KW_TRUE", "KW_TRUNCATE", "KW_TRY_CAST", "KW_TYPE", 
		"KW_UNARCHIVE", "KW_UNBOUNDED", "KW_UNCACHE", "KW_UNION", "KW_UNIQUE", 
		"KW_UNKNOWN", "KW_UNLOCK", "KW_UNPIVOT", "KW_UNSET", "KW_UPDATE", "KW_USE", 
		"KW_USER", "KW_USING", "KW_VALUES", "KW_VARCHAR", "KW_VAR", "KW_VARIABLE", 
		"KW_VERSION", "KW_VIEW", "KW_VIEWS", "KW_VOID", "KW_WEEK", "KW_WEEKS", 
		"KW_WHEN", "KW_WHERE", "KW_WINDOW", "KW_WITH", "KW_WITHIN", "KW_YEAR", 
		"KW_YEARS", "KW_ZONE", "EQ", "NSEQ", "NEQ", "NEQJ", "LT", "LTE", "GT", 
		"GTE", "NOT", "PLUS", "MINUS", "ASTERISK", "SLASH", "PERCENT", "TILDE", 
		"AMPERSAND", "PIPE", "CONCAT_PIPE", "HAT", "COLON", "ARROW", "FAT_ARROW", 
		"HENT_START", "HENT_END", "QUESTION", "STRING_LITERAL", "DOUBLEQUOTED_STRING", 
		"BIGINT_LITERAL", "SMALLINT_LITERAL", "TINYINT_LITERAL", "INTEGER_VALUE", 
		"EXPONENT_VALUE", "DECIMAL_VALUE", "FLOAT_LITERAL", "DOUBLE_LITERAL", 
		"BIGDECIMAL_LITERAL", "IDENTIFIER", "BACKQUOTED_IDENTIFIER", "SIMPLE_COMMENT", 
		"BRACKETED_COMMENT", "WS", "UNRECOGNIZED",
	];
	public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(SparkSqlParser._LITERAL_NAMES, SparkSqlParser._SYMBOLIC_NAMES, []);

	// @Override
	// @NotNull
	public get vocabulary(): Vocabulary {
		return SparkSqlParser.VOCABULARY;
	}
	// tslint:enable:no-trailing-whitespace

	// @Override
	public get grammarFileName(): string { return "SparkSqlParser.g4"; }

	// @Override
	public get ruleNames(): string[] { return SparkSqlParser.ruleNames; }

	// @Override
	public get serializedATN(): string { return SparkSqlParser._serializedATN; }

	protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException {
		return new FailedPredicateException(this, predicate, message);
	}

	constructor(input: TokenStream) {
		super(input);
		this._interp = new ParserATNSimulator(SparkSqlParser._ATN, this);
	}
	// @RuleVersion(0)
	public program(): ProgramContext {
		let _localctx: ProgramContext = new ProgramContext(this._ctx, this.state);
		this.enterRule(_localctx, 0, SparkSqlParser.RULE_program);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 399;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ANALYZE))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (SparkSqlParser.KW_CACHE - 33)) | (1 << (SparkSqlParser.KW_CLEAR - 33)) | (1 << (SparkSqlParser.KW_COMMENT - 33)) | (1 << (SparkSqlParser.KW_COMMIT - 33)) | (1 << (SparkSqlParser.KW_CREATE - 33)))) !== 0) || ((((_la - 81)) & ~0x1F) === 0 && ((1 << (_la - 81)) & ((1 << (SparkSqlParser.KW_DECLARE - 81)) | (1 << (SparkSqlParser.KW_DELETE - 81)) | (1 << (SparkSqlParser.KW_DESC - 81)) | (1 << (SparkSqlParser.KW_DESCRIBE - 81)) | (1 << (SparkSqlParser.KW_DFS - 81)) | (1 << (SparkSqlParser.KW_DROP - 81)) | (1 << (SparkSqlParser.KW_EXPLAIN - 81)) | (1 << (SparkSqlParser.KW_EXPORT - 81)))) !== 0) || ((((_la - 121)) & ~0x1F) === 0 && ((1 << (_la - 121)) & ((1 << (SparkSqlParser.KW_FROM - 121)) | (1 << (SparkSqlParser.KW_GRANT - 121)) | (1 << (SparkSqlParser.KW_IMPORT - 121)) | (1 << (SparkSqlParser.KW_INSERT - 121)))) !== 0) || ((((_la - 164)) & ~0x1F) === 0 && ((1 << (_la - 164)) & ((1 << (SparkSqlParser.KW_LIST - 164)) | (1 << (SparkSqlParser.KW_LOAD - 164)) | (1 << (SparkSqlParser.KW_LOCK - 164)) | (1 << (SparkSqlParser.KW_MAP - 164)) | (1 << (SparkSqlParser.KW_MERGE - 164)) | (1 << (SparkSqlParser.KW_MSCK - 164)))) !== 0) || ((((_la - 233)) & ~0x1F) === 0 && ((1 << (_la - 233)) & ((1 << (SparkSqlParser.KW_REDUCE - 233)) | (1 << (SparkSqlParser.KW_REFRESH - 233)) | (1 << (SparkSqlParser.KW_REPAIR - 233)) | (1 << (SparkSqlParser.KW_REPLACE - 233)) | (1 << (SparkSqlParser.KW_RESET - 233)) | (1 << (SparkSqlParser.KW_REVOKE - 233)) | (1 << (SparkSqlParser.KW_ROLLBACK - 233)) | (1 << (SparkSqlParser.KW_SELECT - 233)) | (1 << (SparkSqlParser.KW_SET - 233)))) !== 0) || ((((_la - 267)) & ~0x1F) === 0 && ((1 << (_la - 267)) & ((1 << (SparkSqlParser.KW_SHOW - 267)) | (1 << (SparkSqlParser.KW_START - 267)) | (1 << (SparkSqlParser.KW_TABLE - 267)))) !== 0) || ((((_la - 311)) & ~0x1F) === 0 && ((1 << (_la - 311)) & ((1 << (SparkSqlParser.KW_TRUNCATE - 311)) | (1 << (SparkSqlParser.KW_UNCACHE - 311)) | (1 << (SparkSqlParser.KW_UNLOCK - 311)) | (1 << (SparkSqlParser.KW_UPDATE - 311)) | (1 << (SparkSqlParser.KW_USE - 311)) | (1 << (SparkSqlParser.KW_VALUES - 311)) | (1 << (SparkSqlParser.KW_WITH - 311)))) !== 0)) {
				{
				{
				this.state = 396;
				this.singleStatement();
				}
				}
				this.state = 401;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 402;
			this.match(SparkSqlParser.EOF);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public singleStatement(): SingleStatementContext {
		let _localctx: SingleStatementContext = new SingleStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 2, SparkSqlParser.RULE_singleStatement);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 404;
			this.statement();
			this.state = 406;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.SEMICOLON) {
				{
				this.state = 405;
				this.match(SparkSqlParser.SEMICOLON);
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public statement(): StatementContext {
		let _localctx: StatementContext = new StatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 4, SparkSqlParser.RULE_statement);
		let _la: number;
		try {
			let _alt: number;
			this.state = 1247;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 133, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 408;
				this.query();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 410;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_WITH) {
					{
					this.state = 409;
					this.ctes();
					}
				}

				this.state = 412;
				this.dmlStatementNoWith();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 413;
				this.match(SparkSqlParser.KW_USE);
				this.state = 414;
				this.dbSchemaName();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 415;
				this.match(SparkSqlParser.KW_USE);
				this.state = 416;
				this.dbSchema();
				this.state = 417;
				this.dbSchemaName();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 419;
				this.match(SparkSqlParser.KW_SET);
				this.state = 420;
				this.match(SparkSqlParser.KW_CATALOG);
				this.state = 423;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 3, this._ctx) ) {
				case 1:
					{
					this.state = 421;
					this.identifier();
					}
					break;

				case 2:
					{
					this.state = 422;
					this.stringLit();
					}
					break;
				}
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 425;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 426;
				this.dbSchema();
				this.state = 428;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 4, this._ctx) ) {
				case 1:
					{
					this.state = 427;
					this.ifNotExists();
					}
					break;
				}
				this.state = 430;
				this.dbSchemaNameCreate();
				this.state = 438;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						this.state = 436;
						this._errHandler.sync(this);
						switch (this._input.LA(1)) {
						case SparkSqlParser.KW_COMMENT:
							{
							this.state = 431;
							this.commentSpec();
							}
							break;
						case SparkSqlParser.KW_LOCATION:
							{
							this.state = 432;
							this.locationSpec();
							}
							break;
						case SparkSqlParser.KW_WITH:
							{
							{
							this.state = 433;
							this.match(SparkSqlParser.KW_WITH);
							this.state = 434;
							_la = this._input.LA(1);
							if (!(_la === SparkSqlParser.KW_DBPROPERTIES || _la === SparkSqlParser.KW_PROPERTIES)) {
							this._errHandler.recoverInline(this);
							} else {
								if (this._input.LA(1) === Token.EOF) {
									this.matchedEOF = true;
								}

								this._errHandler.reportMatch(this);
								this.consume();
							}
							this.state = 435;
							this.propertyList();
							}
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						}
					}
					this.state = 440;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
				}
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 441;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 442;
				this.dbSchema();
				this.state = 443;
				this.dbSchemaName();
				this.state = 444;
				this.match(SparkSqlParser.KW_SET);
				this.state = 445;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DBPROPERTIES || _la === SparkSqlParser.KW_PROPERTIES)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 446;
				this.propertyList();
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 448;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 449;
				this.dbSchema();
				this.state = 450;
				this.dbSchemaName();
				this.state = 451;
				this.match(SparkSqlParser.KW_SET);
				this.state = 452;
				this.locationSpec();
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 454;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 455;
				this.dbSchema();
				this.state = 457;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 7, this._ctx) ) {
				case 1:
					{
					this.state = 456;
					this.ifExists();
					}
					break;
				}
				this.state = 459;
				this.dbSchemaName();
				this.state = 461;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_CASCADE || _la === SparkSqlParser.KW_RESTRICT) {
					{
					this.state = 460;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_CASCADE || _la === SparkSqlParser.KW_RESTRICT)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					}
				}

				}
				break;

			case 10:
				this.enterOuterAlt(_localctx, 10);
				{
				this.state = 463;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 464;
				this.dbSchemas();
				this.state = 467;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
				case 1:
					{
					this.state = 465;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 466;
					this.multipartIdentifier();
					}
					break;
				}
				this.state = 473;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.STRING_LITERAL || _la === SparkSqlParser.DOUBLEQUOTED_STRING) {
					{
					this.state = 470;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_LIKE) {
						{
						this.state = 469;
						this.match(SparkSqlParser.KW_LIKE);
						}
					}

					this.state = 472;
					_localctx._pattern = this.stringLit();
					}
				}

				}
				break;

			case 11:
				this.enterOuterAlt(_localctx, 11);
				{
				this.state = 475;
				this.createTableHeader();
				this.state = 480;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 12, this._ctx) ) {
				case 1:
					{
					this.state = 476;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 477;
					this.createOrReplaceTableColTypeList();
					this.state = 478;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 483;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 482;
					this.tableProvider();
					}
				}

				this.state = 485;
				this.createTableClauses();
				this.state = 490;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 15, this._ctx) ) {
				case 1:
					{
					this.state = 487;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_AS) {
						{
						this.state = 486;
						this.match(SparkSqlParser.KW_AS);
						}
					}

					this.state = 489;
					this.query();
					}
					break;
				}
				}
				break;

			case 12:
				this.enterOuterAlt(_localctx, 12);
				{
				this.state = 492;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 493;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 495;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
				case 1:
					{
					this.state = 494;
					this.ifNotExists();
					}
					break;
				}
				this.state = 497;
				_localctx._target = this.tableNameCreate();
				this.state = 498;
				this.match(SparkSqlParser.KW_LIKE);
				this.state = 499;
				_localctx._source = this.tableName();
				this.state = 508;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.KW_LOCATION || _la === SparkSqlParser.KW_ROW || _la === SparkSqlParser.KW_STORED || _la === SparkSqlParser.KW_TBLPROPERTIES || _la === SparkSqlParser.KW_USING) {
					{
					this.state = 506;
					this._errHandler.sync(this);
					switch (this._input.LA(1)) {
					case SparkSqlParser.KW_USING:
						{
						this.state = 500;
						this.tableProvider();
						}
						break;
					case SparkSqlParser.KW_ROW:
						{
						this.state = 501;
						this.rowFormat();
						}
						break;
					case SparkSqlParser.KW_STORED:
						{
						this.state = 502;
						this.createFileFormat();
						}
						break;
					case SparkSqlParser.KW_LOCATION:
						{
						this.state = 503;
						this.locationSpec();
						}
						break;
					case SparkSqlParser.KW_TBLPROPERTIES:
						{
						{
						this.state = 504;
						this.match(SparkSqlParser.KW_TBLPROPERTIES);
						this.state = 505;
						_localctx._tableProps = this.propertyList();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					this.state = 510;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;

			case 13:
				this.enterOuterAlt(_localctx, 13);
				{
				this.state = 511;
				this.replaceTableHeader();
				this.state = 516;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 19, this._ctx) ) {
				case 1:
					{
					this.state = 512;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 513;
					this.createOrReplaceTableColTypeList();
					this.state = 514;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 519;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 518;
					this.tableProvider();
					}
				}

				this.state = 521;
				this.createTableClauses();
				this.state = 526;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 22, this._ctx) ) {
				case 1:
					{
					this.state = 523;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_AS) {
						{
						this.state = 522;
						this.match(SparkSqlParser.KW_AS);
						}
					}

					this.state = 525;
					this.query();
					}
					break;
				}
				}
				break;

			case 14:
				this.enterOuterAlt(_localctx, 14);
				{
				this.state = 528;
				this.match(SparkSqlParser.KW_ANALYZE);
				this.state = 529;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 530;
				this.tableName();
				this.state = 532;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 531;
					this.partitionSpec();
					}
				}

				this.state = 534;
				this.match(SparkSqlParser.KW_COMPUTE);
				this.state = 535;
				this.match(SparkSqlParser.KW_STATISTICS);
				this.state = 543;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 24, this._ctx) ) {
				case 1:
					{
					this.state = 536;
					this.match(SparkSqlParser.KW_NOSCAN);
					}
					break;

				case 2:
					{
					this.state = 537;
					this.match(SparkSqlParser.KW_FOR);
					this.state = 538;
					this.match(SparkSqlParser.KW_COLUMNS);
					this.state = 539;
					this.columnNameSeq();
					}
					break;

				case 3:
					{
					this.state = 540;
					this.match(SparkSqlParser.KW_FOR);
					this.state = 541;
					this.match(SparkSqlParser.KW_ALL);
					this.state = 542;
					this.match(SparkSqlParser.KW_COLUMNS);
					}
					break;
				}
				}
				break;

			case 15:
				this.enterOuterAlt(_localctx, 15);
				{
				this.state = 545;
				this.match(SparkSqlParser.KW_ANALYZE);
				this.state = 546;
				this.match(SparkSqlParser.KW_TABLES);
				this.state = 549;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN) {
					{
					this.state = 547;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 548;
					this.dbSchemaName();
					}
				}

				this.state = 551;
				this.match(SparkSqlParser.KW_COMPUTE);
				this.state = 552;
				this.match(SparkSqlParser.KW_STATISTICS);
				this.state = 554;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOSCAN) {
					{
					this.state = 553;
					this.match(SparkSqlParser.KW_NOSCAN);
					}
				}

				}
				break;

			case 16:
				this.enterOuterAlt(_localctx, 16);
				{
				this.state = 556;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 557;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 558;
				this.tableName();
				this.state = 559;
				this.match(SparkSqlParser.KW_ADD);
				this.state = 560;
				this.match(SparkSqlParser.KW_COLUMN);
				this.state = 561;
				this.qualifiedColTypeWithPositionForAdd();
				}
				break;

			case 17:
				this.enterOuterAlt(_localctx, 17);
				{
				this.state = 563;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 564;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 565;
				this.tableName();
				this.state = 566;
				this.match(SparkSqlParser.KW_ADD);
				this.state = 567;
				this.match(SparkSqlParser.KW_COLUMNS);
				this.state = 568;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 569;
				this.qualifiedColTypeWithPositionSeqForAdd();
				this.state = 570;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 18:
				this.enterOuterAlt(_localctx, 18);
				{
				this.state = 572;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 573;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 574;
				_localctx._table = this.tableName();
				this.state = 575;
				this.match(SparkSqlParser.KW_RENAME);
				this.state = 576;
				this.match(SparkSqlParser.KW_COLUMN);
				this.state = 577;
				this.columnName();
				this.state = 578;
				this.match(SparkSqlParser.KW_TO);
				this.state = 579;
				this.columnNameCreate();
				}
				break;

			case 19:
				this.enterOuterAlt(_localctx, 19);
				{
				this.state = 581;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 582;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 583;
				this.tableName();
				this.state = 584;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 585;
				this.match(SparkSqlParser.KW_COLUMN);
				this.state = 587;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 27, this._ctx) ) {
				case 1:
					{
					this.state = 586;
					this.ifExists();
					}
					break;
				}
				this.state = 589;
				this.columnName();
				}
				break;

			case 20:
				this.enterOuterAlt(_localctx, 20);
				{
				this.state = 591;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 592;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 593;
				this.tableName();
				this.state = 594;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 595;
				this.match(SparkSqlParser.KW_COLUMNS);
				this.state = 597;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 596;
					this.ifExists();
					}
				}

				this.state = 599;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 600;
				this.columnNameSeq();
				this.state = 601;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 21:
				this.enterOuterAlt(_localctx, 21);
				{
				this.state = 603;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 608;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 604;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 605;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 606;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 607;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 610;
				this.match(SparkSqlParser.KW_RENAME);
				this.state = 611;
				this.match(SparkSqlParser.KW_TO);
				this.state = 612;
				this.multipartIdentifier();
				}
				break;

			case 22:
				this.enterOuterAlt(_localctx, 22);
				{
				this.state = 614;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 619;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 615;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 616;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 617;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 618;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 621;
				this.match(SparkSqlParser.KW_SET);
				this.state = 622;
				this.match(SparkSqlParser.KW_TBLPROPERTIES);
				this.state = 623;
				this.propertyList();
				}
				break;

			case 23:
				this.enterOuterAlt(_localctx, 23);
				{
				this.state = 625;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 630;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 626;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 627;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 628;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 629;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 632;
				this.match(SparkSqlParser.KW_UNSET);
				this.state = 633;
				this.match(SparkSqlParser.KW_TBLPROPERTIES);
				this.state = 635;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 634;
					this.ifExists();
					}
				}

				this.state = 637;
				this.propertyList();
				}
				break;

			case 24:
				this.enterOuterAlt(_localctx, 24);
				{
				this.state = 639;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 640;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 641;
				_localctx._table = this.tableName();
				this.state = 642;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_ALTER || _la === SparkSqlParser.KW_CHANGE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 644;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 33, this._ctx) ) {
				case 1:
					{
					this.state = 643;
					this.match(SparkSqlParser.KW_COLUMN);
					}
					break;
				}
				this.state = 646;
				_localctx._column = this.columnName();
				this.state = 648;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 34, this._ctx) ) {
				case 1:
					{
					this.state = 647;
					this.alterColumnAction();
					}
					break;
				}
				}
				break;

			case 25:
				this.enterOuterAlt(_localctx, 25);
				{
				this.state = 650;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 651;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 652;
				_localctx._table = this.tableName();
				this.state = 654;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 653;
					this.partitionSpec();
					}
				}

				this.state = 656;
				this.match(SparkSqlParser.KW_CHANGE);
				this.state = 658;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 36, this._ctx) ) {
				case 1:
					{
					this.state = 657;
					this.match(SparkSqlParser.KW_COLUMN);
					}
					break;
				}
				this.state = 660;
				_localctx._colName = this.columnName();
				this.state = 661;
				this.colType();
				this.state = 663;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_AFTER || _la === SparkSqlParser.KW_FIRST) {
					{
					this.state = 662;
					this.colPosition();
					}
				}

				}
				break;

			case 26:
				this.enterOuterAlt(_localctx, 26);
				{
				this.state = 665;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 666;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 667;
				_localctx._table = this.tableName();
				this.state = 669;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 668;
					this.partitionSpec();
					}
				}

				this.state = 671;
				this.match(SparkSqlParser.KW_REPLACE);
				this.state = 672;
				this.match(SparkSqlParser.KW_COLUMNS);
				this.state = 673;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 674;
				this.qualifiedColTypeWithPositionSeqForReplace();
				this.state = 675;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 27:
				this.enterOuterAlt(_localctx, 27);
				{
				this.state = 677;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 678;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 679;
				this.tableName();
				this.state = 681;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 680;
					this.partitionSpec();
					}
				}

				this.state = 683;
				this.match(SparkSqlParser.KW_SET);
				this.state = 684;
				this.match(SparkSqlParser.KW_SERDE);
				this.state = 685;
				this.stringLit();
				this.state = 689;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 40, this._ctx) ) {
				case 1:
					{
					this.state = 686;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 687;
					this.match(SparkSqlParser.KW_SERDEPROPERTIES);
					this.state = 688;
					this.propertyList();
					}
					break;
				}
				}
				break;

			case 28:
				this.enterOuterAlt(_localctx, 28);
				{
				this.state = 691;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 692;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 693;
				this.tableName();
				this.state = 695;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 694;
					this.partitionSpec();
					}
				}

				this.state = 697;
				this.match(SparkSqlParser.KW_SET);
				this.state = 698;
				this.match(SparkSqlParser.KW_SERDEPROPERTIES);
				this.state = 699;
				this.propertyList();
				}
				break;

			case 29:
				this.enterOuterAlt(_localctx, 29);
				{
				this.state = 701;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 706;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 702;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 703;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 704;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 705;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 708;
				this.match(SparkSqlParser.KW_ADD);
				this.state = 710;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 709;
					this.ifNotExists();
					}
				}

				this.state = 713;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 712;
					this.partitionSpecLocation();
					}
					}
					this.state = 715;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.KW_PARTITION);
				}
				break;

			case 30:
				this.enterOuterAlt(_localctx, 30);
				{
				this.state = 717;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 718;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 719;
				this.tableName();
				this.state = 720;
				this.partitionSpec();
				this.state = 721;
				this.match(SparkSqlParser.KW_RENAME);
				this.state = 722;
				this.match(SparkSqlParser.KW_TO);
				this.state = 723;
				this.partitionSpec();
				}
				break;

			case 31:
				this.enterOuterAlt(_localctx, 31);
				{
				this.state = 725;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 730;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 726;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 727;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 728;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 729;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 732;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 734;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 733;
					this.ifExists();
					}
				}

				this.state = 736;
				this.partitionSpec();
				this.state = 741;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 737;
					this.match(SparkSqlParser.COMMA);
					this.state = 738;
					this.partitionSpec();
					}
					}
					this.state = 743;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 745;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PURGE) {
					{
					this.state = 744;
					this.match(SparkSqlParser.KW_PURGE);
					}
				}

				}
				break;

			case 32:
				this.enterOuterAlt(_localctx, 32);
				{
				this.state = 747;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 748;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 749;
				this.tableName();
				this.state = 751;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 750;
					this.partitionSpec();
					}
				}

				this.state = 753;
				this.match(SparkSqlParser.KW_SET);
				this.state = 754;
				this.locationSpec();
				}
				break;

			case 33:
				this.enterOuterAlt(_localctx, 33);
				{
				this.state = 756;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 757;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 758;
				this.tableName();
				this.state = 759;
				this.match(SparkSqlParser.KW_RECOVER);
				this.state = 760;
				this.match(SparkSqlParser.KW_PARTITIONS);
				}
				break;

			case 34:
				this.enterOuterAlt(_localctx, 34);
				{
				this.state = 762;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 763;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 765;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 50, this._ctx) ) {
				case 1:
					{
					this.state = 764;
					this.ifExists();
					}
					break;
				}
				this.state = 767;
				this.tableName();
				this.state = 769;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PURGE) {
					{
					this.state = 768;
					this.match(SparkSqlParser.KW_PURGE);
					}
				}

				}
				break;

			case 35:
				this.enterOuterAlt(_localctx, 35);
				{
				this.state = 771;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 772;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 774;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 52, this._ctx) ) {
				case 1:
					{
					this.state = 773;
					this.ifExists();
					}
					break;
				}
				this.state = 776;
				this.viewName();
				}
				break;

			case 36:
				this.enterOuterAlt(_localctx, 36);
				{
				this.state = 777;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 780;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OR) {
					{
					this.state = 778;
					this.match(SparkSqlParser.KW_OR);
					this.state = 779;
					this.match(SparkSqlParser.KW_REPLACE);
					}
				}

				this.state = 786;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_GLOBAL || _la === SparkSqlParser.KW_TEMPORARY) {
					{
					this.state = 783;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_GLOBAL) {
						{
						this.state = 782;
						this.match(SparkSqlParser.KW_GLOBAL);
						}
					}

					this.state = 785;
					this.match(SparkSqlParser.KW_TEMPORARY);
					}
				}

				this.state = 788;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 790;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 56, this._ctx) ) {
				case 1:
					{
					this.state = 789;
					this.ifNotExists();
					}
					break;
				}
				this.state = 792;
				this.viewNameCreate();
				this.state = 794;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.LEFT_PAREN) {
					{
					this.state = 793;
					this.identifierCommentList();
					}
				}

				this.state = 804;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.KW_COMMENT || _la === SparkSqlParser.KW_PARTITIONED || _la === SparkSqlParser.KW_TBLPROPERTIES) {
					{
					this.state = 802;
					this._errHandler.sync(this);
					switch (this._input.LA(1)) {
					case SparkSqlParser.KW_COMMENT:
						{
						this.state = 796;
						this.commentSpec();
						}
						break;
					case SparkSqlParser.KW_PARTITIONED:
						{
						{
						this.state = 797;
						this.match(SparkSqlParser.KW_PARTITIONED);
						this.state = 798;
						this.match(SparkSqlParser.KW_ON);
						this.state = 799;
						this.identifierList();
						}
						}
						break;
					case SparkSqlParser.KW_TBLPROPERTIES:
						{
						{
						this.state = 800;
						this.match(SparkSqlParser.KW_TBLPROPERTIES);
						this.state = 801;
						this.propertyList();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					this.state = 806;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 807;
				this.match(SparkSqlParser.KW_AS);
				this.state = 808;
				this.query();
				}
				break;

			case 37:
				this.enterOuterAlt(_localctx, 37);
				{
				this.state = 810;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 813;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OR) {
					{
					this.state = 811;
					this.match(SparkSqlParser.KW_OR);
					this.state = 812;
					this.match(SparkSqlParser.KW_REPLACE);
					}
				}

				this.state = 816;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_GLOBAL) {
					{
					this.state = 815;
					this.match(SparkSqlParser.KW_GLOBAL);
					}
				}

				this.state = 818;
				this.match(SparkSqlParser.KW_TEMPORARY);
				this.state = 819;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 820;
				this.viewNameCreate();
				this.state = 825;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.LEFT_PAREN) {
					{
					this.state = 821;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 822;
					this.colTypeList();
					this.state = 823;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
				}

				this.state = 827;
				this.tableProvider();
				this.state = 830;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 828;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 829;
					this.propertyList();
					}
				}

				}
				break;

			case 38:
				this.enterOuterAlt(_localctx, 38);
				{
				this.state = 832;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 833;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 834;
				this.viewName();
				this.state = 836;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_AS) {
					{
					this.state = 835;
					this.match(SparkSqlParser.KW_AS);
					}
				}

				this.state = 838;
				this.query();
				}
				break;

			case 39:
				this.enterOuterAlt(_localctx, 39);
				{
				this.state = 840;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 843;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OR) {
					{
					this.state = 841;
					this.match(SparkSqlParser.KW_OR);
					this.state = 842;
					this.match(SparkSqlParser.KW_REPLACE);
					}
				}

				this.state = 846;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_TEMPORARY) {
					{
					this.state = 845;
					this.match(SparkSqlParser.KW_TEMPORARY);
					}
				}

				this.state = 848;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 850;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 67, this._ctx) ) {
				case 1:
					{
					this.state = 849;
					this.ifNotExists();
					}
					break;
				}
				this.state = 852;
				this.functionNameCreate();
				this.state = 853;
				this.match(SparkSqlParser.KW_AS);
				this.state = 854;
				_localctx._className = this.stringLit();
				this.state = 864;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 855;
					this.match(SparkSqlParser.KW_USING);
					this.state = 856;
					this.resource();
					this.state = 861;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 857;
						this.match(SparkSqlParser.COMMA);
						this.state = 858;
						this.resource();
						}
						}
						this.state = 863;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
				}

				}
				break;

			case 40:
				this.enterOuterAlt(_localctx, 40);
				{
				this.state = 866;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 868;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_TEMPORARY) {
					{
					this.state = 867;
					this.match(SparkSqlParser.KW_TEMPORARY);
					}
				}

				this.state = 870;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 872;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 71, this._ctx) ) {
				case 1:
					{
					this.state = 871;
					this.ifExists();
					}
					break;
				}
				this.state = 874;
				this.functionName();
				}
				break;

			case 41:
				this.enterOuterAlt(_localctx, 41);
				{
				this.state = 875;
				this.match(SparkSqlParser.KW_DECLARE);
				this.state = 878;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 72, this._ctx) ) {
				case 1:
					{
					this.state = 876;
					this.match(SparkSqlParser.KW_OR);
					this.state = 877;
					this.match(SparkSqlParser.KW_REPLACE);
					}
					break;
				}
				this.state = 881;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 73, this._ctx) ) {
				case 1:
					{
					this.state = 880;
					this.match(SparkSqlParser.KW_VARIABLE);
					}
					break;
				}
				this.state = 883;
				this.functionName();
				this.state = 885;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 74, this._ctx) ) {
				case 1:
					{
					this.state = 884;
					this.dataType();
					}
					break;
				}
				this.state = 888;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.EQ) {
					{
					this.state = 887;
					this.variableDefaultExpression();
					}
				}

				}
				break;

			case 42:
				this.enterOuterAlt(_localctx, 42);
				{
				this.state = 890;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 891;
				this.match(SparkSqlParser.KW_TEMPORARY);
				this.state = 892;
				this.match(SparkSqlParser.KW_VARIABLE);
				this.state = 894;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 76, this._ctx) ) {
				case 1:
					{
					this.state = 893;
					this.ifExists();
					}
					break;
				}
				this.state = 899;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 77, this._ctx) ) {
				case 1:
					{
					this.state = 896;
					this.tableName();
					}
					break;

				case 2:
					{
					this.state = 897;
					this.viewName();
					}
					break;

				case 3:
					{
					this.state = 898;
					this.functionName();
					}
					break;
				}
				}
				break;

			case 43:
				this.enterOuterAlt(_localctx, 43);
				{
				this.state = 901;
				this.match(SparkSqlParser.KW_EXPLAIN);
				this.state = 903;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_CODEGEN || _la === SparkSqlParser.KW_COST || _la === SparkSqlParser.KW_EXTENDED || _la === SparkSqlParser.KW_FORMATTED || _la === SparkSqlParser.KW_LOGICAL) {
					{
					this.state = 902;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_CODEGEN || _la === SparkSqlParser.KW_COST || _la === SparkSqlParser.KW_EXTENDED || _la === SparkSqlParser.KW_FORMATTED || _la === SparkSqlParser.KW_LOGICAL)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					}
				}

				this.state = 905;
				this.statement();
				}
				break;

			case 44:
				this.enterOuterAlt(_localctx, 44);
				{
				this.state = 906;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 907;
				this.match(SparkSqlParser.KW_TABLES);
				this.state = 910;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 79, this._ctx) ) {
				case 1:
					{
					this.state = 908;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 909;
					this.dbSchemaName();
					}
					break;
				}
				this.state = 916;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.STRING_LITERAL || _la === SparkSqlParser.DOUBLEQUOTED_STRING) {
					{
					this.state = 913;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_LIKE) {
						{
						this.state = 912;
						this.match(SparkSqlParser.KW_LIKE);
						}
					}

					this.state = 915;
					_localctx._pattern = this.stringLit();
					}
				}

				}
				break;

			case 45:
				this.enterOuterAlt(_localctx, 45);
				{
				this.state = 918;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 919;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 920;
				this.match(SparkSqlParser.KW_EXTENDED);
				this.state = 923;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN) {
					{
					this.state = 921;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 922;
					_localctx._ns = this.dbSchemaName();
					}
				}

				this.state = 925;
				this.match(SparkSqlParser.KW_LIKE);
				this.state = 926;
				_localctx._pattern = this.stringLit();
				this.state = 928;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 927;
					this.partitionSpec();
					}
				}

				}
				break;

			case 46:
				this.enterOuterAlt(_localctx, 46);
				{
				this.state = 930;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 931;
				this.match(SparkSqlParser.KW_TBLPROPERTIES);
				this.state = 932;
				_localctx._table = this.tableName();
				this.state = 937;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 84, this._ctx) ) {
				case 1:
					{
					this.state = 933;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 934;
					_localctx._key = this.propertyKey();
					this.state = 935;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				}
				break;

			case 47:
				this.enterOuterAlt(_localctx, 47);
				{
				this.state = 939;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 940;
				this.match(SparkSqlParser.KW_COLUMNS);
				this.state = 941;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 942;
				_localctx._table = this.tableName();
				this.state = 945;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 85, this._ctx) ) {
				case 1:
					{
					this.state = 943;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 944;
					this.dbSchemaName();
					}
					break;
				}
				}
				break;

			case 48:
				this.enterOuterAlt(_localctx, 48);
				{
				this.state = 947;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 948;
				this.match(SparkSqlParser.KW_VIEWS);
				this.state = 951;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 86, this._ctx) ) {
				case 1:
					{
					this.state = 949;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 950;
					this.dbSchemaName();
					}
					break;
				}
				this.state = 957;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.STRING_LITERAL || _la === SparkSqlParser.DOUBLEQUOTED_STRING) {
					{
					this.state = 954;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_LIKE) {
						{
						this.state = 953;
						this.match(SparkSqlParser.KW_LIKE);
						}
					}

					this.state = 956;
					_localctx._pattern = this.stringLit();
					}
				}

				}
				break;

			case 49:
				this.enterOuterAlt(_localctx, 49);
				{
				this.state = 959;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 960;
				this.match(SparkSqlParser.KW_PARTITIONS);
				this.state = 961;
				this.tableName();
				this.state = 963;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 962;
					this.partitionSpec();
					}
				}

				}
				break;

			case 50:
				this.enterOuterAlt(_localctx, 50);
				{
				this.state = 965;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 967;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_SYSTEM || _la === SparkSqlParser.KW_USER) {
					{
					this.state = 966;
					this.functionKind();
					}
				}

				this.state = 969;
				this.match(SparkSqlParser.KW_FUNCTIONS);
				this.state = 972;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 91, this._ctx) ) {
				case 1:
					{
					this.state = 970;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 971;
					_localctx._ns = this.dbSchemaName();
					}
					break;
				}
				this.state = 981;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 94, this._ctx) ) {
				case 1:
					{
					this.state = 975;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 92, this._ctx) ) {
					case 1:
						{
						this.state = 974;
						this.match(SparkSqlParser.KW_LIKE);
						}
						break;
					}
					this.state = 979;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 93, this._ctx) ) {
					case 1:
						{
						this.state = 977;
						_localctx._legacy = this.multipartIdentifier();
						}
						break;

					case 2:
						{
						this.state = 978;
						_localctx._pattern = this.stringLit();
						}
						break;
					}
					}
					break;
				}
				}
				break;

			case 51:
				this.enterOuterAlt(_localctx, 51);
				{
				this.state = 983;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 984;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 985;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 986;
				this.tableName();
				this.state = 989;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_AS) {
					{
					this.state = 987;
					this.match(SparkSqlParser.KW_AS);
					this.state = 988;
					this.match(SparkSqlParser.KW_SERDE);
					}
				}

				}
				break;

			case 52:
				this.enterOuterAlt(_localctx, 52);
				{
				this.state = 991;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 992;
				this.match(SparkSqlParser.KW_CURRENT);
				this.state = 993;
				this.dbSchema();
				}
				break;

			case 53:
				this.enterOuterAlt(_localctx, 53);
				{
				this.state = 994;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 995;
				this.match(SparkSqlParser.KW_CATALOGS);
				this.state = 1000;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.STRING_LITERAL || _la === SparkSqlParser.DOUBLEQUOTED_STRING) {
					{
					this.state = 997;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_LIKE) {
						{
						this.state = 996;
						this.match(SparkSqlParser.KW_LIKE);
						}
					}

					this.state = 999;
					_localctx._pattern = this.stringLit();
					}
				}

				}
				break;

			case 54:
				this.enterOuterAlt(_localctx, 54);
				{
				this.state = 1002;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1003;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 1005;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 98, this._ctx) ) {
				case 1:
					{
					this.state = 1004;
					this.match(SparkSqlParser.KW_EXTENDED);
					}
					break;
				}
				this.state = 1007;
				this.describeFuncName();
				}
				break;

			case 55:
				this.enterOuterAlt(_localctx, 55);
				{
				this.state = 1008;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1009;
				this.match(SparkSqlParser.KW_DATABASE);
				this.state = 1011;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 99, this._ctx) ) {
				case 1:
					{
					this.state = 1010;
					this.match(SparkSqlParser.KW_EXTENDED);
					}
					break;
				}
				this.state = 1013;
				this.dbSchemaName();
				}
				break;

			case 56:
				this.enterOuterAlt(_localctx, 56);
				{
				this.state = 1014;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1016;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 100, this._ctx) ) {
				case 1:
					{
					this.state = 1015;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1019;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 101, this._ctx) ) {
				case 1:
					{
					this.state = 1018;
					_localctx._option = this._input.LT(1);
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_EXTENDED || _la === SparkSqlParser.KW_FORMATTED)) {
						_localctx._option = this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					}
					break;
				}
				this.state = 1021;
				this.tableName();
				this.state = 1023;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 102, this._ctx) ) {
				case 1:
					{
					this.state = 1022;
					this.partitionSpec();
					}
					break;
				}
				this.state = 1026;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 103, this._ctx) ) {
				case 1:
					{
					this.state = 1025;
					this.describeColName();
					}
					break;
				}
				}
				break;

			case 57:
				this.enterOuterAlt(_localctx, 57);
				{
				this.state = 1028;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DESC || _la === SparkSqlParser.KW_DESCRIBE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1030;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_QUERY) {
					{
					this.state = 1029;
					this.match(SparkSqlParser.KW_QUERY);
					}
				}

				this.state = 1032;
				this.query();
				}
				break;

			case 58:
				this.enterOuterAlt(_localctx, 58);
				{
				this.state = 1033;
				this.match(SparkSqlParser.KW_COMMENT);
				this.state = 1034;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1035;
				this.dbSchema();
				this.state = 1036;
				this.dbSchemaName();
				this.state = 1037;
				this.match(SparkSqlParser.KW_IS);
				this.state = 1038;
				this.comment();
				}
				break;

			case 59:
				this.enterOuterAlt(_localctx, 59);
				{
				this.state = 1040;
				this.match(SparkSqlParser.KW_COMMENT);
				this.state = 1041;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1042;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1043;
				this.tableName();
				this.state = 1044;
				this.match(SparkSqlParser.KW_IS);
				this.state = 1045;
				this.comment();
				}
				break;

			case 60:
				this.enterOuterAlt(_localctx, 60);
				{
				this.state = 1047;
				this.match(SparkSqlParser.KW_REFRESH);
				this.state = 1048;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1049;
				this.tableName();
				}
				break;

			case 61:
				this.enterOuterAlt(_localctx, 61);
				{
				this.state = 1050;
				this.match(SparkSqlParser.KW_REFRESH);
				this.state = 1051;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 1052;
				this.functionName();
				}
				break;

			case 62:
				this.enterOuterAlt(_localctx, 62);
				{
				this.state = 1053;
				this.match(SparkSqlParser.KW_REFRESH);
				this.state = 1061;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 106, this._ctx) ) {
				case 1:
					{
					this.state = 1054;
					this.stringLit();
					}
					break;

				case 2:
					{
					this.state = 1058;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 105, this._ctx);
					while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
						if (_alt === 1 + 1) {
							{
							{
							this.state = 1055;
							this.matchWildcard();
							}
							}
						}
						this.state = 1060;
						this._errHandler.sync(this);
						_alt = this.interpreter.adaptivePredict(this._input, 105, this._ctx);
					}
					}
					break;
				}
				}
				break;

			case 63:
				this.enterOuterAlt(_localctx, 63);
				{
				this.state = 1063;
				this.match(SparkSqlParser.KW_CACHE);
				this.state = 1065;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LAZY) {
					{
					this.state = 1064;
					this.match(SparkSqlParser.KW_LAZY);
					}
				}

				this.state = 1067;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1068;
				this.tableName();
				this.state = 1071;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 1069;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 1070;
					_localctx._options = this.propertyList();
					}
				}

				this.state = 1077;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 110, this._ctx) ) {
				case 1:
					{
					this.state = 1074;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_AS) {
						{
						this.state = 1073;
						this.match(SparkSqlParser.KW_AS);
						}
					}

					this.state = 1076;
					this.query();
					}
					break;
				}
				}
				break;

			case 64:
				this.enterOuterAlt(_localctx, 64);
				{
				this.state = 1079;
				this.match(SparkSqlParser.KW_UNCACHE);
				this.state = 1080;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1082;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 111, this._ctx) ) {
				case 1:
					{
					this.state = 1081;
					this.ifExists();
					}
					break;
				}
				this.state = 1084;
				this.tableName();
				}
				break;

			case 65:
				this.enterOuterAlt(_localctx, 65);
				{
				this.state = 1085;
				this.match(SparkSqlParser.KW_CLEAR);
				this.state = 1086;
				this.match(SparkSqlParser.KW_CACHE);
				}
				break;

			case 66:
				this.enterOuterAlt(_localctx, 66);
				{
				this.state = 1087;
				this.match(SparkSqlParser.KW_LOAD);
				this.state = 1088;
				this.match(SparkSqlParser.KW_DATA);
				this.state = 1090;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LOCAL) {
					{
					this.state = 1089;
					this.match(SparkSqlParser.KW_LOCAL);
					}
				}

				this.state = 1092;
				this.match(SparkSqlParser.KW_INPATH);
				this.state = 1093;
				_localctx._path = this.stringLit();
				this.state = 1095;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OVERWRITE) {
					{
					this.state = 1094;
					this.match(SparkSqlParser.KW_OVERWRITE);
					}
				}

				this.state = 1097;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1098;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1099;
				this.tableName();
				this.state = 1101;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1100;
					this.partitionSpec();
					}
				}

				}
				break;

			case 67:
				this.enterOuterAlt(_localctx, 67);
				{
				this.state = 1103;
				this.match(SparkSqlParser.KW_TRUNCATE);
				this.state = 1104;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1105;
				this.tableName();
				this.state = 1107;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1106;
					this.partitionSpec();
					}
				}

				}
				break;

			case 68:
				this.enterOuterAlt(_localctx, 68);
				{
				this.state = 1110;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_MSCK) {
					{
					this.state = 1109;
					this.match(SparkSqlParser.KW_MSCK);
					}
				}

				this.state = 1112;
				this.match(SparkSqlParser.KW_REPAIR);
				this.state = 1113;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1114;
				this.tableName();
				this.state = 1117;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 117, this._ctx) ) {
				case 1:
					{
					this.state = 1115;
					_localctx._option = this._input.LT(1);
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_ADD || _la === SparkSqlParser.KW_DROP || _la === SparkSqlParser.KW_SYNC)) {
						_localctx._option = this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 1116;
					this.match(SparkSqlParser.KW_PARTITIONS);
					}
					break;
				}
				}
				break;

			case 69:
				this.enterOuterAlt(_localctx, 69);
				{
				this.state = 1119;
				_localctx._op = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_ADD || _la === SparkSqlParser.KW_LIST)) {
					_localctx._op = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1120;
				this.identifier();
				this.state = 1124;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 118, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1121;
						this.matchWildcard();
						}
						}
					}
					this.state = 1126;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 118, this._ctx);
				}
				}
				break;

			case 70:
				this.enterOuterAlt(_localctx, 70);
				{
				this.state = 1127;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1128;
				this.match(SparkSqlParser.KW_ROLE);
				this.state = 1132;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 119, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1129;
						this.matchWildcard();
						}
						}
					}
					this.state = 1134;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 119, this._ctx);
				}
				}
				break;

			case 71:
				this.enterOuterAlt(_localctx, 71);
				{
				this.state = 1135;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1136;
				this.match(SparkSqlParser.KW_TIME);
				this.state = 1137;
				this.match(SparkSqlParser.KW_ZONE);
				this.state = 1138;
				this.interval();
				}
				break;

			case 72:
				this.enterOuterAlt(_localctx, 72);
				{
				this.state = 1139;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1140;
				this.match(SparkSqlParser.KW_TIME);
				this.state = 1141;
				this.match(SparkSqlParser.KW_ZONE);
				this.state = 1142;
				this.timezone();
				}
				break;

			case 73:
				this.enterOuterAlt(_localctx, 73);
				{
				this.state = 1143;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1144;
				this.match(SparkSqlParser.KW_TIME);
				this.state = 1145;
				this.match(SparkSqlParser.KW_ZONE);
				this.state = 1149;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 120, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1146;
						this.matchWildcard();
						}
						}
					}
					this.state = 1151;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 120, this._ctx);
				}
				}
				break;

			case 74:
				this.enterOuterAlt(_localctx, 74);
				{
				this.state = 1152;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1153;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_VAR || _la === SparkSqlParser.KW_VARIABLE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1154;
				this.assignmentList();
				}
				break;

			case 75:
				this.enterOuterAlt(_localctx, 75);
				{
				this.state = 1155;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1156;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_VAR || _la === SparkSqlParser.KW_VARIABLE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 1157;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1158;
				this.multipartIdentifierList();
				this.state = 1159;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 1160;
				this.match(SparkSqlParser.EQ);
				this.state = 1161;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1162;
				this.query();
				this.state = 1163;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 76:
				this.enterOuterAlt(_localctx, 76);
				{
				this.state = 1165;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1166;
				this.configKey();
				this.state = 1167;
				this.match(SparkSqlParser.EQ);
				this.state = 1168;
				this.configValue();
				}
				break;

			case 77:
				this.enterOuterAlt(_localctx, 77);
				{
				this.state = 1170;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1171;
				this.configKey();
				this.state = 1179;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.EQ) {
					{
					this.state = 1172;
					this.match(SparkSqlParser.EQ);
					this.state = 1176;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 121, this._ctx);
					while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
						if (_alt === 1 + 1) {
							{
							{
							this.state = 1173;
							this.matchWildcard();
							}
							}
						}
						this.state = 1178;
						this._errHandler.sync(this);
						_alt = this.interpreter.adaptivePredict(this._input, 121, this._ctx);
					}
					}
				}

				}
				break;

			case 78:
				this.enterOuterAlt(_localctx, 78);
				{
				this.state = 1181;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1185;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 123, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1182;
						this.matchWildcard();
						}
						}
					}
					this.state = 1187;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 123, this._ctx);
				}
				this.state = 1188;
				this.match(SparkSqlParser.EQ);
				this.state = 1189;
				this.configValue();
				}
				break;

			case 79:
				this.enterOuterAlt(_localctx, 79);
				{
				this.state = 1190;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1194;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 124, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1191;
						this.matchWildcard();
						}
						}
					}
					this.state = 1196;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 124, this._ctx);
				}
				}
				break;

			case 80:
				this.enterOuterAlt(_localctx, 80);
				{
				this.state = 1197;
				this.match(SparkSqlParser.KW_RESET);
				this.state = 1198;
				this.configKey();
				}
				break;

			case 81:
				this.enterOuterAlt(_localctx, 81);
				{
				this.state = 1199;
				this.match(SparkSqlParser.KW_RESET);
				this.state = 1203;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 125, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1200;
						this.matchWildcard();
						}
						}
					}
					this.state = 1205;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 125, this._ctx);
				}
				}
				break;

			case 82:
				this.enterOuterAlt(_localctx, 82);
				{
				this.state = 1206;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 1207;
				this.match(SparkSqlParser.KW_INDEX);
				this.state = 1209;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 126, this._ctx) ) {
				case 1:
					{
					this.state = 1208;
					this.ifNotExists();
					}
					break;
				}
				this.state = 1211;
				this.identifier();
				this.state = 1212;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1214;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 127, this._ctx) ) {
				case 1:
					{
					this.state = 1213;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1216;
				this.tableName();
				this.state = 1219;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 1217;
					this.match(SparkSqlParser.KW_USING);
					this.state = 1218;
					_localctx._indexType = this.identifier();
					}
				}

				this.state = 1221;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1222;
				this.multipartIdentifierPropertyList();
				this.state = 1223;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 1226;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 1224;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 1225;
					_localctx._options = this.propertyList();
					}
				}

				}
				break;

			case 83:
				this.enterOuterAlt(_localctx, 83);
				{
				this.state = 1228;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 1229;
				this.match(SparkSqlParser.KW_INDEX);
				this.state = 1231;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 130, this._ctx) ) {
				case 1:
					{
					this.state = 1230;
					this.ifExists();
					}
					break;
				}
				this.state = 1233;
				this.identifier();
				this.state = 1234;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1236;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 131, this._ctx) ) {
				case 1:
					{
					this.state = 1235;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1238;
				this.tableName();
				}
				break;

			case 84:
				this.enterOuterAlt(_localctx, 84);
				{
				this.state = 1240;
				this.unsupportedHiveNativeCommands();
				this.state = 1244;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 132, this._ctx);
				while (_alt !== 1 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1 + 1) {
						{
						{
						this.state = 1241;
						this.matchWildcard();
						}
						}
					}
					this.state = 1246;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 132, this._ctx);
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public timezone(): TimezoneContext {
		let _localctx: TimezoneContext = new TimezoneContext(this._ctx, this.state);
		this.enterRule(_localctx, 6, SparkSqlParser.RULE_timezone);
		try {
			this.state = 1251;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.STRING_LITERAL:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1249;
				this.stringLit();
				}
				break;
			case SparkSqlParser.KW_LOCAL:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1250;
				this.match(SparkSqlParser.KW_LOCAL);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public configKey(): ConfigKeyContext {
		let _localctx: ConfigKeyContext = new ConfigKeyContext(this._ctx, this.state);
		this.enterRule(_localctx, 8, SparkSqlParser.RULE_configKey);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1253;
			this.quotedIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public configValue(): ConfigValueContext {
		let _localctx: ConfigValueContext = new ConfigValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 10, SparkSqlParser.RULE_configValue);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1255;
			this.backQuotedIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext {
		let _localctx: UnsupportedHiveNativeCommandsContext = new UnsupportedHiveNativeCommandsContext(this._ctx, this.state);
		this.enterRule(_localctx, 12, SparkSqlParser.RULE_unsupportedHiveNativeCommands);
		let _la: number;
		try {
			this.state = 1425;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 142, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1257;
				_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
				this.state = 1258;
				_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1259;
				_localctx._kw1 = this.match(SparkSqlParser.KW_DROP);
				this.state = 1260;
				_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1261;
				_localctx._kw1 = this.match(SparkSqlParser.KW_GRANT);
				this.state = 1263;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 135, this._ctx) ) {
				case 1:
					{
					this.state = 1262;
					_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
					}
					break;
				}
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1265;
				_localctx._kw1 = this.match(SparkSqlParser.KW_REVOKE);
				this.state = 1267;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 136, this._ctx) ) {
				case 1:
					{
					this.state = 1266;
					_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
					}
					break;
				}
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1269;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1270;
				_localctx._kw2 = this.match(SparkSqlParser.KW_GRANT);
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 1271;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1272;
				_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
				this.state = 1274;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 137, this._ctx) ) {
				case 1:
					{
					this.state = 1273;
					_localctx._kw3 = this.match(SparkSqlParser.KW_GRANT);
					}
					break;
				}
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 1276;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1277;
				_localctx._kw2 = this.match(SparkSqlParser.KW_PRINCIPALS);
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 1278;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1279;
				_localctx._kw2 = this.match(SparkSqlParser.KW_ROLES);
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 1280;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1281;
				_localctx._kw2 = this.match(SparkSqlParser.KW_CURRENT);
				this.state = 1282;
				_localctx._kw3 = this.match(SparkSqlParser.KW_ROLES);
				}
				break;

			case 10:
				this.enterOuterAlt(_localctx, 10);
				{
				this.state = 1283;
				_localctx._kw1 = this.match(SparkSqlParser.KW_EXPORT);
				this.state = 1284;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				}
				break;

			case 11:
				this.enterOuterAlt(_localctx, 11);
				{
				this.state = 1285;
				_localctx._kw1 = this.match(SparkSqlParser.KW_IMPORT);
				this.state = 1286;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				}
				break;

			case 12:
				this.enterOuterAlt(_localctx, 12);
				{
				this.state = 1287;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1288;
				_localctx._kw2 = this.match(SparkSqlParser.KW_COMPACTIONS);
				}
				break;

			case 13:
				this.enterOuterAlt(_localctx, 13);
				{
				this.state = 1289;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1290;
				_localctx._kw2 = this.match(SparkSqlParser.KW_CREATE);
				this.state = 1291;
				_localctx._kw3 = this.match(SparkSqlParser.KW_TABLE);
				}
				break;

			case 14:
				this.enterOuterAlt(_localctx, 14);
				{
				this.state = 1292;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1293;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TRANSACTIONS);
				}
				break;

			case 15:
				this.enterOuterAlt(_localctx, 15);
				{
				this.state = 1294;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1295;
				_localctx._kw2 = this.match(SparkSqlParser.KW_INDEXES);
				}
				break;

			case 16:
				this.enterOuterAlt(_localctx, 16);
				{
				this.state = 1296;
				_localctx._kw1 = this.match(SparkSqlParser.KW_SHOW);
				this.state = 1297;
				_localctx._kw2 = this.match(SparkSqlParser.KW_LOCKS);
				}
				break;

			case 17:
				this.enterOuterAlt(_localctx, 17);
				{
				this.state = 1298;
				_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
				this.state = 1299;
				_localctx._kw2 = this.match(SparkSqlParser.KW_INDEX);
				}
				break;

			case 18:
				this.enterOuterAlt(_localctx, 18);
				{
				this.state = 1300;
				_localctx._kw1 = this.match(SparkSqlParser.KW_DROP);
				this.state = 1301;
				_localctx._kw2 = this.match(SparkSqlParser.KW_INDEX);
				}
				break;

			case 19:
				this.enterOuterAlt(_localctx, 19);
				{
				this.state = 1302;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1303;
				_localctx._kw2 = this.match(SparkSqlParser.KW_INDEX);
				}
				break;

			case 20:
				this.enterOuterAlt(_localctx, 20);
				{
				this.state = 1304;
				_localctx._kw1 = this.match(SparkSqlParser.KW_LOCK);
				this.state = 1305;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				}
				break;

			case 21:
				this.enterOuterAlt(_localctx, 21);
				{
				this.state = 1306;
				_localctx._kw1 = this.match(SparkSqlParser.KW_LOCK);
				this.state = 1307;
				_localctx._kw2 = this.match(SparkSqlParser.KW_DATABASE);
				}
				break;

			case 22:
				this.enterOuterAlt(_localctx, 22);
				{
				this.state = 1308;
				_localctx._kw1 = this.match(SparkSqlParser.KW_UNLOCK);
				this.state = 1309;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				}
				break;

			case 23:
				this.enterOuterAlt(_localctx, 23);
				{
				this.state = 1310;
				_localctx._kw1 = this.match(SparkSqlParser.KW_UNLOCK);
				this.state = 1311;
				_localctx._kw2 = this.match(SparkSqlParser.KW_DATABASE);
				}
				break;

			case 24:
				this.enterOuterAlt(_localctx, 24);
				{
				this.state = 1312;
				_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
				this.state = 1313;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TEMPORARY);
				this.state = 1314;
				_localctx._kw3 = this.match(SparkSqlParser.KW_MACRO);
				}
				break;

			case 25:
				this.enterOuterAlt(_localctx, 25);
				{
				this.state = 1315;
				_localctx._kw1 = this.match(SparkSqlParser.KW_DROP);
				this.state = 1316;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TEMPORARY);
				this.state = 1317;
				_localctx._kw3 = this.match(SparkSqlParser.KW_MACRO);
				}
				break;

			case 26:
				this.enterOuterAlt(_localctx, 26);
				{
				this.state = 1318;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1319;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1320;
				this.tableName();
				this.state = 1321;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1322;
				_localctx._kw4 = this.match(SparkSqlParser.KW_CLUSTERED);
				}
				break;

			case 27:
				this.enterOuterAlt(_localctx, 27);
				{
				this.state = 1324;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1325;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1326;
				this.tableName();
				this.state = 1327;
				_localctx._kw3 = this.match(SparkSqlParser.KW_CLUSTERED);
				this.state = 1328;
				_localctx._kw4 = this.match(SparkSqlParser.KW_BY);
				}
				break;

			case 28:
				this.enterOuterAlt(_localctx, 28);
				{
				this.state = 1330;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1331;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1332;
				this.tableName();
				this.state = 1333;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1334;
				_localctx._kw4 = this.match(SparkSqlParser.KW_SORTED);
				}
				break;

			case 29:
				this.enterOuterAlt(_localctx, 29);
				{
				this.state = 1336;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1337;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1338;
				this.tableName();
				this.state = 1339;
				_localctx._kw3 = this.match(SparkSqlParser.KW_SKEWED);
				this.state = 1340;
				_localctx._kw4 = this.match(SparkSqlParser.KW_BY);
				}
				break;

			case 30:
				this.enterOuterAlt(_localctx, 30);
				{
				this.state = 1342;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1343;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1344;
				this.tableName();
				this.state = 1345;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1346;
				_localctx._kw4 = this.match(SparkSqlParser.KW_SKEWED);
				}
				break;

			case 31:
				this.enterOuterAlt(_localctx, 31);
				{
				this.state = 1348;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1349;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1350;
				this.tableName();
				this.state = 1351;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1352;
				_localctx._kw4 = this.match(SparkSqlParser.KW_STORED);
				this.state = 1353;
				_localctx._kw5 = this.match(SparkSqlParser.KW_AS);
				this.state = 1354;
				_localctx._kw6 = this.match(SparkSqlParser.KW_DIRECTORIES);
				}
				break;

			case 32:
				this.enterOuterAlt(_localctx, 32);
				{
				this.state = 1356;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1357;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1358;
				this.tableName();
				this.state = 1359;
				_localctx._kw3 = this.match(SparkSqlParser.KW_SET);
				this.state = 1360;
				_localctx._kw4 = this.match(SparkSqlParser.KW_SKEWED);
				this.state = 1361;
				_localctx._kw5 = this.match(SparkSqlParser.KW_LOCATION);
				}
				break;

			case 33:
				this.enterOuterAlt(_localctx, 33);
				{
				this.state = 1363;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1364;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1365;
				this.tableName();
				this.state = 1366;
				_localctx._kw3 = this.match(SparkSqlParser.KW_EXCHANGE);
				this.state = 1367;
				_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
				}
				break;

			case 34:
				this.enterOuterAlt(_localctx, 34);
				{
				this.state = 1369;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1370;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1371;
				this.tableName();
				this.state = 1372;
				_localctx._kw3 = this.match(SparkSqlParser.KW_ARCHIVE);
				this.state = 1373;
				_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
				}
				break;

			case 35:
				this.enterOuterAlt(_localctx, 35);
				{
				this.state = 1375;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1376;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1377;
				this.tableName();
				this.state = 1378;
				_localctx._kw3 = this.match(SparkSqlParser.KW_UNARCHIVE);
				this.state = 1379;
				_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
				}
				break;

			case 36:
				this.enterOuterAlt(_localctx, 36);
				{
				this.state = 1381;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1382;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1383;
				this.tableName();
				this.state = 1384;
				_localctx._kw3 = this.match(SparkSqlParser.KW_TOUCH);
				}
				break;

			case 37:
				this.enterOuterAlt(_localctx, 37);
				{
				this.state = 1386;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1387;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1388;
				this.tableName();
				this.state = 1390;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1389;
					this.partitionSpec();
					}
				}

				this.state = 1392;
				_localctx._kw3 = this.match(SparkSqlParser.KW_COMPACT);
				}
				break;

			case 38:
				this.enterOuterAlt(_localctx, 38);
				{
				this.state = 1394;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1395;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1396;
				this.tableName();
				this.state = 1398;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1397;
					this.partitionSpec();
					}
				}

				this.state = 1400;
				_localctx._kw3 = this.match(SparkSqlParser.KW_CONCATENATE);
				}
				break;

			case 39:
				this.enterOuterAlt(_localctx, 39);
				{
				this.state = 1402;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1403;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1404;
				this.tableName();
				this.state = 1406;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1405;
					this.partitionSpec();
					}
				}

				this.state = 1408;
				_localctx._kw3 = this.match(SparkSqlParser.KW_SET);
				this.state = 1409;
				_localctx._kw4 = this.match(SparkSqlParser.KW_FILEFORMAT);
				}
				break;

			case 40:
				this.enterOuterAlt(_localctx, 40);
				{
				this.state = 1411;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1412;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1413;
				this.tableName();
				this.state = 1415;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1414;
					this.partitionSpec();
					}
				}

				this.state = 1417;
				_localctx._kw3 = this.match(SparkSqlParser.KW_REPLACE);
				this.state = 1418;
				_localctx._kw4 = this.match(SparkSqlParser.KW_COLUMNS);
				}
				break;

			case 41:
				this.enterOuterAlt(_localctx, 41);
				{
				this.state = 1420;
				_localctx._kw1 = this.match(SparkSqlParser.KW_START);
				this.state = 1421;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TRANSACTION);
				}
				break;

			case 42:
				this.enterOuterAlt(_localctx, 42);
				{
				this.state = 1422;
				_localctx._kw1 = this.match(SparkSqlParser.KW_COMMIT);
				}
				break;

			case 43:
				this.enterOuterAlt(_localctx, 43);
				{
				this.state = 1423;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ROLLBACK);
				}
				break;

			case 44:
				this.enterOuterAlt(_localctx, 44);
				{
				this.state = 1424;
				_localctx._kw1 = this.match(SparkSqlParser.KW_DFS);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public createTableHeader(): CreateTableHeaderContext {
		let _localctx: CreateTableHeaderContext = new CreateTableHeaderContext(this._ctx, this.state);
		this.enterRule(_localctx, 14, SparkSqlParser.RULE_createTableHeader);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1427;
			this.match(SparkSqlParser.KW_CREATE);
			this.state = 1429;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_TEMPORARY) {
				{
				this.state = 1428;
				this.match(SparkSqlParser.KW_TEMPORARY);
				}
			}

			this.state = 1432;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_EXTERNAL) {
				{
				this.state = 1431;
				this.match(SparkSqlParser.KW_EXTERNAL);
				}
			}

			this.state = 1434;
			this.match(SparkSqlParser.KW_TABLE);
			this.state = 1436;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 145, this._ctx) ) {
			case 1:
				{
				this.state = 1435;
				this.ifNotExists();
				}
				break;
			}
			this.state = 1438;
			this.tableNameCreate();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public replaceTableHeader(): ReplaceTableHeaderContext {
		let _localctx: ReplaceTableHeaderContext = new ReplaceTableHeaderContext(this._ctx, this.state);
		this.enterRule(_localctx, 16, SparkSqlParser.RULE_replaceTableHeader);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1442;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_CREATE) {
				{
				this.state = 1440;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 1441;
				this.match(SparkSqlParser.KW_OR);
				}
			}

			this.state = 1444;
			this.match(SparkSqlParser.KW_REPLACE);
			this.state = 1445;
			this.match(SparkSqlParser.KW_TABLE);
			this.state = 1446;
			this.tableNameCreate();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public bucketSpec(): BucketSpecContext {
		let _localctx: BucketSpecContext = new BucketSpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 18, SparkSqlParser.RULE_bucketSpec);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1448;
			this.match(SparkSqlParser.KW_CLUSTERED);
			this.state = 1449;
			this.match(SparkSqlParser.KW_BY);
			this.state = 1450;
			this.identifierList();
			this.state = 1454;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_SORTED) {
				{
				this.state = 1451;
				this.match(SparkSqlParser.KW_SORTED);
				this.state = 1452;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1453;
				this.orderedIdentifierList();
				}
			}

			this.state = 1456;
			this.match(SparkSqlParser.KW_INTO);
			this.state = 1457;
			this.match(SparkSqlParser.INTEGER_VALUE);
			this.state = 1458;
			this.match(SparkSqlParser.KW_BUCKETS);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public skewSpec(): SkewSpecContext {
		let _localctx: SkewSpecContext = new SkewSpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 20, SparkSqlParser.RULE_skewSpec);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1460;
			this.match(SparkSqlParser.KW_SKEWED);
			this.state = 1461;
			this.match(SparkSqlParser.KW_BY);
			this.state = 1462;
			this.identifierList();
			this.state = 1463;
			this.match(SparkSqlParser.KW_ON);
			this.state = 1466;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 148, this._ctx) ) {
			case 1:
				{
				this.state = 1464;
				this.constantList();
				}
				break;

			case 2:
				{
				this.state = 1465;
				this.nestedConstantList();
				}
				break;
			}
			this.state = 1471;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 149, this._ctx) ) {
			case 1:
				{
				this.state = 1468;
				this.match(SparkSqlParser.KW_STORED);
				this.state = 1469;
				this.match(SparkSqlParser.KW_AS);
				this.state = 1470;
				this.match(SparkSqlParser.KW_DIRECTORIES);
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public locationSpec(): LocationSpecContext {
		let _localctx: LocationSpecContext = new LocationSpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 22, SparkSqlParser.RULE_locationSpec);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1473;
			this.match(SparkSqlParser.KW_LOCATION);
			this.state = 1474;
			this.stringLit();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public commentSpec(): CommentSpecContext {
		let _localctx: CommentSpecContext = new CommentSpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 24, SparkSqlParser.RULE_commentSpec);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1476;
			this.match(SparkSqlParser.KW_COMMENT);
			this.state = 1477;
			this.stringLit();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public query(): QueryContext {
		let _localctx: QueryContext = new QueryContext(this._ctx, this.state);
		this.enterRule(_localctx, 26, SparkSqlParser.RULE_query);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1480;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_WITH) {
				{
				this.state = 1479;
				this.ctes();
				}
			}

			this.state = 1482;
			this.queryTerm(0);
			this.state = 1483;
			this.queryOrganization();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public insertInto(): InsertIntoContext {
		let _localctx: InsertIntoContext = new InsertIntoContext(this._ctx, this.state);
		this.enterRule(_localctx, 28, SparkSqlParser.RULE_insertInto);
		let _la: number;
		try {
			this.state = 1561;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 166, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1485;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1486;
				this.match(SparkSqlParser.KW_OVERWRITE);
				this.state = 1488;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 151, this._ctx) ) {
				case 1:
					{
					this.state = 1487;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1490;
				this.tableName();
				this.state = 1495;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1491;
					this.partitionSpec();
					this.state = 1493;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_IF) {
						{
						this.state = 1492;
						this.ifNotExists();
						}
					}

					}
				}

				this.state = 1503;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 154, this._ctx) ) {
				case 1:
					{
					{
					this.state = 1497;
					this.match(SparkSqlParser.KW_BY);
					this.state = 1498;
					this.match(SparkSqlParser.KW_NAME);
					}
					}
					break;

				case 2:
					{
					{
					this.state = 1499;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 1500;
					this.columnNameSeq();
					this.state = 1501;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					break;
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1505;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1506;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1508;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 155, this._ctx) ) {
				case 1:
					{
					this.state = 1507;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1510;
				this.tableName();
				this.state = 1512;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1511;
					this.partitionSpec();
					}
				}

				this.state = 1515;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 1514;
					this.ifNotExists();
					}
				}

				this.state = 1523;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 158, this._ctx) ) {
				case 1:
					{
					{
					this.state = 1517;
					this.match(SparkSqlParser.KW_BY);
					this.state = 1518;
					this.match(SparkSqlParser.KW_NAME);
					}
					}
					break;

				case 2:
					{
					{
					this.state = 1519;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 1520;
					this.columnNameSeq();
					this.state = 1521;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					break;
				}
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1525;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1526;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1528;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 159, this._ctx) ) {
				case 1:
					{
					this.state = 1527;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1530;
				this.tableName();
				this.state = 1531;
				this.match(SparkSqlParser.KW_REPLACE);
				this.state = 1532;
				this.whereClause();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1534;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1535;
				this.match(SparkSqlParser.KW_OVERWRITE);
				this.state = 1537;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LOCAL) {
					{
					this.state = 1536;
					this.match(SparkSqlParser.KW_LOCAL);
					}
				}

				this.state = 1539;
				this.match(SparkSqlParser.KW_DIRECTORY);
				this.state = 1540;
				_localctx._path = this.stringLit();
				this.state = 1542;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ROW) {
					{
					this.state = 1541;
					this.rowFormat();
					}
				}

				this.state = 1545;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_STORED) {
					{
					this.state = 1544;
					this.createFileFormat();
					}
				}

				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1547;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1548;
				this.match(SparkSqlParser.KW_OVERWRITE);
				this.state = 1550;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LOCAL) {
					{
					this.state = 1549;
					this.match(SparkSqlParser.KW_LOCAL);
					}
				}

				this.state = 1552;
				this.match(SparkSqlParser.KW_DIRECTORY);
				this.state = 1554;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.STRING_LITERAL || _la === SparkSqlParser.DOUBLEQUOTED_STRING) {
					{
					this.state = 1553;
					_localctx._path = this.stringLit();
					}
				}

				this.state = 1556;
				this.tableProvider();
				this.state = 1559;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 1557;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 1558;
					_localctx._options = this.propertyList();
					}
				}

				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public partitionSpecLocation(): PartitionSpecLocationContext {
		let _localctx: PartitionSpecLocationContext = new PartitionSpecLocationContext(this._ctx, this.state);
		this.enterRule(_localctx, 30, SparkSqlParser.RULE_partitionSpecLocation);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1563;
			this.partitionSpec();
			this.state = 1565;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_LOCATION) {
				{
				this.state = 1564;
				this.locationSpec();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public partitionSpec(): PartitionSpecContext {
		let _localctx: PartitionSpecContext = new PartitionSpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 32, SparkSqlParser.RULE_partitionSpec);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1567;
			this.match(SparkSqlParser.KW_PARTITION);
			this.state = 1568;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1569;
			this.partitionVal();
			this.state = 1574;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1570;
				this.match(SparkSqlParser.COMMA);
				this.state = 1571;
				this.partitionVal();
				}
				}
				this.state = 1576;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1577;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public partitionVal(): PartitionValContext {
		let _localctx: PartitionValContext = new PartitionValContext(this._ctx, this.state);
		this.enterRule(_localctx, 34, SparkSqlParser.RULE_partitionVal);
		let _la: number;
		try {
			this.state = 1588;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 170, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1579;
				this.identifier();
				this.state = 1582;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.EQ) {
					{
					this.state = 1580;
					this.match(SparkSqlParser.EQ);
					this.state = 1581;
					this.constant();
					}
				}

				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1584;
				this.identifier();
				this.state = 1585;
				this.match(SparkSqlParser.EQ);
				this.state = 1586;
				this.match(SparkSqlParser.KW_DEFAULT);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dbSchema(): DbSchemaContext {
		let _localctx: DbSchemaContext = new DbSchemaContext(this._ctx, this.state);
		this.enterRule(_localctx, 36, SparkSqlParser.RULE_dbSchema);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1590;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DATABASE || _la === SparkSqlParser.KW_NAMESPACE || _la === SparkSqlParser.KW_SCHEMA)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dbSchemas(): DbSchemasContext {
		let _localctx: DbSchemasContext = new DbSchemasContext(this._ctx, this.state);
		this.enterRule(_localctx, 38, SparkSqlParser.RULE_dbSchemas);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1592;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DATABASES || _la === SparkSqlParser.KW_NAMESPACES || _la === SparkSqlParser.KW_SCHEMAS)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public describeFuncName(): DescribeFuncNameContext {
		let _localctx: DescribeFuncNameContext = new DescribeFuncNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 40, SparkSqlParser.RULE_describeFuncName);
		try {
			this.state = 1599;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 171, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1594;
				this.identifierReference();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1595;
				this.stringLit();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1596;
				this.comparisonOperator();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1597;
				this.arithmeticOperator();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1598;
				this.predicateOperator();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public describeColName(): DescribeColNameContext {
		let _localctx: DescribeColNameContext = new DescribeColNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 42, SparkSqlParser.RULE_describeColName);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1601;
			_localctx._identifier = this.identifier();
			_localctx._nameParts.push(_localctx._identifier);
			this.state = 1606;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.DOT) {
				{
				{
				this.state = 1602;
				this.match(SparkSqlParser.DOT);
				this.state = 1603;
				_localctx._identifier = this.identifier();
				_localctx._nameParts.push(_localctx._identifier);
				}
				}
				this.state = 1608;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ctes(): CtesContext {
		let _localctx: CtesContext = new CtesContext(this._ctx, this.state);
		this.enterRule(_localctx, 44, SparkSqlParser.RULE_ctes);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1609;
			this.match(SparkSqlParser.KW_WITH);
			this.state = 1610;
			this.namedQuery();
			this.state = 1615;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1611;
				this.match(SparkSqlParser.COMMA);
				this.state = 1612;
				this.namedQuery();
				}
				}
				this.state = 1617;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public namedQuery(): NamedQueryContext {
		let _localctx: NamedQueryContext = new NamedQueryContext(this._ctx, this.state);
		this.enterRule(_localctx, 46, SparkSqlParser.RULE_namedQuery);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1618;
			_localctx._name = this.errorCapturingIdentifier();
			this.state = 1620;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 174, this._ctx) ) {
			case 1:
				{
				this.state = 1619;
				_localctx._columnAliases = this.identifierList();
				}
				break;
			}
			this.state = 1623;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AS) {
				{
				this.state = 1622;
				this.match(SparkSqlParser.KW_AS);
				}
			}

			this.state = 1625;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1626;
			this.query();
			this.state = 1627;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public tableProvider(): TableProviderContext {
		let _localctx: TableProviderContext = new TableProviderContext(this._ctx, this.state);
		this.enterRule(_localctx, 48, SparkSqlParser.RULE_tableProvider);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1629;
			this.match(SparkSqlParser.KW_USING);
			this.state = 1630;
			this.multipartIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public createTableClauses(): CreateTableClausesContext {
		let _localctx: CreateTableClausesContext = new CreateTableClausesContext(this._ctx, this.state);
		this.enterRule(_localctx, 50, SparkSqlParser.RULE_createTableClauses);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1647;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 177, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					this.state = 1645;
					this._errHandler.sync(this);
					switch (this._input.LA(1)) {
					case SparkSqlParser.KW_OPTIONS:
						{
						{
						this.state = 1632;
						this.match(SparkSqlParser.KW_OPTIONS);
						this.state = 1633;
						_localctx._options = this.expressionPropertyList();
						}
						}
						break;
					case SparkSqlParser.KW_PARTITIONED:
						{
						{
						this.state = 1634;
						this.match(SparkSqlParser.KW_PARTITIONED);
						this.state = 1635;
						this.match(SparkSqlParser.KW_BY);
						this.state = 1636;
						_localctx._partitioning = this.partitionFieldList();
						}
						}
						break;
					case SparkSqlParser.KW_SKEWED:
						{
						this.state = 1637;
						this.skewSpec();
						}
						break;
					case SparkSqlParser.KW_CLUSTERED:
						{
						this.state = 1638;
						this.bucketSpec();
						}
						break;
					case SparkSqlParser.KW_ROW:
						{
						this.state = 1639;
						this.rowFormat();
						}
						break;
					case SparkSqlParser.KW_STORED:
						{
						this.state = 1640;
						this.createFileFormat();
						}
						break;
					case SparkSqlParser.KW_LOCATION:
						{
						this.state = 1641;
						this.locationSpec();
						}
						break;
					case SparkSqlParser.KW_COMMENT:
						{
						this.state = 1642;
						this.commentSpec();
						}
						break;
					case SparkSqlParser.KW_TBLPROPERTIES:
						{
						{
						this.state = 1643;
						this.match(SparkSqlParser.KW_TBLPROPERTIES);
						this.state = 1644;
						_localctx._tableProps = this.propertyList();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
				}
				this.state = 1649;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 177, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public propertyList(): PropertyListContext {
		let _localctx: PropertyListContext = new PropertyListContext(this._ctx, this.state);
		this.enterRule(_localctx, 52, SparkSqlParser.RULE_propertyList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1650;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1651;
			this.property();
			this.state = 1656;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1652;
				this.match(SparkSqlParser.COMMA);
				this.state = 1653;
				this.property();
				}
				}
				this.state = 1658;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1659;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public property(): PropertyContext {
		let _localctx: PropertyContext = new PropertyContext(this._ctx, this.state);
		this.enterRule(_localctx, 54, SparkSqlParser.RULE_property);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1661;
			_localctx._key = this.propertyKey();
			this.state = 1666;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_FALSE || _la === SparkSqlParser.KW_TRUE || ((((_la - 345)) & ~0x1F) === 0 && ((1 << (_la - 345)) & ((1 << (SparkSqlParser.EQ - 345)) | (1 << (SparkSqlParser.STRING_LITERAL - 345)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 345)) | (1 << (SparkSqlParser.INTEGER_VALUE - 345)))) !== 0) || _la === SparkSqlParser.DECIMAL_VALUE) {
				{
				this.state = 1663;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.EQ) {
					{
					this.state = 1662;
					this.match(SparkSqlParser.EQ);
					}
				}

				this.state = 1665;
				_localctx._value = this.propertyValue();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public propertyKey(): PropertyKeyContext {
		let _localctx: PropertyKeyContext = new PropertyKeyContext(this._ctx, this.state);
		this.enterRule(_localctx, 56, SparkSqlParser.RULE_propertyKey);
		let _la: number;
		try {
			this.state = 1677;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 182, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1668;
				this.identifier();
				this.state = 1673;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.DOT) {
					{
					{
					this.state = 1669;
					this.match(SparkSqlParser.DOT);
					this.state = 1670;
					this.identifier();
					}
					}
					this.state = 1675;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1676;
				this.stringLit();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public propertyValue(): PropertyValueContext {
		let _localctx: PropertyValueContext = new PropertyValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 58, SparkSqlParser.RULE_propertyValue);
		try {
			this.state = 1683;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.INTEGER_VALUE:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1679;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;
			case SparkSqlParser.DECIMAL_VALUE:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1680;
				this.match(SparkSqlParser.DECIMAL_VALUE);
				}
				break;
			case SparkSqlParser.KW_FALSE:
			case SparkSqlParser.KW_TRUE:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1681;
				this.booleanValue();
				}
				break;
			case SparkSqlParser.STRING_LITERAL:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1682;
				this.stringLit();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expressionPropertyList(): ExpressionPropertyListContext {
		let _localctx: ExpressionPropertyListContext = new ExpressionPropertyListContext(this._ctx, this.state);
		this.enterRule(_localctx, 60, SparkSqlParser.RULE_expressionPropertyList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1685;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1686;
			this.expressionProperty();
			this.state = 1691;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1687;
				this.match(SparkSqlParser.COMMA);
				this.state = 1688;
				this.expressionProperty();
				}
				}
				this.state = 1693;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1694;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expressionProperty(): ExpressionPropertyContext {
		let _localctx: ExpressionPropertyContext = new ExpressionPropertyContext(this._ctx, this.state);
		this.enterRule(_localctx, 62, SparkSqlParser.RULE_expressionProperty);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1696;
			_localctx._key = this.propertyKey();
			this.state = 1701;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)) | (1 << (SparkSqlParser.EQ - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
				{
				this.state = 1698;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.EQ) {
					{
					this.state = 1697;
					this.match(SparkSqlParser.EQ);
					}
				}

				this.state = 1700;
				_localctx._value = this.expression();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public constantList(): ConstantListContext {
		let _localctx: ConstantListContext = new ConstantListContext(this._ctx, this.state);
		this.enterRule(_localctx, 64, SparkSqlParser.RULE_constantList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1703;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1704;
			this.constant();
			this.state = 1709;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1705;
				this.match(SparkSqlParser.COMMA);
				this.state = 1706;
				this.constant();
				}
				}
				this.state = 1711;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1712;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public nestedConstantList(): NestedConstantListContext {
		let _localctx: NestedConstantListContext = new NestedConstantListContext(this._ctx, this.state);
		this.enterRule(_localctx, 66, SparkSqlParser.RULE_nestedConstantList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1714;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1715;
			this.constantList();
			this.state = 1720;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1716;
				this.match(SparkSqlParser.COMMA);
				this.state = 1717;
				this.constantList();
				}
				}
				this.state = 1722;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1723;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public createFileFormat(): CreateFileFormatContext {
		let _localctx: CreateFileFormatContext = new CreateFileFormatContext(this._ctx, this.state);
		this.enterRule(_localctx, 68, SparkSqlParser.RULE_createFileFormat);
		try {
			this.state = 1731;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 189, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1725;
				this.match(SparkSqlParser.KW_STORED);
				this.state = 1726;
				this.match(SparkSqlParser.KW_AS);
				this.state = 1727;
				this.fileFormat();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1728;
				this.match(SparkSqlParser.KW_STORED);
				this.state = 1729;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1730;
				this.storageHandler();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public fileFormat(): FileFormatContext {
		let _localctx: FileFormatContext = new FileFormatContext(this._ctx, this.state);
		this.enterRule(_localctx, 70, SparkSqlParser.RULE_fileFormat);
		try {
			this.state = 1739;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 190, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1733;
				this.match(SparkSqlParser.KW_INPUTFORMAT);
				this.state = 1734;
				_localctx._inFmt = this.stringLit();
				this.state = 1735;
				this.match(SparkSqlParser.KW_OUTPUTFORMAT);
				this.state = 1736;
				_localctx._outFmt = this.stringLit();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1738;
				this.identifier();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public storageHandler(): StorageHandlerContext {
		let _localctx: StorageHandlerContext = new StorageHandlerContext(this._ctx, this.state);
		this.enterRule(_localctx, 72, SparkSqlParser.RULE_storageHandler);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1741;
			this.stringLit();
			this.state = 1745;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 191, this._ctx) ) {
			case 1:
				{
				this.state = 1742;
				this.match(SparkSqlParser.KW_WITH);
				this.state = 1743;
				this.match(SparkSqlParser.KW_SERDEPROPERTIES);
				this.state = 1744;
				this.propertyList();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public resource(): ResourceContext {
		let _localctx: ResourceContext = new ResourceContext(this._ctx, this.state);
		this.enterRule(_localctx, 74, SparkSqlParser.RULE_resource);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1747;
			this.identifier();
			this.state = 1748;
			this.stringLit();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dmlStatementNoWith(): DmlStatementNoWithContext {
		let _localctx: DmlStatementNoWithContext = new DmlStatementNoWithContext(this._ctx, this.state);
		this.enterRule(_localctx, 76, SparkSqlParser.RULE_dmlStatementNoWith);
		let _la: number;
		try {
			let _alt: number;
			this.state = 1806;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_INSERT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1750;
				this.insertInto();
				this.state = 1751;
				this.query();
				}
				break;
			case SparkSqlParser.KW_FROM:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1753;
				this.fromClause();
				this.state = 1755;
				this._errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						this.state = 1754;
						this.multiInsertQueryBody();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					this.state = 1757;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 192, this._ctx);
				} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
				}
				break;
			case SparkSqlParser.KW_DELETE:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1759;
				this.match(SparkSqlParser.KW_DELETE);
				this.state = 1760;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 1761;
				this.tableName();
				this.state = 1762;
				this.tableAlias();
				this.state = 1764;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_WHERE) {
					{
					this.state = 1763;
					this.whereClause();
					}
				}

				}
				break;
			case SparkSqlParser.KW_UPDATE:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1766;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 1767;
				this.tableName();
				this.state = 1768;
				this.tableAlias();
				this.state = 1769;
				this.setClause();
				this.state = 1771;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_WHERE) {
					{
					this.state = 1770;
					this.whereClause();
					}
				}

				}
				break;
			case SparkSqlParser.KW_MERGE:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1773;
				this.match(SparkSqlParser.KW_MERGE);
				this.state = 1774;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1775;
				_localctx._target = this.tableName();
				this.state = 1776;
				_localctx._targetAlias = this.tableAlias();
				this.state = 1777;
				this.match(SparkSqlParser.KW_USING);
				this.state = 1783;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_ADD:
				case SparkSqlParser.KW_AFTER:
				case SparkSqlParser.KW_ALL:
				case SparkSqlParser.KW_ALTER:
				case SparkSqlParser.KW_ALWAYS:
				case SparkSqlParser.KW_ANALYZE:
				case SparkSqlParser.KW_AND:
				case SparkSqlParser.KW_ANTI:
				case SparkSqlParser.KW_ANY:
				case SparkSqlParser.KW_ANY_VALUE:
				case SparkSqlParser.KW_ARCHIVE:
				case SparkSqlParser.KW_ARRAY:
				case SparkSqlParser.KW_AS:
				case SparkSqlParser.KW_ASC:
				case SparkSqlParser.KW_AT:
				case SparkSqlParser.KW_AUTHORIZATION:
				case SparkSqlParser.KW_BETWEEN:
				case SparkSqlParser.KW_BIGINT:
				case SparkSqlParser.KW_BINARY:
				case SparkSqlParser.KW_BOOLEAN:
				case SparkSqlParser.KW_BOTH:
				case SparkSqlParser.KW_BUCKET:
				case SparkSqlParser.KW_BUCKETS:
				case SparkSqlParser.KW_BY:
				case SparkSqlParser.KW_BYTE:
				case SparkSqlParser.KW_CACHE:
				case SparkSqlParser.KW_CASCADE:
				case SparkSqlParser.KW_CASE:
				case SparkSqlParser.KW_CAST:
				case SparkSqlParser.KW_CATALOG:
				case SparkSqlParser.KW_CATALOGS:
				case SparkSqlParser.KW_CHANGE:
				case SparkSqlParser.KW_CHAR:
				case SparkSqlParser.KW_CHARACTER:
				case SparkSqlParser.KW_CHECK:
				case SparkSqlParser.KW_CLEAR:
				case SparkSqlParser.KW_CLUSTER:
				case SparkSqlParser.KW_CLUSTERED:
				case SparkSqlParser.KW_CODEGEN:
				case SparkSqlParser.KW_COLLATE:
				case SparkSqlParser.KW_COLLECTION:
				case SparkSqlParser.KW_COLUMN:
				case SparkSqlParser.KW_COLUMNS:
				case SparkSqlParser.KW_COMMENT:
				case SparkSqlParser.KW_COMMIT:
				case SparkSqlParser.KW_COMPACT:
				case SparkSqlParser.KW_COMPACTIONS:
				case SparkSqlParser.KW_COMPUTE:
				case SparkSqlParser.KW_CONCATENATE:
				case SparkSqlParser.KW_CONSTRAINT:
				case SparkSqlParser.KW_COST:
				case SparkSqlParser.KW_CREATE:
				case SparkSqlParser.KW_CROSS:
				case SparkSqlParser.KW_CUBE:
				case SparkSqlParser.KW_CURRENT:
				case SparkSqlParser.KW_CURRENT_DATE:
				case SparkSqlParser.KW_CURRENT_TIME:
				case SparkSqlParser.KW_CURRENT_TIMESTAMP:
				case SparkSqlParser.KW_CURRENT_USER:
				case SparkSqlParser.KW_DAY:
				case SparkSqlParser.KW_DAYS:
				case SparkSqlParser.KW_DAYOFYEAR:
				case SparkSqlParser.KW_DATA:
				case SparkSqlParser.KW_DATE:
				case SparkSqlParser.KW_DATABASE:
				case SparkSqlParser.KW_DATABASES:
				case SparkSqlParser.KW_DATEADD:
				case SparkSqlParser.KW_DATE_ADD:
				case SparkSqlParser.KW_DATEDIFF:
				case SparkSqlParser.KW_DATE_DIFF:
				case SparkSqlParser.KW_DBPROPERTIES:
				case SparkSqlParser.KW_DEC:
				case SparkSqlParser.KW_DECIMAL:
				case SparkSqlParser.KW_DECLARE:
				case SparkSqlParser.KW_DEFAULT:
				case SparkSqlParser.KW_DEFINED:
				case SparkSqlParser.KW_DELETE:
				case SparkSqlParser.KW_DELIMITED:
				case SparkSqlParser.KW_DESC:
				case SparkSqlParser.KW_DESCRIBE:
				case SparkSqlParser.KW_DFS:
				case SparkSqlParser.KW_DIRECTORIES:
				case SparkSqlParser.KW_DIRECTORY:
				case SparkSqlParser.KW_DISTINCT:
				case SparkSqlParser.KW_DISTRIBUTE:
				case SparkSqlParser.KW_DIV:
				case SparkSqlParser.KW_DOUBLE:
				case SparkSqlParser.KW_DROP:
				case SparkSqlParser.KW_ELSE:
				case SparkSqlParser.KW_END:
				case SparkSqlParser.KW_ESCAPE:
				case SparkSqlParser.KW_ESCAPED:
				case SparkSqlParser.KW_EXCEPT:
				case SparkSqlParser.KW_EXCHANGE:
				case SparkSqlParser.KW_EXCLUDE:
				case SparkSqlParser.KW_EXISTS:
				case SparkSqlParser.KW_EXPLAIN:
				case SparkSqlParser.KW_EXPORT:
				case SparkSqlParser.KW_EXTENDED:
				case SparkSqlParser.KW_EXTERNAL:
				case SparkSqlParser.KW_EXTRACT:
				case SparkSqlParser.KW_FALSE:
				case SparkSqlParser.KW_FETCH:
				case SparkSqlParser.KW_FIELDS:
				case SparkSqlParser.KW_FILTER:
				case SparkSqlParser.KW_FILEFORMAT:
				case SparkSqlParser.KW_FIRST:
				case SparkSqlParser.KW_FLOAT:
				case SparkSqlParser.KW_FOLLOWING:
				case SparkSqlParser.KW_FOR:
				case SparkSqlParser.KW_FOREIGN:
				case SparkSqlParser.KW_FORMAT:
				case SparkSqlParser.KW_FORMATTED:
				case SparkSqlParser.KW_FROM:
				case SparkSqlParser.KW_FULL:
				case SparkSqlParser.KW_FUNCTION:
				case SparkSqlParser.KW_FUNCTIONS:
				case SparkSqlParser.KW_GENERATED:
				case SparkSqlParser.KW_GLOBAL:
				case SparkSqlParser.KW_GRANT:
				case SparkSqlParser.KW_GROUP:
				case SparkSqlParser.KW_GROUPING:
				case SparkSqlParser.KW_HAVING:
				case SparkSqlParser.KW_BINARY_HEX:
				case SparkSqlParser.KW_HOUR:
				case SparkSqlParser.KW_HOURS:
				case SparkSqlParser.KW_IDENTIFIER:
				case SparkSqlParser.KW_IF:
				case SparkSqlParser.KW_IGNORE:
				case SparkSqlParser.KW_IMPORT:
				case SparkSqlParser.KW_IN:
				case SparkSqlParser.KW_INCLUDE:
				case SparkSqlParser.KW_INDEX:
				case SparkSqlParser.KW_INDEXES:
				case SparkSqlParser.KW_INNER:
				case SparkSqlParser.KW_INPATH:
				case SparkSqlParser.KW_INPUTFORMAT:
				case SparkSqlParser.KW_INSERT:
				case SparkSqlParser.KW_INTERSECT:
				case SparkSqlParser.KW_INTERVAL:
				case SparkSqlParser.KW_INT:
				case SparkSqlParser.KW_INTEGER:
				case SparkSqlParser.KW_INTO:
				case SparkSqlParser.KW_IS:
				case SparkSqlParser.KW_ITEMS:
				case SparkSqlParser.KW_JOIN:
				case SparkSqlParser.KW_KEYS:
				case SparkSqlParser.KW_LAST:
				case SparkSqlParser.KW_LATERAL:
				case SparkSqlParser.KW_LAZY:
				case SparkSqlParser.KW_LEADING:
				case SparkSqlParser.KW_LEFT:
				case SparkSqlParser.KW_LIKE:
				case SparkSqlParser.KW_ILIKE:
				case SparkSqlParser.KW_LIMIT:
				case SparkSqlParser.KW_LINES:
				case SparkSqlParser.KW_LIST:
				case SparkSqlParser.KW_LOAD:
				case SparkSqlParser.KW_LOCAL:
				case SparkSqlParser.KW_LOCATION:
				case SparkSqlParser.KW_LOCK:
				case SparkSqlParser.KW_LOCKS:
				case SparkSqlParser.KW_LOGICAL:
				case SparkSqlParser.KW_LONG:
				case SparkSqlParser.KW_MACRO:
				case SparkSqlParser.KW_MAP:
				case SparkSqlParser.KW_MATCHED:
				case SparkSqlParser.KW_MERGE:
				case SparkSqlParser.KW_MICROSECOND:
				case SparkSqlParser.KW_MICROSECONDS:
				case SparkSqlParser.KW_MILLISECOND:
				case SparkSqlParser.KW_MILLISECONDS:
				case SparkSqlParser.KW_MINUTE:
				case SparkSqlParser.KW_MINUTES:
				case SparkSqlParser.KW_MONTH:
				case SparkSqlParser.KW_MONTHS:
				case SparkSqlParser.KW_MSCK:
				case SparkSqlParser.KW_NAME:
				case SparkSqlParser.KW_NAMESPACE:
				case SparkSqlParser.KW_NAMESPACES:
				case SparkSqlParser.KW_NANOSECOND:
				case SparkSqlParser.KW_NANOSECONDS:
				case SparkSqlParser.KW_NATURAL:
				case SparkSqlParser.KW_NO:
				case SparkSqlParser.KW_NOT:
				case SparkSqlParser.KW_NULL:
				case SparkSqlParser.KW_NULLS:
				case SparkSqlParser.KW_NUMERIC:
				case SparkSqlParser.KW_OF:
				case SparkSqlParser.KW_OFFSET:
				case SparkSqlParser.KW_ON:
				case SparkSqlParser.KW_ONLY:
				case SparkSqlParser.KW_OPTION:
				case SparkSqlParser.KW_OPTIONS:
				case SparkSqlParser.KW_OR:
				case SparkSqlParser.KW_ORDER:
				case SparkSqlParser.KW_OUT:
				case SparkSqlParser.KW_OUTER:
				case SparkSqlParser.KW_OUTPUTFORMAT:
				case SparkSqlParser.KW_OVER:
				case SparkSqlParser.KW_OVERLAPS:
				case SparkSqlParser.KW_OVERLAY:
				case SparkSqlParser.KW_OVERWRITE:
				case SparkSqlParser.KW_PARTITION:
				case SparkSqlParser.KW_PARTITIONED:
				case SparkSqlParser.KW_PARTITIONS:
				case SparkSqlParser.KW_PERCENTILE_CONT:
				case SparkSqlParser.KW_PERCENTILE_DISC:
				case SparkSqlParser.KW_PERCENTLIT:
				case SparkSqlParser.KW_PIVOT:
				case SparkSqlParser.KW_PLACING:
				case SparkSqlParser.KW_POSITION:
				case SparkSqlParser.KW_PRECEDING:
				case SparkSqlParser.KW_PRIMARY:
				case SparkSqlParser.KW_PRINCIPALS:
				case SparkSqlParser.KW_PROPERTIES:
				case SparkSqlParser.KW_PURGE:
				case SparkSqlParser.KW_QUARTER:
				case SparkSqlParser.KW_QUERY:
				case SparkSqlParser.KW_RANGE:
				case SparkSqlParser.KW_REAL:
				case SparkSqlParser.KW_RECORDREADER:
				case SparkSqlParser.KW_RECORDWRITER:
				case SparkSqlParser.KW_RECOVER:
				case SparkSqlParser.KW_REDUCE:
				case SparkSqlParser.KW_REFERENCES:
				case SparkSqlParser.KW_REFRESH:
				case SparkSqlParser.KW_RENAME:
				case SparkSqlParser.KW_REPAIR:
				case SparkSqlParser.KW_REPEATABLE:
				case SparkSqlParser.KW_REPLACE:
				case SparkSqlParser.KW_RESET:
				case SparkSqlParser.KW_RESPECT:
				case SparkSqlParser.KW_RESTRICT:
				case SparkSqlParser.KW_REVOKE:
				case SparkSqlParser.KW_RIGHT:
				case SparkSqlParser.KW_RLIKE:
				case SparkSqlParser.KW_REGEXP:
				case SparkSqlParser.KW_ROLE:
				case SparkSqlParser.KW_ROLES:
				case SparkSqlParser.KW_ROLLBACK:
				case SparkSqlParser.KW_ROLLUP:
				case SparkSqlParser.KW_ROW:
				case SparkSqlParser.KW_ROWS:
				case SparkSqlParser.KW_SECOND:
				case SparkSqlParser.KW_SECONDS:
				case SparkSqlParser.KW_SCHEMA:
				case SparkSqlParser.KW_SCHEMAS:
				case SparkSqlParser.KW_SELECT:
				case SparkSqlParser.KW_SEMI:
				case SparkSqlParser.KW_SEPARATED:
				case SparkSqlParser.KW_SERDE:
				case SparkSqlParser.KW_SERDEPROPERTIES:
				case SparkSqlParser.KW_SESSION_USER:
				case SparkSqlParser.KW_SET:
				case SparkSqlParser.KW_MINUS:
				case SparkSqlParser.KW_SETS:
				case SparkSqlParser.KW_SHORT:
				case SparkSqlParser.KW_SHOW:
				case SparkSqlParser.KW_SINGLE:
				case SparkSqlParser.KW_SKEWED:
				case SparkSqlParser.KW_SMALLINT:
				case SparkSqlParser.KW_SOME:
				case SparkSqlParser.KW_SORT:
				case SparkSqlParser.KW_SORTED:
				case SparkSqlParser.KW_SOURCE:
				case SparkSqlParser.KW_START:
				case SparkSqlParser.KW_STATISTICS:
				case SparkSqlParser.KW_STORED:
				case SparkSqlParser.KW_STRATIFY:
				case SparkSqlParser.KW_STRING:
				case SparkSqlParser.KW_STRUCT:
				case SparkSqlParser.KW_SUBSTR:
				case SparkSqlParser.KW_SUBSTRING:
				case SparkSqlParser.KW_SYNC:
				case SparkSqlParser.KW_SYSTEM:
				case SparkSqlParser.KW_SYSTEM_TIME:
				case SparkSqlParser.KW_SYSTEM_VERSION:
				case SparkSqlParser.KW_TABLE:
				case SparkSqlParser.KW_TABLES:
				case SparkSqlParser.KW_TABLESAMPLE:
				case SparkSqlParser.KW_TARGET:
				case SparkSqlParser.KW_TBLPROPERTIES:
				case SparkSqlParser.KW_TEMPORARY:
				case SparkSqlParser.KW_TERMINATED:
				case SparkSqlParser.KW_THEN:
				case SparkSqlParser.KW_TIME:
				case SparkSqlParser.KW_TIMEDIFF:
				case SparkSqlParser.KW_TIMESTAMP:
				case SparkSqlParser.KW_TIMESTAMP_LTZ:
				case SparkSqlParser.KW_TIMESTAMP_NTZ:
				case SparkSqlParser.KW_TIMESTAMPADD:
				case SparkSqlParser.KW_TIMESTAMPDIFF:
				case SparkSqlParser.KW_TINYINT:
				case SparkSqlParser.KW_TO:
				case SparkSqlParser.KW_TOUCH:
				case SparkSqlParser.KW_TRAILING:
				case SparkSqlParser.KW_TRANSACTION:
				case SparkSqlParser.KW_TRANSACTIONS:
				case SparkSqlParser.KW_TRANSFORM:
				case SparkSqlParser.KW_TRIM:
				case SparkSqlParser.KW_TRUE:
				case SparkSqlParser.KW_TRUNCATE:
				case SparkSqlParser.KW_TRY_CAST:
				case SparkSqlParser.KW_TYPE:
				case SparkSqlParser.KW_UNARCHIVE:
				case SparkSqlParser.KW_UNBOUNDED:
				case SparkSqlParser.KW_UNCACHE:
				case SparkSqlParser.KW_UNION:
				case SparkSqlParser.KW_UNIQUE:
				case SparkSqlParser.KW_UNKNOWN:
				case SparkSqlParser.KW_UNLOCK:
				case SparkSqlParser.KW_UNPIVOT:
				case SparkSqlParser.KW_UNSET:
				case SparkSqlParser.KW_UPDATE:
				case SparkSqlParser.KW_USE:
				case SparkSqlParser.KW_USER:
				case SparkSqlParser.KW_USING:
				case SparkSqlParser.KW_VALUES:
				case SparkSqlParser.KW_VARCHAR:
				case SparkSqlParser.KW_VAR:
				case SparkSqlParser.KW_VARIABLE:
				case SparkSqlParser.KW_VERSION:
				case SparkSqlParser.KW_VIEW:
				case SparkSqlParser.KW_VIEWS:
				case SparkSqlParser.KW_VOID:
				case SparkSqlParser.KW_WEEK:
				case SparkSqlParser.KW_WEEKS:
				case SparkSqlParser.KW_WHEN:
				case SparkSqlParser.KW_WHERE:
				case SparkSqlParser.KW_WINDOW:
				case SparkSqlParser.KW_WITH:
				case SparkSqlParser.KW_WITHIN:
				case SparkSqlParser.KW_YEAR:
				case SparkSqlParser.KW_YEARS:
				case SparkSqlParser.KW_ZONE:
				case SparkSqlParser.DOUBLEQUOTED_STRING:
				case SparkSqlParser.IDENTIFIER:
				case SparkSqlParser.BACKQUOTED_IDENTIFIER:
					{
					this.state = 1778;
					_localctx._source = this.identifierReference();
					}
					break;
				case SparkSqlParser.LEFT_PAREN:
					{
					this.state = 1779;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 1780;
					_localctx._sourceQuery = this.query();
					this.state = 1781;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 1785;
				_localctx._sourceAlias = this.tableAlias();
				this.state = 1786;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1787;
				_localctx._mergeCondition = this.booleanExpression(0);
				this.state = 1791;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1788;
						this.matchedClause();
						}
						}
					}
					this.state = 1793;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx);
				}
				this.state = 1797;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 197, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1794;
						this.notMatchedClause();
						}
						}
					}
					this.state = 1799;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 197, this._ctx);
				}
				this.state = 1803;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.KW_WHEN) {
					{
					{
					this.state = 1800;
					this.notMatchedBySourceClause();
					}
					}
					this.state = 1805;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dbSchemaName(): DbSchemaNameContext {
		let _localctx: DbSchemaNameContext = new DbSchemaNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 78, SparkSqlParser.RULE_dbSchemaName);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1808;
			this.identifierReference();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dbSchemaNameCreate(): DbSchemaNameCreateContext {
		let _localctx: DbSchemaNameCreateContext = new DbSchemaNameCreateContext(this._ctx, this.state);
		this.enterRule(_localctx, 80, SparkSqlParser.RULE_dbSchemaNameCreate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1810;
			this.identifierReference();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public tableNameCreate(): TableNameCreateContext {
		let _localctx: TableNameCreateContext = new TableNameCreateContext(this._ctx, this.state);
		this.enterRule(_localctx, 82, SparkSqlParser.RULE_tableNameCreate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1812;
			this.tableIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public tableName(): TableNameContext {
		let _localctx: TableNameContext = new TableNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 84, SparkSqlParser.RULE_tableName);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1814;
			this.tableIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public viewNameCreate(): ViewNameCreateContext {
		let _localctx: ViewNameCreateContext = new ViewNameCreateContext(this._ctx, this.state);
		this.enterRule(_localctx, 86, SparkSqlParser.RULE_viewNameCreate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1816;
			this.viewIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public viewName(): ViewNameContext {
		let _localctx: ViewNameContext = new ViewNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 88, SparkSqlParser.RULE_viewName);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1818;
			this.viewIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public columnName(): ColumnNameContext {
		let _localctx: ColumnNameContext = new ColumnNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 90, SparkSqlParser.RULE_columnName);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1820;
			this.multipartIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public columnNameSeq(): ColumnNameSeqContext {
		let _localctx: ColumnNameSeqContext = new ColumnNameSeqContext(this._ctx, this.state);
		this.enterRule(_localctx, 92, SparkSqlParser.RULE_columnNameSeq);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1822;
			this.columnName();
			this.state = 1827;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1823;
				this.match(SparkSqlParser.COMMA);
				this.state = 1824;
				this.columnName();
				}
				}
				this.state = 1829;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public columnNameCreate(): ColumnNameCreateContext {
		let _localctx: ColumnNameCreateContext = new ColumnNameCreateContext(this._ctx, this.state);
		this.enterRule(_localctx, 94, SparkSqlParser.RULE_columnNameCreate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1830;
			this.errorCapturingIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public identifierReference(): IdentifierReferenceContext {
		let _localctx: IdentifierReferenceContext = new IdentifierReferenceContext(this._ctx, this.state);
		this.enterRule(_localctx, 96, SparkSqlParser.RULE_identifierReference);
		try {
			this.state = 1838;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 201, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1832;
				this.match(SparkSqlParser.KW_IDENTIFIER);
				this.state = 1833;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1834;
				this.expression();
				this.state = 1835;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1837;
				this.multipartIdentifier();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public queryOrganization(): QueryOrganizationContext {
		let _localctx: QueryOrganizationContext = new QueryOrganizationContext(this._ctx, this.state);
		this.enterRule(_localctx, 98, SparkSqlParser.RULE_queryOrganization);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1850;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 203, this._ctx) ) {
			case 1:
				{
				this.state = 1840;
				this.match(SparkSqlParser.KW_ORDER);
				this.state = 1841;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1842;
				_localctx._sortItem = this.sortItem();
				_localctx._order.push(_localctx._sortItem);
				this.state = 1847;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 202, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1843;
						this.match(SparkSqlParser.COMMA);
						this.state = 1844;
						_localctx._sortItem = this.sortItem();
						_localctx._order.push(_localctx._sortItem);
						}
						}
					}
					this.state = 1849;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 202, this._ctx);
				}
				}
				break;
			}
			this.state = 1862;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 205, this._ctx) ) {
			case 1:
				{
				this.state = 1852;
				this.match(SparkSqlParser.KW_CLUSTER);
				this.state = 1853;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1854;
				_localctx._expression = this.expression();
				_localctx._clusterBy.push(_localctx._expression);
				this.state = 1859;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 204, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1855;
						this.match(SparkSqlParser.COMMA);
						this.state = 1856;
						_localctx._expression = this.expression();
						_localctx._clusterBy.push(_localctx._expression);
						}
						}
					}
					this.state = 1861;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 204, this._ctx);
				}
				}
				break;
			}
			this.state = 1874;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 207, this._ctx) ) {
			case 1:
				{
				this.state = 1864;
				this.match(SparkSqlParser.KW_DISTRIBUTE);
				this.state = 1865;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1866;
				_localctx._expression = this.expression();
				_localctx._distributeBy.push(_localctx._expression);
				this.state = 1871;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 206, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1867;
						this.match(SparkSqlParser.COMMA);
						this.state = 1868;
						_localctx._expression = this.expression();
						_localctx._distributeBy.push(_localctx._expression);
						}
						}
					}
					this.state = 1873;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 206, this._ctx);
				}
				}
				break;
			}
			this.state = 1886;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 209, this._ctx) ) {
			case 1:
				{
				this.state = 1876;
				this.match(SparkSqlParser.KW_SORT);
				this.state = 1877;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1878;
				_localctx._sortItem = this.sortItem();
				_localctx._sort.push(_localctx._sortItem);
				this.state = 1883;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 208, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1879;
						this.match(SparkSqlParser.COMMA);
						this.state = 1880;
						_localctx._sortItem = this.sortItem();
						_localctx._sort.push(_localctx._sortItem);
						}
						}
					}
					this.state = 1885;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 208, this._ctx);
				}
				}
				break;
			}
			this.state = 1889;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 210, this._ctx) ) {
			case 1:
				{
				this.state = 1888;
				this.windowClause();
				}
				break;
			}
			this.state = 1896;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 212, this._ctx) ) {
			case 1:
				{
				this.state = 1891;
				this.match(SparkSqlParser.KW_LIMIT);
				this.state = 1894;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 211, this._ctx) ) {
				case 1:
					{
					this.state = 1892;
					this.match(SparkSqlParser.KW_ALL);
					}
					break;

				case 2:
					{
					this.state = 1893;
					_localctx._limit = this.expression();
					}
					break;
				}
				}
				break;
			}
			this.state = 1900;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 213, this._ctx) ) {
			case 1:
				{
				this.state = 1898;
				this.match(SparkSqlParser.KW_OFFSET);
				this.state = 1899;
				_localctx._offset = this.expression();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public multiInsertQueryBody(): MultiInsertQueryBodyContext {
		let _localctx: MultiInsertQueryBodyContext = new MultiInsertQueryBodyContext(this._ctx, this.state);
		this.enterRule(_localctx, 100, SparkSqlParser.RULE_multiInsertQueryBody);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1902;
			this.insertInto();
			this.state = 1903;
			this.fromStatementBody();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public queryTerm(): QueryTermContext;
	public queryTerm(_p: number): QueryTermContext;
	// @RuleVersion(0)
	public queryTerm(_p?: number): QueryTermContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: QueryTermContext = new QueryTermContext(this._ctx, _parentState);
		let _prevctx: QueryTermContext = _localctx;
		let _startState: number = 102;
		this.enterRecursionRule(_localctx, 102, SparkSqlParser.RULE_queryTerm, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			{
			this.state = 1906;
			this.queryPrimary();
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 1928;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 218, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 1926;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 217, this._ctx) ) {
					case 1:
						{
						_localctx = new QueryTermContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
						this.state = 1908;
						if (!(this.precpred(this._ctx, 3))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
						}
						this.state = 1909;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_INTERSECT || _la === SparkSqlParser.KW_MINUS || _la === SparkSqlParser.KW_UNION)) {
							_localctx._operator = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 1911;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
							{
							this.state = 1910;
							this.setQuantifier();
							}
						}

						this.state = 1913;
						_localctx._right = this.queryTerm(4);
						}
						break;

					case 2:
						{
						_localctx = new QueryTermContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
						this.state = 1914;
						if (!(this.precpred(this._ctx, 2))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
						}
						this.state = 1915;
						_localctx._operator = this.match(SparkSqlParser.KW_INTERSECT);
						this.state = 1917;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
							{
							this.state = 1916;
							this.setQuantifier();
							}
						}

						this.state = 1919;
						_localctx._right = this.queryTerm(3);
						}
						break;

					case 3:
						{
						_localctx = new QueryTermContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
						this.state = 1920;
						if (!(this.precpred(this._ctx, 1))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
						}
						this.state = 1921;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_MINUS || _la === SparkSqlParser.KW_UNION)) {
							_localctx._operator = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 1923;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
							{
							this.state = 1922;
							this.setQuantifier();
							}
						}

						this.state = 1925;
						_localctx._right = this.queryTerm(2);
						}
						break;
					}
					}
				}
				this.state = 1930;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 218, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public queryPrimary(): QueryPrimaryContext {
		let _localctx: QueryPrimaryContext = new QueryPrimaryContext(this._ctx, this.state);
		this.enterRule(_localctx, 104, SparkSqlParser.RULE_queryPrimary);
		try {
			this.state = 1940;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_MAP:
			case SparkSqlParser.KW_REDUCE:
			case SparkSqlParser.KW_SELECT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1931;
				this.querySpecification();
				}
				break;
			case SparkSqlParser.KW_FROM:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1932;
				this.fromStatement();
				}
				break;
			case SparkSqlParser.KW_TABLE:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1933;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1934;
				this.tableName();
				}
				break;
			case SparkSqlParser.KW_VALUES:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1935;
				this.inlineTable();
				}
				break;
			case SparkSqlParser.LEFT_PAREN:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1936;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1937;
				this.query();
				this.state = 1938;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public sortItem(): SortItemContext {
		let _localctx: SortItemContext = new SortItemContext(this._ctx, this.state);
		this.enterRule(_localctx, 106, SparkSqlParser.RULE_sortItem);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1944;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 220, this._ctx) ) {
			case 1:
				{
				this.state = 1942;
				this.columnName();
				}
				break;

			case 2:
				{
				this.state = 1943;
				this.expression();
				}
				break;
			}
			this.state = 1947;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 221, this._ctx) ) {
			case 1:
				{
				this.state = 1946;
				_localctx._ordering = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC)) {
					_localctx._ordering = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;
			}
			this.state = 1951;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 222, this._ctx) ) {
			case 1:
				{
				this.state = 1949;
				this.match(SparkSqlParser.KW_NULLS);
				this.state = 1950;
				_localctx._nullOrder = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_FIRST || _la === SparkSqlParser.KW_LAST)) {
					_localctx._nullOrder = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public fromStatement(): FromStatementContext {
		let _localctx: FromStatementContext = new FromStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 108, SparkSqlParser.RULE_fromStatement);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1953;
			this.fromClause();
			this.state = 1955;
			this._errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					this.state = 1954;
					this.fromStatementBody();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 1957;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 223, this._ctx);
			} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public fromStatementBody(): FromStatementBodyContext {
		let _localctx: FromStatementBodyContext = new FromStatementBodyContext(this._ctx, this.state);
		this.enterRule(_localctx, 110, SparkSqlParser.RULE_fromStatementBody);
		try {
			let _alt: number;
			this.state = 1986;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 230, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1959;
				this.transformClause();
				this.state = 1961;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 224, this._ctx) ) {
				case 1:
					{
					this.state = 1960;
					this.whereClause();
					}
					break;
				}
				this.state = 1963;
				this.queryOrganization();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1965;
				this.selectClause();
				this.state = 1969;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 225, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1966;
						this.lateralView();
						}
						}
					}
					this.state = 1971;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 225, this._ctx);
				}
				this.state = 1973;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 226, this._ctx) ) {
				case 1:
					{
					this.state = 1972;
					this.whereClause();
					}
					break;
				}
				this.state = 1976;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 227, this._ctx) ) {
				case 1:
					{
					this.state = 1975;
					this.aggregationClause();
					}
					break;
				}
				this.state = 1979;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 228, this._ctx) ) {
				case 1:
					{
					this.state = 1978;
					this.havingClause();
					}
					break;
				}
				this.state = 1982;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 229, this._ctx) ) {
				case 1:
					{
					this.state = 1981;
					this.windowClause();
					}
					break;
				}
				this.state = 1984;
				this.queryOrganization();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public querySpecification(): QuerySpecificationContext {
		let _localctx: QuerySpecificationContext = new QuerySpecificationContext(this._ctx, this.state);
		this.enterRule(_localctx, 112, SparkSqlParser.RULE_querySpecification);
		try {
			let _alt: number;
			this.state = 2032;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 243, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1988;
				this.transformClause();
				this.state = 1990;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 231, this._ctx) ) {
				case 1:
					{
					this.state = 1989;
					this.fromClause();
					}
					break;
				}
				this.state = 1995;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 232, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1992;
						this.lateralView();
						}
						}
					}
					this.state = 1997;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 232, this._ctx);
				}
				this.state = 1999;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 233, this._ctx) ) {
				case 1:
					{
					this.state = 1998;
					this.whereClause();
					}
					break;
				}
				this.state = 2002;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 234, this._ctx) ) {
				case 1:
					{
					this.state = 2001;
					this.aggregationClause();
					}
					break;
				}
				this.state = 2005;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 235, this._ctx) ) {
				case 1:
					{
					this.state = 2004;
					this.havingClause();
					}
					break;
				}
				this.state = 2008;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 236, this._ctx) ) {
				case 1:
					{
					this.state = 2007;
					this.windowClause();
					}
					break;
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2010;
				this.selectClause();
				this.state = 2012;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 237, this._ctx) ) {
				case 1:
					{
					this.state = 2011;
					this.fromClause();
					}
					break;
				}
				this.state = 2017;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 238, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2014;
						this.lateralView();
						}
						}
					}
					this.state = 2019;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 238, this._ctx);
				}
				this.state = 2021;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 239, this._ctx) ) {
				case 1:
					{
					this.state = 2020;
					this.whereClause();
					}
					break;
				}
				this.state = 2024;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 240, this._ctx) ) {
				case 1:
					{
					this.state = 2023;
					this.aggregationClause();
					}
					break;
				}
				this.state = 2027;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 241, this._ctx) ) {
				case 1:
					{
					this.state = 2026;
					this.havingClause();
					}
					break;
				}
				this.state = 2030;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 242, this._ctx) ) {
				case 1:
					{
					this.state = 2029;
					this.windowClause();
					}
					break;
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public transformClause(): TransformClauseContext {
		let _localctx: TransformClauseContext = new TransformClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 114, SparkSqlParser.RULE_transformClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2053;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_SELECT:
				{
				this.state = 2034;
				this.match(SparkSqlParser.KW_SELECT);
				this.state = 2035;
				_localctx._kind = this.match(SparkSqlParser.KW_TRANSFORM);
				this.state = 2036;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2038;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 244, this._ctx) ) {
				case 1:
					{
					this.state = 2037;
					this.setQuantifier();
					}
					break;
				}
				this.state = 2040;
				this.expressionSeq();
				this.state = 2041;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			case SparkSqlParser.KW_MAP:
				{
				this.state = 2043;
				_localctx._kind = this.match(SparkSqlParser.KW_MAP);
				this.state = 2045;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 245, this._ctx) ) {
				case 1:
					{
					this.state = 2044;
					this.setQuantifier();
					}
					break;
				}
				this.state = 2047;
				this.expressionSeq();
				}
				break;
			case SparkSqlParser.KW_REDUCE:
				{
				this.state = 2048;
				_localctx._kind = this.match(SparkSqlParser.KW_REDUCE);
				this.state = 2050;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 246, this._ctx) ) {
				case 1:
					{
					this.state = 2049;
					this.setQuantifier();
					}
					break;
				}
				this.state = 2052;
				this.expressionSeq();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			this.state = 2056;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_ROW) {
				{
				this.state = 2055;
				_localctx._inRowFormat = this.rowFormat();
				}
			}

			this.state = 2060;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_RECORDWRITER) {
				{
				this.state = 2058;
				this.match(SparkSqlParser.KW_RECORDWRITER);
				this.state = 2059;
				_localctx._recordWriter = this.stringLit();
				}
			}

			this.state = 2062;
			this.match(SparkSqlParser.KW_USING);
			this.state = 2063;
			_localctx._script = this.stringLit();
			this.state = 2076;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 252, this._ctx) ) {
			case 1:
				{
				this.state = 2064;
				this.match(SparkSqlParser.KW_AS);
				this.state = 2074;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 251, this._ctx) ) {
				case 1:
					{
					this.state = 2065;
					this.identifierSeq();
					}
					break;

				case 2:
					{
					this.state = 2066;
					this.colTypeList();
					}
					break;

				case 3:
					{
					{
					this.state = 2067;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2070;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 250, this._ctx) ) {
					case 1:
						{
						this.state = 2068;
						this.identifierSeq();
						}
						break;

					case 2:
						{
						this.state = 2069;
						this.colTypeList();
						}
						break;
					}
					this.state = 2072;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					break;
				}
				}
				break;
			}
			this.state = 2079;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 253, this._ctx) ) {
			case 1:
				{
				this.state = 2078;
				_localctx._outRowFormat = this.rowFormat();
				}
				break;
			}
			this.state = 2083;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 254, this._ctx) ) {
			case 1:
				{
				this.state = 2081;
				this.match(SparkSqlParser.KW_RECORDREADER);
				this.state = 2082;
				_localctx._recordReader = this.stringLit();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public selectClause(): SelectClauseContext {
		let _localctx: SelectClauseContext = new SelectClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 116, SparkSqlParser.RULE_selectClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2085;
			this.match(SparkSqlParser.KW_SELECT);
			this.state = 2089;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.HENT_START) {
				{
				{
				this.state = 2086;
				_localctx._hint = this.hint();
				_localctx._hints.push(_localctx._hint);
				}
				}
				this.state = 2091;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2093;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 256, this._ctx) ) {
			case 1:
				{
				this.state = 2092;
				this.setQuantifier();
				}
				break;
			}
			this.state = 2095;
			this.namedExpressionSeq();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setClause(): SetClauseContext {
		let _localctx: SetClauseContext = new SetClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 118, SparkSqlParser.RULE_setClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2097;
			this.match(SparkSqlParser.KW_SET);
			this.state = 2098;
			this.assignmentList();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public matchedClause(): MatchedClauseContext {
		let _localctx: MatchedClauseContext = new MatchedClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 120, SparkSqlParser.RULE_matchedClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2100;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 2101;
			this.match(SparkSqlParser.KW_MATCHED);
			this.state = 2104;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AND) {
				{
				this.state = 2102;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2103;
				_localctx._matchedCond = this.booleanExpression(0);
				}
			}

			this.state = 2106;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 2107;
			this.matchedAction();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public notMatchedClause(): NotMatchedClauseContext {
		let _localctx: NotMatchedClauseContext = new NotMatchedClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 122, SparkSqlParser.RULE_notMatchedClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2109;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 2110;
			this.match(SparkSqlParser.KW_NOT);
			this.state = 2111;
			this.match(SparkSqlParser.KW_MATCHED);
			this.state = 2114;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_BY) {
				{
				this.state = 2112;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2113;
				this.match(SparkSqlParser.KW_TARGET);
				}
			}

			this.state = 2118;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AND) {
				{
				this.state = 2116;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2117;
				_localctx._notMatchedCond = this.booleanExpression(0);
				}
			}

			this.state = 2120;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 2121;
			this.notMatchedAction();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public notMatchedBySourceClause(): NotMatchedBySourceClauseContext {
		let _localctx: NotMatchedBySourceClauseContext = new NotMatchedBySourceClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 124, SparkSqlParser.RULE_notMatchedBySourceClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2123;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 2124;
			this.match(SparkSqlParser.KW_NOT);
			this.state = 2125;
			this.match(SparkSqlParser.KW_MATCHED);
			this.state = 2126;
			this.match(SparkSqlParser.KW_BY);
			this.state = 2127;
			this.match(SparkSqlParser.KW_SOURCE);
			this.state = 2130;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AND) {
				{
				this.state = 2128;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2129;
				_localctx._notMatchedBySourceCond = this.booleanExpression(0);
				}
			}

			this.state = 2132;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 2133;
			this.notMatchedBySourceAction();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public matchedAction(): MatchedActionContext {
		let _localctx: MatchedActionContext = new MatchedActionContext(this._ctx, this.state);
		this.enterRule(_localctx, 126, SparkSqlParser.RULE_matchedAction);
		try {
			this.state = 2142;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 261, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2135;
				this.match(SparkSqlParser.KW_DELETE);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2136;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 2137;
				this.match(SparkSqlParser.KW_SET);
				this.state = 2138;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2139;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 2140;
				this.match(SparkSqlParser.KW_SET);
				this.state = 2141;
				this.assignmentList();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public notMatchedAction(): NotMatchedActionContext {
		let _localctx: NotMatchedActionContext = new NotMatchedActionContext(this._ctx, this.state);
		this.enterRule(_localctx, 128, SparkSqlParser.RULE_notMatchedAction);
		let _la: number;
		try {
			this.state = 2162;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 263, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2144;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 2145;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2146;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 2147;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2148;
				this.multipartIdentifierList();
				this.state = 2149;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2150;
				this.match(SparkSqlParser.KW_VALUES);
				this.state = 2151;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2152;
				this.expression();
				this.state = 2157;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2153;
					this.match(SparkSqlParser.COMMA);
					this.state = 2154;
					this.expression();
					}
					}
					this.state = 2159;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2160;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public notMatchedBySourceAction(): NotMatchedBySourceActionContext {
		let _localctx: NotMatchedBySourceActionContext = new NotMatchedBySourceActionContext(this._ctx, this.state);
		this.enterRule(_localctx, 130, SparkSqlParser.RULE_notMatchedBySourceAction);
		try {
			this.state = 2168;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_DELETE:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2164;
				this.match(SparkSqlParser.KW_DELETE);
				}
				break;
			case SparkSqlParser.KW_UPDATE:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2165;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 2166;
				this.match(SparkSqlParser.KW_SET);
				this.state = 2167;
				this.assignmentList();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public assignmentList(): AssignmentListContext {
		let _localctx: AssignmentListContext = new AssignmentListContext(this._ctx, this.state);
		this.enterRule(_localctx, 132, SparkSqlParser.RULE_assignmentList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2170;
			this.assignment();
			this.state = 2175;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2171;
				this.match(SparkSqlParser.COMMA);
				this.state = 2172;
				this.assignment();
				}
				}
				this.state = 2177;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public assignment(): AssignmentContext {
		let _localctx: AssignmentContext = new AssignmentContext(this._ctx, this.state);
		this.enterRule(_localctx, 134, SparkSqlParser.RULE_assignment);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2178;
			_localctx._key = this.multipartIdentifier();
			this.state = 2179;
			this.match(SparkSqlParser.EQ);
			this.state = 2180;
			_localctx._value = this.expression();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public whereClause(): WhereClauseContext {
		let _localctx: WhereClauseContext = new WhereClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 136, SparkSqlParser.RULE_whereClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2182;
			this.match(SparkSqlParser.KW_WHERE);
			this.state = 2183;
			this.booleanExpression(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public havingClause(): HavingClauseContext {
		let _localctx: HavingClauseContext = new HavingClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 138, SparkSqlParser.RULE_havingClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2185;
			this.match(SparkSqlParser.KW_HAVING);
			this.state = 2186;
			this.booleanExpression(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public hint(): HintContext {
		let _localctx: HintContext = new HintContext(this._ctx, this.state);
		this.enterRule(_localctx, 140, SparkSqlParser.RULE_hint);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2188;
			this.match(SparkSqlParser.HENT_START);
			this.state = 2189;
			_localctx._hintStatement = this.hintStatement();
			_localctx._hintStatements.push(_localctx._hintStatement);
			this.state = 2196;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.COMMA) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 371)) & ~0x1F) === 0 && ((1 << (_la - 371)) & ((1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 371)) | (1 << (SparkSqlParser.IDENTIFIER - 371)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 371)))) !== 0)) {
				{
				{
				this.state = 2191;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.COMMA) {
					{
					this.state = 2190;
					this.match(SparkSqlParser.COMMA);
					}
				}

				this.state = 2193;
				_localctx._hintStatement = this.hintStatement();
				_localctx._hintStatements.push(_localctx._hintStatement);
				}
				}
				this.state = 2198;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2199;
			this.match(SparkSqlParser.HENT_END);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public hintStatement(): HintStatementContext {
		let _localctx: HintStatementContext = new HintStatementContext(this._ctx, this.state);
		this.enterRule(_localctx, 142, SparkSqlParser.RULE_hintStatement);
		let _la: number;
		try {
			this.state = 2214;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 269, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2201;
				_localctx._hintName = this.identifier();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2202;
				_localctx._hintName = this.identifier();
				this.state = 2203;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2204;
				_localctx._primaryExpression = this.primaryExpression(0);
				_localctx._parameters.push(_localctx._primaryExpression);
				this.state = 2209;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2205;
					this.match(SparkSqlParser.COMMA);
					this.state = 2206;
					_localctx._primaryExpression = this.primaryExpression(0);
					_localctx._parameters.push(_localctx._primaryExpression);
					}
					}
					this.state = 2211;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2212;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public fromClause(): FromClauseContext {
		let _localctx: FromClauseContext = new FromClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 144, SparkSqlParser.RULE_fromClause);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2216;
			this.match(SparkSqlParser.KW_FROM);
			this.state = 2217;
			this.relation();
			this.state = 2222;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 270, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2218;
					this.match(SparkSqlParser.COMMA);
					this.state = 2219;
					this.relation();
					}
					}
				}
				this.state = 2224;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 270, this._ctx);
			}
			this.state = 2228;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 271, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2225;
					this.lateralView();
					}
					}
				}
				this.state = 2230;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 271, this._ctx);
			}
			this.state = 2232;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 272, this._ctx) ) {
			case 1:
				{
				this.state = 2231;
				this.pivotClause();
				}
				break;
			}
			this.state = 2235;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 273, this._ctx) ) {
			case 1:
				{
				this.state = 2234;
				this.unpivotClause();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionKind(): FunctionKindContext {
		let _localctx: FunctionKindContext = new FunctionKindContext(this._ctx, this.state);
		this.enterRule(_localctx, 146, SparkSqlParser.RULE_functionKind);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2237;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_SYSTEM || _la === SparkSqlParser.KW_USER)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public temporalClause(): TemporalClauseContext {
		let _localctx: TemporalClauseContext = new TemporalClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 148, SparkSqlParser.RULE_temporalClause);
		let _la: number;
		try {
			this.state = 2253;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 276, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2240;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FOR) {
					{
					this.state = 2239;
					this.match(SparkSqlParser.KW_FOR);
					}
				}

				this.state = 2242;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_SYSTEM_VERSION || _la === SparkSqlParser.KW_VERSION)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2243;
				this.match(SparkSqlParser.KW_AS);
				this.state = 2244;
				this.match(SparkSqlParser.KW_OF);
				this.state = 2245;
				this.version();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2247;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FOR) {
					{
					this.state = 2246;
					this.match(SparkSqlParser.KW_FOR);
					}
				}

				this.state = 2249;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_SYSTEM_TIME || _la === SparkSqlParser.KW_TIMESTAMP)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2250;
				this.match(SparkSqlParser.KW_AS);
				this.state = 2251;
				this.match(SparkSqlParser.KW_OF);
				this.state = 2252;
				_localctx._timestamp = this.valueExpression(0);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public aggregationClause(): AggregationClauseContext {
		let _localctx: AggregationClauseContext = new AggregationClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 150, SparkSqlParser.RULE_aggregationClause);
		let _la: number;
		try {
			let _alt: number;
			this.state = 2294;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 281, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2255;
				this.match(SparkSqlParser.KW_GROUP);
				this.state = 2256;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2257;
				_localctx._groupByClause = this.groupByClause();
				_localctx._groupingExpressionsWithGroupingAnalytics.push(_localctx._groupByClause);
				this.state = 2262;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 277, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2258;
						this.match(SparkSqlParser.COMMA);
						this.state = 2259;
						_localctx._groupByClause = this.groupByClause();
						_localctx._groupingExpressionsWithGroupingAnalytics.push(_localctx._groupByClause);
						}
						}
					}
					this.state = 2264;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 277, this._ctx);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2265;
				this.match(SparkSqlParser.KW_GROUP);
				this.state = 2266;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2267;
				_localctx._expression = this.expression();
				_localctx._groupingExpressions.push(_localctx._expression);
				this.state = 2272;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 278, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2268;
						this.match(SparkSqlParser.COMMA);
						this.state = 2269;
						_localctx._expression = this.expression();
						_localctx._groupingExpressions.push(_localctx._expression);
						}
						}
					}
					this.state = 2274;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 278, this._ctx);
				}
				this.state = 2292;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 280, this._ctx) ) {
				case 1:
					{
					this.state = 2275;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 2276;
					_localctx._kind = this.match(SparkSqlParser.KW_ROLLUP);
					}
					break;

				case 2:
					{
					this.state = 2277;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 2278;
					_localctx._kind = this.match(SparkSqlParser.KW_CUBE);
					}
					break;

				case 3:
					{
					this.state = 2279;
					_localctx._kind = this.match(SparkSqlParser.KW_GROUPING);
					this.state = 2280;
					this.match(SparkSqlParser.KW_SETS);
					this.state = 2281;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2282;
					this.groupingSet();
					this.state = 2287;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2283;
						this.match(SparkSqlParser.COMMA);
						this.state = 2284;
						this.groupingSet();
						}
						}
						this.state = 2289;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 2290;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public groupByClause(): GroupByClauseContext {
		let _localctx: GroupByClauseContext = new GroupByClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 152, SparkSqlParser.RULE_groupByClause);
		try {
			this.state = 2299;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 282, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2296;
				this.columnName();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2297;
				this.groupingAnalytics();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2298;
				this.expression();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public groupingAnalytics(): GroupingAnalyticsContext {
		let _localctx: GroupingAnalyticsContext = new GroupingAnalyticsContext(this._ctx, this.state);
		this.enterRule(_localctx, 154, SparkSqlParser.RULE_groupingAnalytics);
		let _la: number;
		try {
			this.state = 2326;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_CUBE:
			case SparkSqlParser.KW_ROLLUP:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2301;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_CUBE || _la === SparkSqlParser.KW_ROLLUP)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2302;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2303;
				this.groupingSet();
				this.state = 2308;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2304;
					this.match(SparkSqlParser.COMMA);
					this.state = 2305;
					this.groupingSet();
					}
					}
					this.state = 2310;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2311;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			case SparkSqlParser.KW_GROUPING:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2313;
				this.match(SparkSqlParser.KW_GROUPING);
				this.state = 2314;
				this.match(SparkSqlParser.KW_SETS);
				this.state = 2315;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2316;
				this.groupingElement();
				this.state = 2321;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2317;
					this.match(SparkSqlParser.COMMA);
					this.state = 2318;
					this.groupingElement();
					}
					}
					this.state = 2323;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2324;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public groupingElement(): GroupingElementContext {
		let _localctx: GroupingElementContext = new GroupingElementContext(this._ctx, this.state);
		this.enterRule(_localctx, 156, SparkSqlParser.RULE_groupingElement);
		try {
			this.state = 2330;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 286, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2328;
				this.groupingAnalytics();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2329;
				this.groupingSet();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public groupingSet(): GroupingSetContext {
		let _localctx: GroupingSetContext = new GroupingSetContext(this._ctx, this.state);
		this.enterRule(_localctx, 158, SparkSqlParser.RULE_groupingSet);
		let _la: number;
		try {
			this.state = 2352;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 291, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2332;
				this.columnName();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2333;
				this.expression();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2334;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2349;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
					{
					this.state = 2337;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 287, this._ctx) ) {
					case 1:
						{
						this.state = 2335;
						this.columnName();
						}
						break;

					case 2:
						{
						this.state = 2336;
						this.expression();
						}
						break;
					}
					this.state = 2346;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2339;
						this.match(SparkSqlParser.COMMA);
						this.state = 2342;
						this._errHandler.sync(this);
						switch ( this.interpreter.adaptivePredict(this._input, 288, this._ctx) ) {
						case 1:
							{
							this.state = 2340;
							this.columnName();
							}
							break;

						case 2:
							{
							this.state = 2341;
							this.expression();
							}
							break;
						}
						}
						}
						this.state = 2348;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
				}

				this.state = 2351;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public pivotClause(): PivotClauseContext {
		let _localctx: PivotClauseContext = new PivotClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 160, SparkSqlParser.RULE_pivotClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2354;
			this.match(SparkSqlParser.KW_PIVOT);
			this.state = 2355;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2356;
			_localctx._aggregates = this.namedExpressionSeq();
			this.state = 2357;
			this.match(SparkSqlParser.KW_FOR);
			this.state = 2358;
			this.pivotColumn();
			this.state = 2359;
			this.match(SparkSqlParser.KW_IN);
			this.state = 2360;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2361;
			_localctx._pivotValue = this.pivotValue();
			_localctx._pivotValues.push(_localctx._pivotValue);
			this.state = 2366;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2362;
				this.match(SparkSqlParser.COMMA);
				this.state = 2363;
				_localctx._pivotValue = this.pivotValue();
				_localctx._pivotValues.push(_localctx._pivotValue);
				}
				}
				this.state = 2368;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2369;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2370;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public pivotColumn(): PivotColumnContext {
		let _localctx: PivotColumnContext = new PivotColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 162, SparkSqlParser.RULE_pivotColumn);
		let _la: number;
		try {
			this.state = 2384;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_ADD:
			case SparkSqlParser.KW_AFTER:
			case SparkSqlParser.KW_ALL:
			case SparkSqlParser.KW_ALTER:
			case SparkSqlParser.KW_ALWAYS:
			case SparkSqlParser.KW_ANALYZE:
			case SparkSqlParser.KW_AND:
			case SparkSqlParser.KW_ANTI:
			case SparkSqlParser.KW_ANY:
			case SparkSqlParser.KW_ANY_VALUE:
			case SparkSqlParser.KW_ARCHIVE:
			case SparkSqlParser.KW_ARRAY:
			case SparkSqlParser.KW_AS:
			case SparkSqlParser.KW_ASC:
			case SparkSqlParser.KW_AT:
			case SparkSqlParser.KW_AUTHORIZATION:
			case SparkSqlParser.KW_BETWEEN:
			case SparkSqlParser.KW_BIGINT:
			case SparkSqlParser.KW_BINARY:
			case SparkSqlParser.KW_BOOLEAN:
			case SparkSqlParser.KW_BOTH:
			case SparkSqlParser.KW_BUCKET:
			case SparkSqlParser.KW_BUCKETS:
			case SparkSqlParser.KW_BY:
			case SparkSqlParser.KW_BYTE:
			case SparkSqlParser.KW_CACHE:
			case SparkSqlParser.KW_CASCADE:
			case SparkSqlParser.KW_CASE:
			case SparkSqlParser.KW_CAST:
			case SparkSqlParser.KW_CATALOG:
			case SparkSqlParser.KW_CATALOGS:
			case SparkSqlParser.KW_CHANGE:
			case SparkSqlParser.KW_CHAR:
			case SparkSqlParser.KW_CHARACTER:
			case SparkSqlParser.KW_CHECK:
			case SparkSqlParser.KW_CLEAR:
			case SparkSqlParser.KW_CLUSTER:
			case SparkSqlParser.KW_CLUSTERED:
			case SparkSqlParser.KW_CODEGEN:
			case SparkSqlParser.KW_COLLATE:
			case SparkSqlParser.KW_COLLECTION:
			case SparkSqlParser.KW_COLUMN:
			case SparkSqlParser.KW_COLUMNS:
			case SparkSqlParser.KW_COMMENT:
			case SparkSqlParser.KW_COMMIT:
			case SparkSqlParser.KW_COMPACT:
			case SparkSqlParser.KW_COMPACTIONS:
			case SparkSqlParser.KW_COMPUTE:
			case SparkSqlParser.KW_CONCATENATE:
			case SparkSqlParser.KW_CONSTRAINT:
			case SparkSqlParser.KW_COST:
			case SparkSqlParser.KW_CREATE:
			case SparkSqlParser.KW_CROSS:
			case SparkSqlParser.KW_CUBE:
			case SparkSqlParser.KW_CURRENT:
			case SparkSqlParser.KW_CURRENT_DATE:
			case SparkSqlParser.KW_CURRENT_TIME:
			case SparkSqlParser.KW_CURRENT_TIMESTAMP:
			case SparkSqlParser.KW_CURRENT_USER:
			case SparkSqlParser.KW_DAY:
			case SparkSqlParser.KW_DAYS:
			case SparkSqlParser.KW_DAYOFYEAR:
			case SparkSqlParser.KW_DATA:
			case SparkSqlParser.KW_DATE:
			case SparkSqlParser.KW_DATABASE:
			case SparkSqlParser.KW_DATABASES:
			case SparkSqlParser.KW_DATEADD:
			case SparkSqlParser.KW_DATE_ADD:
			case SparkSqlParser.KW_DATEDIFF:
			case SparkSqlParser.KW_DATE_DIFF:
			case SparkSqlParser.KW_DBPROPERTIES:
			case SparkSqlParser.KW_DEC:
			case SparkSqlParser.KW_DECIMAL:
			case SparkSqlParser.KW_DECLARE:
			case SparkSqlParser.KW_DEFAULT:
			case SparkSqlParser.KW_DEFINED:
			case SparkSqlParser.KW_DELETE:
			case SparkSqlParser.KW_DELIMITED:
			case SparkSqlParser.KW_DESC:
			case SparkSqlParser.KW_DESCRIBE:
			case SparkSqlParser.KW_DFS:
			case SparkSqlParser.KW_DIRECTORIES:
			case SparkSqlParser.KW_DIRECTORY:
			case SparkSqlParser.KW_DISTINCT:
			case SparkSqlParser.KW_DISTRIBUTE:
			case SparkSqlParser.KW_DIV:
			case SparkSqlParser.KW_DOUBLE:
			case SparkSqlParser.KW_DROP:
			case SparkSqlParser.KW_ELSE:
			case SparkSqlParser.KW_END:
			case SparkSqlParser.KW_ESCAPE:
			case SparkSqlParser.KW_ESCAPED:
			case SparkSqlParser.KW_EXCEPT:
			case SparkSqlParser.KW_EXCHANGE:
			case SparkSqlParser.KW_EXCLUDE:
			case SparkSqlParser.KW_EXISTS:
			case SparkSqlParser.KW_EXPLAIN:
			case SparkSqlParser.KW_EXPORT:
			case SparkSqlParser.KW_EXTENDED:
			case SparkSqlParser.KW_EXTERNAL:
			case SparkSqlParser.KW_EXTRACT:
			case SparkSqlParser.KW_FALSE:
			case SparkSqlParser.KW_FETCH:
			case SparkSqlParser.KW_FIELDS:
			case SparkSqlParser.KW_FILTER:
			case SparkSqlParser.KW_FILEFORMAT:
			case SparkSqlParser.KW_FIRST:
			case SparkSqlParser.KW_FLOAT:
			case SparkSqlParser.KW_FOLLOWING:
			case SparkSqlParser.KW_FOR:
			case SparkSqlParser.KW_FOREIGN:
			case SparkSqlParser.KW_FORMAT:
			case SparkSqlParser.KW_FORMATTED:
			case SparkSqlParser.KW_FROM:
			case SparkSqlParser.KW_FULL:
			case SparkSqlParser.KW_FUNCTION:
			case SparkSqlParser.KW_FUNCTIONS:
			case SparkSqlParser.KW_GENERATED:
			case SparkSqlParser.KW_GLOBAL:
			case SparkSqlParser.KW_GRANT:
			case SparkSqlParser.KW_GROUP:
			case SparkSqlParser.KW_GROUPING:
			case SparkSqlParser.KW_HAVING:
			case SparkSqlParser.KW_BINARY_HEX:
			case SparkSqlParser.KW_HOUR:
			case SparkSqlParser.KW_HOURS:
			case SparkSqlParser.KW_IDENTIFIER:
			case SparkSqlParser.KW_IF:
			case SparkSqlParser.KW_IGNORE:
			case SparkSqlParser.KW_IMPORT:
			case SparkSqlParser.KW_IN:
			case SparkSqlParser.KW_INCLUDE:
			case SparkSqlParser.KW_INDEX:
			case SparkSqlParser.KW_INDEXES:
			case SparkSqlParser.KW_INNER:
			case SparkSqlParser.KW_INPATH:
			case SparkSqlParser.KW_INPUTFORMAT:
			case SparkSqlParser.KW_INSERT:
			case SparkSqlParser.KW_INTERSECT:
			case SparkSqlParser.KW_INTERVAL:
			case SparkSqlParser.KW_INT:
			case SparkSqlParser.KW_INTEGER:
			case SparkSqlParser.KW_INTO:
			case SparkSqlParser.KW_IS:
			case SparkSqlParser.KW_ITEMS:
			case SparkSqlParser.KW_JOIN:
			case SparkSqlParser.KW_KEYS:
			case SparkSqlParser.KW_LAST:
			case SparkSqlParser.KW_LATERAL:
			case SparkSqlParser.KW_LAZY:
			case SparkSqlParser.KW_LEADING:
			case SparkSqlParser.KW_LEFT:
			case SparkSqlParser.KW_LIKE:
			case SparkSqlParser.KW_ILIKE:
			case SparkSqlParser.KW_LIMIT:
			case SparkSqlParser.KW_LINES:
			case SparkSqlParser.KW_LIST:
			case SparkSqlParser.KW_LOAD:
			case SparkSqlParser.KW_LOCAL:
			case SparkSqlParser.KW_LOCATION:
			case SparkSqlParser.KW_LOCK:
			case SparkSqlParser.KW_LOCKS:
			case SparkSqlParser.KW_LOGICAL:
			case SparkSqlParser.KW_LONG:
			case SparkSqlParser.KW_MACRO:
			case SparkSqlParser.KW_MAP:
			case SparkSqlParser.KW_MATCHED:
			case SparkSqlParser.KW_MERGE:
			case SparkSqlParser.KW_MICROSECOND:
			case SparkSqlParser.KW_MICROSECONDS:
			case SparkSqlParser.KW_MILLISECOND:
			case SparkSqlParser.KW_MILLISECONDS:
			case SparkSqlParser.KW_MINUTE:
			case SparkSqlParser.KW_MINUTES:
			case SparkSqlParser.KW_MONTH:
			case SparkSqlParser.KW_MONTHS:
			case SparkSqlParser.KW_MSCK:
			case SparkSqlParser.KW_NAME:
			case SparkSqlParser.KW_NAMESPACE:
			case SparkSqlParser.KW_NAMESPACES:
			case SparkSqlParser.KW_NANOSECOND:
			case SparkSqlParser.KW_NANOSECONDS:
			case SparkSqlParser.KW_NATURAL:
			case SparkSqlParser.KW_NO:
			case SparkSqlParser.KW_NOT:
			case SparkSqlParser.KW_NULL:
			case SparkSqlParser.KW_NULLS:
			case SparkSqlParser.KW_NUMERIC:
			case SparkSqlParser.KW_OF:
			case SparkSqlParser.KW_OFFSET:
			case SparkSqlParser.KW_ON:
			case SparkSqlParser.KW_ONLY:
			case SparkSqlParser.KW_OPTION:
			case SparkSqlParser.KW_OPTIONS:
			case SparkSqlParser.KW_OR:
			case SparkSqlParser.KW_ORDER:
			case SparkSqlParser.KW_OUT:
			case SparkSqlParser.KW_OUTER:
			case SparkSqlParser.KW_OUTPUTFORMAT:
			case SparkSqlParser.KW_OVER:
			case SparkSqlParser.KW_OVERLAPS:
			case SparkSqlParser.KW_OVERLAY:
			case SparkSqlParser.KW_OVERWRITE:
			case SparkSqlParser.KW_PARTITION:
			case SparkSqlParser.KW_PARTITIONED:
			case SparkSqlParser.KW_PARTITIONS:
			case SparkSqlParser.KW_PERCENTILE_CONT:
			case SparkSqlParser.KW_PERCENTILE_DISC:
			case SparkSqlParser.KW_PERCENTLIT:
			case SparkSqlParser.KW_PIVOT:
			case SparkSqlParser.KW_PLACING:
			case SparkSqlParser.KW_POSITION:
			case SparkSqlParser.KW_PRECEDING:
			case SparkSqlParser.KW_PRIMARY:
			case SparkSqlParser.KW_PRINCIPALS:
			case SparkSqlParser.KW_PROPERTIES:
			case SparkSqlParser.KW_PURGE:
			case SparkSqlParser.KW_QUARTER:
			case SparkSqlParser.KW_QUERY:
			case SparkSqlParser.KW_RANGE:
			case SparkSqlParser.KW_REAL:
			case SparkSqlParser.KW_RECORDREADER:
			case SparkSqlParser.KW_RECORDWRITER:
			case SparkSqlParser.KW_RECOVER:
			case SparkSqlParser.KW_REDUCE:
			case SparkSqlParser.KW_REFERENCES:
			case SparkSqlParser.KW_REFRESH:
			case SparkSqlParser.KW_RENAME:
			case SparkSqlParser.KW_REPAIR:
			case SparkSqlParser.KW_REPEATABLE:
			case SparkSqlParser.KW_REPLACE:
			case SparkSqlParser.KW_RESET:
			case SparkSqlParser.KW_RESPECT:
			case SparkSqlParser.KW_RESTRICT:
			case SparkSqlParser.KW_REVOKE:
			case SparkSqlParser.KW_RIGHT:
			case SparkSqlParser.KW_RLIKE:
			case SparkSqlParser.KW_REGEXP:
			case SparkSqlParser.KW_ROLE:
			case SparkSqlParser.KW_ROLES:
			case SparkSqlParser.KW_ROLLBACK:
			case SparkSqlParser.KW_ROLLUP:
			case SparkSqlParser.KW_ROW:
			case SparkSqlParser.KW_ROWS:
			case SparkSqlParser.KW_SECOND:
			case SparkSqlParser.KW_SECONDS:
			case SparkSqlParser.KW_SCHEMA:
			case SparkSqlParser.KW_SCHEMAS:
			case SparkSqlParser.KW_SELECT:
			case SparkSqlParser.KW_SEMI:
			case SparkSqlParser.KW_SEPARATED:
			case SparkSqlParser.KW_SERDE:
			case SparkSqlParser.KW_SERDEPROPERTIES:
			case SparkSqlParser.KW_SESSION_USER:
			case SparkSqlParser.KW_SET:
			case SparkSqlParser.KW_MINUS:
			case SparkSqlParser.KW_SETS:
			case SparkSqlParser.KW_SHORT:
			case SparkSqlParser.KW_SHOW:
			case SparkSqlParser.KW_SINGLE:
			case SparkSqlParser.KW_SKEWED:
			case SparkSqlParser.KW_SMALLINT:
			case SparkSqlParser.KW_SOME:
			case SparkSqlParser.KW_SORT:
			case SparkSqlParser.KW_SORTED:
			case SparkSqlParser.KW_SOURCE:
			case SparkSqlParser.KW_START:
			case SparkSqlParser.KW_STATISTICS:
			case SparkSqlParser.KW_STORED:
			case SparkSqlParser.KW_STRATIFY:
			case SparkSqlParser.KW_STRING:
			case SparkSqlParser.KW_STRUCT:
			case SparkSqlParser.KW_SUBSTR:
			case SparkSqlParser.KW_SUBSTRING:
			case SparkSqlParser.KW_SYNC:
			case SparkSqlParser.KW_SYSTEM:
			case SparkSqlParser.KW_SYSTEM_TIME:
			case SparkSqlParser.KW_SYSTEM_VERSION:
			case SparkSqlParser.KW_TABLE:
			case SparkSqlParser.KW_TABLES:
			case SparkSqlParser.KW_TABLESAMPLE:
			case SparkSqlParser.KW_TARGET:
			case SparkSqlParser.KW_TBLPROPERTIES:
			case SparkSqlParser.KW_TEMPORARY:
			case SparkSqlParser.KW_TERMINATED:
			case SparkSqlParser.KW_THEN:
			case SparkSqlParser.KW_TIME:
			case SparkSqlParser.KW_TIMEDIFF:
			case SparkSqlParser.KW_TIMESTAMP:
			case SparkSqlParser.KW_TIMESTAMP_LTZ:
			case SparkSqlParser.KW_TIMESTAMP_NTZ:
			case SparkSqlParser.KW_TIMESTAMPADD:
			case SparkSqlParser.KW_TIMESTAMPDIFF:
			case SparkSqlParser.KW_TINYINT:
			case SparkSqlParser.KW_TO:
			case SparkSqlParser.KW_TOUCH:
			case SparkSqlParser.KW_TRAILING:
			case SparkSqlParser.KW_TRANSACTION:
			case SparkSqlParser.KW_TRANSACTIONS:
			case SparkSqlParser.KW_TRANSFORM:
			case SparkSqlParser.KW_TRIM:
			case SparkSqlParser.KW_TRUE:
			case SparkSqlParser.KW_TRUNCATE:
			case SparkSqlParser.KW_TRY_CAST:
			case SparkSqlParser.KW_TYPE:
			case SparkSqlParser.KW_UNARCHIVE:
			case SparkSqlParser.KW_UNBOUNDED:
			case SparkSqlParser.KW_UNCACHE:
			case SparkSqlParser.KW_UNION:
			case SparkSqlParser.KW_UNIQUE:
			case SparkSqlParser.KW_UNKNOWN:
			case SparkSqlParser.KW_UNLOCK:
			case SparkSqlParser.KW_UNPIVOT:
			case SparkSqlParser.KW_UNSET:
			case SparkSqlParser.KW_UPDATE:
			case SparkSqlParser.KW_USE:
			case SparkSqlParser.KW_USER:
			case SparkSqlParser.KW_USING:
			case SparkSqlParser.KW_VALUES:
			case SparkSqlParser.KW_VARCHAR:
			case SparkSqlParser.KW_VAR:
			case SparkSqlParser.KW_VARIABLE:
			case SparkSqlParser.KW_VERSION:
			case SparkSqlParser.KW_VIEW:
			case SparkSqlParser.KW_VIEWS:
			case SparkSqlParser.KW_VOID:
			case SparkSqlParser.KW_WEEK:
			case SparkSqlParser.KW_WEEKS:
			case SparkSqlParser.KW_WHEN:
			case SparkSqlParser.KW_WHERE:
			case SparkSqlParser.KW_WINDOW:
			case SparkSqlParser.KW_WITH:
			case SparkSqlParser.KW_WITHIN:
			case SparkSqlParser.KW_YEAR:
			case SparkSqlParser.KW_YEARS:
			case SparkSqlParser.KW_ZONE:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
			case SparkSqlParser.IDENTIFIER:
			case SparkSqlParser.BACKQUOTED_IDENTIFIER:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2372;
				_localctx._identifier = this.identifier();
				_localctx._identifiers.push(_localctx._identifier);
				}
				break;
			case SparkSqlParser.LEFT_PAREN:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2373;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2374;
				_localctx._identifier = this.identifier();
				_localctx._identifiers.push(_localctx._identifier);
				this.state = 2379;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2375;
					this.match(SparkSqlParser.COMMA);
					this.state = 2376;
					_localctx._identifier = this.identifier();
					_localctx._identifiers.push(_localctx._identifier);
					}
					}
					this.state = 2381;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2382;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public pivotValue(): PivotValueContext {
		let _localctx: PivotValueContext = new PivotValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 164, SparkSqlParser.RULE_pivotValue);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2386;
			this.expression();
			this.state = 2391;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 371)) & ~0x1F) === 0 && ((1 << (_la - 371)) & ((1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 371)) | (1 << (SparkSqlParser.IDENTIFIER - 371)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 371)))) !== 0)) {
				{
				this.state = 2388;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 295, this._ctx) ) {
				case 1:
					{
					this.state = 2387;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2390;
				this.identifier();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotClause(): UnpivotClauseContext {
		let _localctx: UnpivotClauseContext = new UnpivotClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 166, SparkSqlParser.RULE_unpivotClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2393;
			this.match(SparkSqlParser.KW_UNPIVOT);
			this.state = 2395;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_EXCLUDE || _la === SparkSqlParser.KW_INCLUDE) {
				{
				this.state = 2394;
				_localctx._nullOperator = this.unpivotNullClause();
				}
			}

			this.state = 2397;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2398;
			_localctx._operator = this.unpivotOperator();
			this.state = 2399;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2404;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 299, this._ctx) ) {
			case 1:
				{
				this.state = 2401;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 298, this._ctx) ) {
				case 1:
					{
					this.state = 2400;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2403;
				this.identifier();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotNullClause(): UnpivotNullClauseContext {
		let _localctx: UnpivotNullClauseContext = new UnpivotNullClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 168, SparkSqlParser.RULE_unpivotNullClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2406;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_EXCLUDE || _la === SparkSqlParser.KW_INCLUDE)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			this.state = 2407;
			this.match(SparkSqlParser.KW_NULLS);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotOperator(): UnpivotOperatorContext {
		let _localctx: UnpivotOperatorContext = new UnpivotOperatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 170, SparkSqlParser.RULE_unpivotOperator);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2411;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_ADD:
			case SparkSqlParser.KW_AFTER:
			case SparkSqlParser.KW_ALL:
			case SparkSqlParser.KW_ALTER:
			case SparkSqlParser.KW_ALWAYS:
			case SparkSqlParser.KW_ANALYZE:
			case SparkSqlParser.KW_AND:
			case SparkSqlParser.KW_ANTI:
			case SparkSqlParser.KW_ANY:
			case SparkSqlParser.KW_ANY_VALUE:
			case SparkSqlParser.KW_ARCHIVE:
			case SparkSqlParser.KW_ARRAY:
			case SparkSqlParser.KW_AS:
			case SparkSqlParser.KW_ASC:
			case SparkSqlParser.KW_AT:
			case SparkSqlParser.KW_AUTHORIZATION:
			case SparkSqlParser.KW_BETWEEN:
			case SparkSqlParser.KW_BIGINT:
			case SparkSqlParser.KW_BINARY:
			case SparkSqlParser.KW_BOOLEAN:
			case SparkSqlParser.KW_BOTH:
			case SparkSqlParser.KW_BUCKET:
			case SparkSqlParser.KW_BUCKETS:
			case SparkSqlParser.KW_BY:
			case SparkSqlParser.KW_BYTE:
			case SparkSqlParser.KW_CACHE:
			case SparkSqlParser.KW_CASCADE:
			case SparkSqlParser.KW_CASE:
			case SparkSqlParser.KW_CAST:
			case SparkSqlParser.KW_CATALOG:
			case SparkSqlParser.KW_CATALOGS:
			case SparkSqlParser.KW_CHANGE:
			case SparkSqlParser.KW_CHAR:
			case SparkSqlParser.KW_CHARACTER:
			case SparkSqlParser.KW_CHECK:
			case SparkSqlParser.KW_CLEAR:
			case SparkSqlParser.KW_CLUSTER:
			case SparkSqlParser.KW_CLUSTERED:
			case SparkSqlParser.KW_CODEGEN:
			case SparkSqlParser.KW_COLLATE:
			case SparkSqlParser.KW_COLLECTION:
			case SparkSqlParser.KW_COLUMN:
			case SparkSqlParser.KW_COLUMNS:
			case SparkSqlParser.KW_COMMENT:
			case SparkSqlParser.KW_COMMIT:
			case SparkSqlParser.KW_COMPACT:
			case SparkSqlParser.KW_COMPACTIONS:
			case SparkSqlParser.KW_COMPUTE:
			case SparkSqlParser.KW_CONCATENATE:
			case SparkSqlParser.KW_CONSTRAINT:
			case SparkSqlParser.KW_COST:
			case SparkSqlParser.KW_CREATE:
			case SparkSqlParser.KW_CROSS:
			case SparkSqlParser.KW_CUBE:
			case SparkSqlParser.KW_CURRENT:
			case SparkSqlParser.KW_CURRENT_DATE:
			case SparkSqlParser.KW_CURRENT_TIME:
			case SparkSqlParser.KW_CURRENT_TIMESTAMP:
			case SparkSqlParser.KW_CURRENT_USER:
			case SparkSqlParser.KW_DAY:
			case SparkSqlParser.KW_DAYS:
			case SparkSqlParser.KW_DAYOFYEAR:
			case SparkSqlParser.KW_DATA:
			case SparkSqlParser.KW_DATE:
			case SparkSqlParser.KW_DATABASE:
			case SparkSqlParser.KW_DATABASES:
			case SparkSqlParser.KW_DATEADD:
			case SparkSqlParser.KW_DATE_ADD:
			case SparkSqlParser.KW_DATEDIFF:
			case SparkSqlParser.KW_DATE_DIFF:
			case SparkSqlParser.KW_DBPROPERTIES:
			case SparkSqlParser.KW_DEC:
			case SparkSqlParser.KW_DECIMAL:
			case SparkSqlParser.KW_DECLARE:
			case SparkSqlParser.KW_DEFAULT:
			case SparkSqlParser.KW_DEFINED:
			case SparkSqlParser.KW_DELETE:
			case SparkSqlParser.KW_DELIMITED:
			case SparkSqlParser.KW_DESC:
			case SparkSqlParser.KW_DESCRIBE:
			case SparkSqlParser.KW_DFS:
			case SparkSqlParser.KW_DIRECTORIES:
			case SparkSqlParser.KW_DIRECTORY:
			case SparkSqlParser.KW_DISTINCT:
			case SparkSqlParser.KW_DISTRIBUTE:
			case SparkSqlParser.KW_DIV:
			case SparkSqlParser.KW_DOUBLE:
			case SparkSqlParser.KW_DROP:
			case SparkSqlParser.KW_ELSE:
			case SparkSqlParser.KW_END:
			case SparkSqlParser.KW_ESCAPE:
			case SparkSqlParser.KW_ESCAPED:
			case SparkSqlParser.KW_EXCEPT:
			case SparkSqlParser.KW_EXCHANGE:
			case SparkSqlParser.KW_EXCLUDE:
			case SparkSqlParser.KW_EXISTS:
			case SparkSqlParser.KW_EXPLAIN:
			case SparkSqlParser.KW_EXPORT:
			case SparkSqlParser.KW_EXTENDED:
			case SparkSqlParser.KW_EXTERNAL:
			case SparkSqlParser.KW_EXTRACT:
			case SparkSqlParser.KW_FALSE:
			case SparkSqlParser.KW_FETCH:
			case SparkSqlParser.KW_FIELDS:
			case SparkSqlParser.KW_FILTER:
			case SparkSqlParser.KW_FILEFORMAT:
			case SparkSqlParser.KW_FIRST:
			case SparkSqlParser.KW_FLOAT:
			case SparkSqlParser.KW_FOLLOWING:
			case SparkSqlParser.KW_FOR:
			case SparkSqlParser.KW_FOREIGN:
			case SparkSqlParser.KW_FORMAT:
			case SparkSqlParser.KW_FORMATTED:
			case SparkSqlParser.KW_FROM:
			case SparkSqlParser.KW_FULL:
			case SparkSqlParser.KW_FUNCTION:
			case SparkSqlParser.KW_FUNCTIONS:
			case SparkSqlParser.KW_GENERATED:
			case SparkSqlParser.KW_GLOBAL:
			case SparkSqlParser.KW_GRANT:
			case SparkSqlParser.KW_GROUP:
			case SparkSqlParser.KW_GROUPING:
			case SparkSqlParser.KW_HAVING:
			case SparkSqlParser.KW_BINARY_HEX:
			case SparkSqlParser.KW_HOUR:
			case SparkSqlParser.KW_HOURS:
			case SparkSqlParser.KW_IDENTIFIER:
			case SparkSqlParser.KW_IF:
			case SparkSqlParser.KW_IGNORE:
			case SparkSqlParser.KW_IMPORT:
			case SparkSqlParser.KW_IN:
			case SparkSqlParser.KW_INCLUDE:
			case SparkSqlParser.KW_INDEX:
			case SparkSqlParser.KW_INDEXES:
			case SparkSqlParser.KW_INNER:
			case SparkSqlParser.KW_INPATH:
			case SparkSqlParser.KW_INPUTFORMAT:
			case SparkSqlParser.KW_INSERT:
			case SparkSqlParser.KW_INTERSECT:
			case SparkSqlParser.KW_INTERVAL:
			case SparkSqlParser.KW_INT:
			case SparkSqlParser.KW_INTEGER:
			case SparkSqlParser.KW_INTO:
			case SparkSqlParser.KW_IS:
			case SparkSqlParser.KW_ITEMS:
			case SparkSqlParser.KW_JOIN:
			case SparkSqlParser.KW_KEYS:
			case SparkSqlParser.KW_LAST:
			case SparkSqlParser.KW_LATERAL:
			case SparkSqlParser.KW_LAZY:
			case SparkSqlParser.KW_LEADING:
			case SparkSqlParser.KW_LEFT:
			case SparkSqlParser.KW_LIKE:
			case SparkSqlParser.KW_ILIKE:
			case SparkSqlParser.KW_LIMIT:
			case SparkSqlParser.KW_LINES:
			case SparkSqlParser.KW_LIST:
			case SparkSqlParser.KW_LOAD:
			case SparkSqlParser.KW_LOCAL:
			case SparkSqlParser.KW_LOCATION:
			case SparkSqlParser.KW_LOCK:
			case SparkSqlParser.KW_LOCKS:
			case SparkSqlParser.KW_LOGICAL:
			case SparkSqlParser.KW_LONG:
			case SparkSqlParser.KW_MACRO:
			case SparkSqlParser.KW_MAP:
			case SparkSqlParser.KW_MATCHED:
			case SparkSqlParser.KW_MERGE:
			case SparkSqlParser.KW_MICROSECOND:
			case SparkSqlParser.KW_MICROSECONDS:
			case SparkSqlParser.KW_MILLISECOND:
			case SparkSqlParser.KW_MILLISECONDS:
			case SparkSqlParser.KW_MINUTE:
			case SparkSqlParser.KW_MINUTES:
			case SparkSqlParser.KW_MONTH:
			case SparkSqlParser.KW_MONTHS:
			case SparkSqlParser.KW_MSCK:
			case SparkSqlParser.KW_NAME:
			case SparkSqlParser.KW_NAMESPACE:
			case SparkSqlParser.KW_NAMESPACES:
			case SparkSqlParser.KW_NANOSECOND:
			case SparkSqlParser.KW_NANOSECONDS:
			case SparkSqlParser.KW_NATURAL:
			case SparkSqlParser.KW_NO:
			case SparkSqlParser.KW_NOT:
			case SparkSqlParser.KW_NULL:
			case SparkSqlParser.KW_NULLS:
			case SparkSqlParser.KW_NUMERIC:
			case SparkSqlParser.KW_OF:
			case SparkSqlParser.KW_OFFSET:
			case SparkSqlParser.KW_ON:
			case SparkSqlParser.KW_ONLY:
			case SparkSqlParser.KW_OPTION:
			case SparkSqlParser.KW_OPTIONS:
			case SparkSqlParser.KW_OR:
			case SparkSqlParser.KW_ORDER:
			case SparkSqlParser.KW_OUT:
			case SparkSqlParser.KW_OUTER:
			case SparkSqlParser.KW_OUTPUTFORMAT:
			case SparkSqlParser.KW_OVER:
			case SparkSqlParser.KW_OVERLAPS:
			case SparkSqlParser.KW_OVERLAY:
			case SparkSqlParser.KW_OVERWRITE:
			case SparkSqlParser.KW_PARTITION:
			case SparkSqlParser.KW_PARTITIONED:
			case SparkSqlParser.KW_PARTITIONS:
			case SparkSqlParser.KW_PERCENTILE_CONT:
			case SparkSqlParser.KW_PERCENTILE_DISC:
			case SparkSqlParser.KW_PERCENTLIT:
			case SparkSqlParser.KW_PIVOT:
			case SparkSqlParser.KW_PLACING:
			case SparkSqlParser.KW_POSITION:
			case SparkSqlParser.KW_PRECEDING:
			case SparkSqlParser.KW_PRIMARY:
			case SparkSqlParser.KW_PRINCIPALS:
			case SparkSqlParser.KW_PROPERTIES:
			case SparkSqlParser.KW_PURGE:
			case SparkSqlParser.KW_QUARTER:
			case SparkSqlParser.KW_QUERY:
			case SparkSqlParser.KW_RANGE:
			case SparkSqlParser.KW_REAL:
			case SparkSqlParser.KW_RECORDREADER:
			case SparkSqlParser.KW_RECORDWRITER:
			case SparkSqlParser.KW_RECOVER:
			case SparkSqlParser.KW_REDUCE:
			case SparkSqlParser.KW_REFERENCES:
			case SparkSqlParser.KW_REFRESH:
			case SparkSqlParser.KW_RENAME:
			case SparkSqlParser.KW_REPAIR:
			case SparkSqlParser.KW_REPEATABLE:
			case SparkSqlParser.KW_REPLACE:
			case SparkSqlParser.KW_RESET:
			case SparkSqlParser.KW_RESPECT:
			case SparkSqlParser.KW_RESTRICT:
			case SparkSqlParser.KW_REVOKE:
			case SparkSqlParser.KW_RIGHT:
			case SparkSqlParser.KW_RLIKE:
			case SparkSqlParser.KW_REGEXP:
			case SparkSqlParser.KW_ROLE:
			case SparkSqlParser.KW_ROLES:
			case SparkSqlParser.KW_ROLLBACK:
			case SparkSqlParser.KW_ROLLUP:
			case SparkSqlParser.KW_ROW:
			case SparkSqlParser.KW_ROWS:
			case SparkSqlParser.KW_SECOND:
			case SparkSqlParser.KW_SECONDS:
			case SparkSqlParser.KW_SCHEMA:
			case SparkSqlParser.KW_SCHEMAS:
			case SparkSqlParser.KW_SELECT:
			case SparkSqlParser.KW_SEMI:
			case SparkSqlParser.KW_SEPARATED:
			case SparkSqlParser.KW_SERDE:
			case SparkSqlParser.KW_SERDEPROPERTIES:
			case SparkSqlParser.KW_SESSION_USER:
			case SparkSqlParser.KW_SET:
			case SparkSqlParser.KW_MINUS:
			case SparkSqlParser.KW_SETS:
			case SparkSqlParser.KW_SHORT:
			case SparkSqlParser.KW_SHOW:
			case SparkSqlParser.KW_SINGLE:
			case SparkSqlParser.KW_SKEWED:
			case SparkSqlParser.KW_SMALLINT:
			case SparkSqlParser.KW_SOME:
			case SparkSqlParser.KW_SORT:
			case SparkSqlParser.KW_SORTED:
			case SparkSqlParser.KW_SOURCE:
			case SparkSqlParser.KW_START:
			case SparkSqlParser.KW_STATISTICS:
			case SparkSqlParser.KW_STORED:
			case SparkSqlParser.KW_STRATIFY:
			case SparkSqlParser.KW_STRING:
			case SparkSqlParser.KW_STRUCT:
			case SparkSqlParser.KW_SUBSTR:
			case SparkSqlParser.KW_SUBSTRING:
			case SparkSqlParser.KW_SYNC:
			case SparkSqlParser.KW_SYSTEM:
			case SparkSqlParser.KW_SYSTEM_TIME:
			case SparkSqlParser.KW_SYSTEM_VERSION:
			case SparkSqlParser.KW_TABLE:
			case SparkSqlParser.KW_TABLES:
			case SparkSqlParser.KW_TABLESAMPLE:
			case SparkSqlParser.KW_TARGET:
			case SparkSqlParser.KW_TBLPROPERTIES:
			case SparkSqlParser.KW_TEMPORARY:
			case SparkSqlParser.KW_TERMINATED:
			case SparkSqlParser.KW_THEN:
			case SparkSqlParser.KW_TIME:
			case SparkSqlParser.KW_TIMEDIFF:
			case SparkSqlParser.KW_TIMESTAMP:
			case SparkSqlParser.KW_TIMESTAMP_LTZ:
			case SparkSqlParser.KW_TIMESTAMP_NTZ:
			case SparkSqlParser.KW_TIMESTAMPADD:
			case SparkSqlParser.KW_TIMESTAMPDIFF:
			case SparkSqlParser.KW_TINYINT:
			case SparkSqlParser.KW_TO:
			case SparkSqlParser.KW_TOUCH:
			case SparkSqlParser.KW_TRAILING:
			case SparkSqlParser.KW_TRANSACTION:
			case SparkSqlParser.KW_TRANSACTIONS:
			case SparkSqlParser.KW_TRANSFORM:
			case SparkSqlParser.KW_TRIM:
			case SparkSqlParser.KW_TRUE:
			case SparkSqlParser.KW_TRUNCATE:
			case SparkSqlParser.KW_TRY_CAST:
			case SparkSqlParser.KW_TYPE:
			case SparkSqlParser.KW_UNARCHIVE:
			case SparkSqlParser.KW_UNBOUNDED:
			case SparkSqlParser.KW_UNCACHE:
			case SparkSqlParser.KW_UNION:
			case SparkSqlParser.KW_UNIQUE:
			case SparkSqlParser.KW_UNKNOWN:
			case SparkSqlParser.KW_UNLOCK:
			case SparkSqlParser.KW_UNPIVOT:
			case SparkSqlParser.KW_UNSET:
			case SparkSqlParser.KW_UPDATE:
			case SparkSqlParser.KW_USE:
			case SparkSqlParser.KW_USER:
			case SparkSqlParser.KW_USING:
			case SparkSqlParser.KW_VALUES:
			case SparkSqlParser.KW_VARCHAR:
			case SparkSqlParser.KW_VAR:
			case SparkSqlParser.KW_VARIABLE:
			case SparkSqlParser.KW_VERSION:
			case SparkSqlParser.KW_VIEW:
			case SparkSqlParser.KW_VIEWS:
			case SparkSqlParser.KW_VOID:
			case SparkSqlParser.KW_WEEK:
			case SparkSqlParser.KW_WEEKS:
			case SparkSqlParser.KW_WHEN:
			case SparkSqlParser.KW_WHERE:
			case SparkSqlParser.KW_WINDOW:
			case SparkSqlParser.KW_WITH:
			case SparkSqlParser.KW_WITHIN:
			case SparkSqlParser.KW_YEAR:
			case SparkSqlParser.KW_YEARS:
			case SparkSqlParser.KW_ZONE:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
			case SparkSqlParser.IDENTIFIER:
			case SparkSqlParser.BACKQUOTED_IDENTIFIER:
				{
				this.state = 2409;
				this.unpivotSingleValueColumnClause();
				}
				break;
			case SparkSqlParser.LEFT_PAREN:
				{
				this.state = 2410;
				this.unpivotMultiValueColumnClause();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext {
		let _localctx: UnpivotSingleValueColumnClauseContext = new UnpivotSingleValueColumnClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 172, SparkSqlParser.RULE_unpivotSingleValueColumnClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2413;
			this.unpivotValueColumn();
			this.state = 2414;
			this.match(SparkSqlParser.KW_FOR);
			this.state = 2415;
			this.unpivotNameColumn();
			this.state = 2416;
			this.match(SparkSqlParser.KW_IN);
			this.state = 2417;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2418;
			_localctx._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
			_localctx._unpivotColumns.push(_localctx._unpivotColumnAndAlias);
			this.state = 2423;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2419;
				this.match(SparkSqlParser.COMMA);
				this.state = 2420;
				_localctx._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
				_localctx._unpivotColumns.push(_localctx._unpivotColumnAndAlias);
				}
				}
				this.state = 2425;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2426;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext {
		let _localctx: UnpivotMultiValueColumnClauseContext = new UnpivotMultiValueColumnClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 174, SparkSqlParser.RULE_unpivotMultiValueColumnClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2428;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2429;
			_localctx._unpivotValueColumn = this.unpivotValueColumn();
			_localctx._unpivotValueColumns.push(_localctx._unpivotValueColumn);
			this.state = 2434;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2430;
				this.match(SparkSqlParser.COMMA);
				this.state = 2431;
				_localctx._unpivotValueColumn = this.unpivotValueColumn();
				_localctx._unpivotValueColumns.push(_localctx._unpivotValueColumn);
				}
				}
				this.state = 2436;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2437;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2438;
			this.match(SparkSqlParser.KW_FOR);
			this.state = 2439;
			this.unpivotNameColumn();
			this.state = 2440;
			this.match(SparkSqlParser.KW_IN);
			this.state = 2441;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2442;
			_localctx._unpivotColumnSet = this.unpivotColumnSet();
			_localctx._unpivotColumnSets.push(_localctx._unpivotColumnSet);
			this.state = 2447;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2443;
				this.match(SparkSqlParser.COMMA);
				this.state = 2444;
				_localctx._unpivotColumnSet = this.unpivotColumnSet();
				_localctx._unpivotColumnSets.push(_localctx._unpivotColumnSet);
				}
				}
				this.state = 2449;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2450;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotColumnSet(): UnpivotColumnSetContext {
		let _localctx: UnpivotColumnSetContext = new UnpivotColumnSetContext(this._ctx, this.state);
		this.enterRule(_localctx, 176, SparkSqlParser.RULE_unpivotColumnSet);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2452;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2453;
			_localctx._unpivotColumn = this.unpivotColumn();
			_localctx._unpivotColumns.push(_localctx._unpivotColumn);
			this.state = 2458;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2454;
				this.match(SparkSqlParser.COMMA);
				this.state = 2455;
				_localctx._unpivotColumn = this.unpivotColumn();
				_localctx._unpivotColumns.push(_localctx._unpivotColumn);
				}
				}
				this.state = 2460;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2461;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2463;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 371)) & ~0x1F) === 0 && ((1 << (_la - 371)) & ((1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 371)) | (1 << (SparkSqlParser.IDENTIFIER - 371)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 371)))) !== 0)) {
				{
				this.state = 2462;
				this.unpivotAlias();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotValueColumn(): UnpivotValueColumnContext {
		let _localctx: UnpivotValueColumnContext = new UnpivotValueColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 178, SparkSqlParser.RULE_unpivotValueColumn);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2465;
			this.identifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotNameColumn(): UnpivotNameColumnContext {
		let _localctx: UnpivotNameColumnContext = new UnpivotNameColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 180, SparkSqlParser.RULE_unpivotNameColumn);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2467;
			this.identifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext {
		let _localctx: UnpivotColumnAndAliasContext = new UnpivotColumnAndAliasContext(this._ctx, this.state);
		this.enterRule(_localctx, 182, SparkSqlParser.RULE_unpivotColumnAndAlias);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2469;
			this.unpivotColumn();
			this.state = 2471;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 371)) & ~0x1F) === 0 && ((1 << (_la - 371)) & ((1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 371)) | (1 << (SparkSqlParser.IDENTIFIER - 371)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 371)))) !== 0)) {
				{
				this.state = 2470;
				this.unpivotAlias();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotColumn(): UnpivotColumnContext {
		let _localctx: UnpivotColumnContext = new UnpivotColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 184, SparkSqlParser.RULE_unpivotColumn);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2473;
			this.multipartIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unpivotAlias(): UnpivotAliasContext {
		let _localctx: UnpivotAliasContext = new UnpivotAliasContext(this._ctx, this.state);
		this.enterRule(_localctx, 186, SparkSqlParser.RULE_unpivotAlias);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2476;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 307, this._ctx) ) {
			case 1:
				{
				this.state = 2475;
				this.match(SparkSqlParser.KW_AS);
				}
				break;
			}
			this.state = 2478;
			this.identifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifNotExists(): IfNotExistsContext {
		let _localctx: IfNotExistsContext = new IfNotExistsContext(this._ctx, this.state);
		this.enterRule(_localctx, 188, SparkSqlParser.RULE_ifNotExists);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2480;
			this.match(SparkSqlParser.KW_IF);
			this.state = 2481;
			this.match(SparkSqlParser.KW_NOT);
			this.state = 2482;
			this.match(SparkSqlParser.KW_EXISTS);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ifExists(): IfExistsContext {
		let _localctx: IfExistsContext = new IfExistsContext(this._ctx, this.state);
		this.enterRule(_localctx, 190, SparkSqlParser.RULE_ifExists);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2484;
			this.match(SparkSqlParser.KW_IF);
			this.state = 2485;
			this.match(SparkSqlParser.KW_EXISTS);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public lateralView(): LateralViewContext {
		let _localctx: LateralViewContext = new LateralViewContext(this._ctx, this.state);
		this.enterRule(_localctx, 192, SparkSqlParser.RULE_lateralView);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2487;
			this.match(SparkSqlParser.KW_LATERAL);
			this.state = 2488;
			this.match(SparkSqlParser.KW_VIEW);
			this.state = 2490;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 308, this._ctx) ) {
			case 1:
				{
				this.state = 2489;
				this.match(SparkSqlParser.KW_OUTER);
				}
				break;
			}
			this.state = 2492;
			this.viewName();
			this.state = 2493;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2502;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
				{
				this.state = 2494;
				this.expression();
				this.state = 2499;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2495;
					this.match(SparkSqlParser.COMMA);
					this.state = 2496;
					this.expression();
					}
					}
					this.state = 2501;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
			}

			this.state = 2504;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2505;
			this.tableAlias();
			this.state = 2517;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 313, this._ctx) ) {
			case 1:
				{
				this.state = 2507;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 311, this._ctx) ) {
				case 1:
					{
					this.state = 2506;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2509;
				_localctx._identifier = this.identifier();
				_localctx._colName.push(_localctx._identifier);
				this.state = 2514;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 312, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2510;
						this.match(SparkSqlParser.COMMA);
						this.state = 2511;
						_localctx._identifier = this.identifier();
						_localctx._colName.push(_localctx._identifier);
						}
						}
					}
					this.state = 2516;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 312, this._ctx);
				}
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public setQuantifier(): SetQuantifierContext {
		let _localctx: SetQuantifierContext = new SetQuantifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 194, SparkSqlParser.RULE_setQuantifier);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2519;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public relation(): RelationContext {
		let _localctx: RelationContext = new RelationContext(this._ctx, this.state);
		this.enterRule(_localctx, 196, SparkSqlParser.RULE_relation);
		try {
			let _alt: number;
			this.state = 2532;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 316, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2522;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 314, this._ctx) ) {
				case 1:
					{
					this.state = 2521;
					this.match(SparkSqlParser.KW_LATERAL);
					}
					break;
				}
				this.state = 2524;
				this.relationPrimary();
				this.state = 2528;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 315, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2525;
						this.relationExtension();
						}
						}
					}
					this.state = 2530;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 315, this._ctx);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2531;
				this.tableName();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public relationExtension(): RelationExtensionContext {
		let _localctx: RelationExtensionContext = new RelationExtensionContext(this._ctx, this.state);
		this.enterRule(_localctx, 198, SparkSqlParser.RULE_relationExtension);
		try {
			this.state = 2537;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_ANTI:
			case SparkSqlParser.KW_CROSS:
			case SparkSqlParser.KW_FULL:
			case SparkSqlParser.KW_INNER:
			case SparkSqlParser.KW_JOIN:
			case SparkSqlParser.KW_LEFT:
			case SparkSqlParser.KW_NATURAL:
			case SparkSqlParser.KW_RIGHT:
			case SparkSqlParser.KW_SEMI:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2534;
				this.joinRelation();
				}
				break;
			case SparkSqlParser.KW_PIVOT:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2535;
				this.pivotClause();
				}
				break;
			case SparkSqlParser.KW_UNPIVOT:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2536;
				this.unpivotClause();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public joinRelation(): JoinRelationContext {
		let _localctx: JoinRelationContext = new JoinRelationContext(this._ctx, this.state);
		this.enterRule(_localctx, 200, SparkSqlParser.RULE_joinRelation);
		try {
			this.state = 2556;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_ANTI:
			case SparkSqlParser.KW_CROSS:
			case SparkSqlParser.KW_FULL:
			case SparkSqlParser.KW_INNER:
			case SparkSqlParser.KW_JOIN:
			case SparkSqlParser.KW_LEFT:
			case SparkSqlParser.KW_RIGHT:
			case SparkSqlParser.KW_SEMI:
				this.enterOuterAlt(_localctx, 1);
				{
				{
				this.state = 2539;
				this.joinType();
				}
				this.state = 2540;
				this.match(SparkSqlParser.KW_JOIN);
				this.state = 2542;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 318, this._ctx) ) {
				case 1:
					{
					this.state = 2541;
					this.match(SparkSqlParser.KW_LATERAL);
					}
					break;
				}
				this.state = 2544;
				_localctx._right = this.relationPrimary();
				this.state = 2546;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 319, this._ctx) ) {
				case 1:
					{
					this.state = 2545;
					this.joinCriteria();
					}
					break;
				}
				}
				break;
			case SparkSqlParser.KW_NATURAL:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2548;
				this.match(SparkSqlParser.KW_NATURAL);
				this.state = 2549;
				this.joinType();
				this.state = 2550;
				this.match(SparkSqlParser.KW_JOIN);
				this.state = 2552;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 320, this._ctx) ) {
				case 1:
					{
					this.state = 2551;
					this.match(SparkSqlParser.KW_LATERAL);
					}
					break;
				}
				this.state = 2554;
				_localctx._right = this.relationPrimary();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public joinType(): JoinTypeContext {
		let _localctx: JoinTypeContext = new JoinTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 202, SparkSqlParser.RULE_joinType);
		let _la: number;
		try {
			this.state = 2582;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 328, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2559;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_INNER) {
					{
					this.state = 2558;
					this.match(SparkSqlParser.KW_INNER);
					}
				}

				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2561;
				this.match(SparkSqlParser.KW_CROSS);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2562;
				this.match(SparkSqlParser.KW_LEFT);
				this.state = 2564;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OUTER) {
					{
					this.state = 2563;
					this.match(SparkSqlParser.KW_OUTER);
					}
				}

				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 2567;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LEFT) {
					{
					this.state = 2566;
					this.match(SparkSqlParser.KW_LEFT);
					}
				}

				this.state = 2569;
				this.match(SparkSqlParser.KW_SEMI);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 2570;
				this.match(SparkSqlParser.KW_RIGHT);
				this.state = 2572;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OUTER) {
					{
					this.state = 2571;
					this.match(SparkSqlParser.KW_OUTER);
					}
				}

				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 2574;
				this.match(SparkSqlParser.KW_FULL);
				this.state = 2576;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OUTER) {
					{
					this.state = 2575;
					this.match(SparkSqlParser.KW_OUTER);
					}
				}

				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 2579;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LEFT) {
					{
					this.state = 2578;
					this.match(SparkSqlParser.KW_LEFT);
					}
				}

				this.state = 2581;
				this.match(SparkSqlParser.KW_ANTI);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public joinCriteria(): JoinCriteriaContext {
		let _localctx: JoinCriteriaContext = new JoinCriteriaContext(this._ctx, this.state);
		this.enterRule(_localctx, 204, SparkSqlParser.RULE_joinCriteria);
		try {
			this.state = 2588;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_ON:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2584;
				this.match(SparkSqlParser.KW_ON);
				this.state = 2585;
				this.booleanExpression(0);
				}
				break;
			case SparkSqlParser.KW_USING:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2586;
				this.match(SparkSqlParser.KW_USING);
				this.state = 2587;
				this.identifierList();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public sample(): SampleContext {
		let _localctx: SampleContext = new SampleContext(this._ctx, this.state);
		this.enterRule(_localctx, 206, SparkSqlParser.RULE_sample);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2590;
			this.match(SparkSqlParser.KW_TABLESAMPLE);
			this.state = 2591;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2593;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
				{
				this.state = 2592;
				this.sampleMethod();
				}
			}

			this.state = 2595;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2600;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 331, this._ctx) ) {
			case 1:
				{
				this.state = 2596;
				this.match(SparkSqlParser.KW_REPEATABLE);
				this.state = 2597;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2598;
				_localctx._seed = this.match(SparkSqlParser.INTEGER_VALUE);
				this.state = 2599;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public sampleMethod(): SampleMethodContext {
		let _localctx: SampleMethodContext = new SampleMethodContext(this._ctx, this.state);
		this.enterRule(_localctx, 208, SparkSqlParser.RULE_sampleMethod);
		let _la: number;
		try {
			this.state = 2626;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 335, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2603;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 2602;
					_localctx._negativeSign = this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 2605;
				_localctx._percentage = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.INTEGER_VALUE || _la === SparkSqlParser.DECIMAL_VALUE)) {
					_localctx._percentage = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2606;
				this.match(SparkSqlParser.KW_PERCENTLIT);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2607;
				this.expression();
				this.state = 2608;
				this.match(SparkSqlParser.KW_ROWS);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2610;
				_localctx._sampleType = this.match(SparkSqlParser.KW_BUCKET);
				this.state = 2611;
				_localctx._numerator = this.match(SparkSqlParser.INTEGER_VALUE);
				this.state = 2612;
				this.match(SparkSqlParser.KW_OUT);
				this.state = 2613;
				this.match(SparkSqlParser.KW_OF);
				this.state = 2614;
				_localctx._denominator = this.match(SparkSqlParser.INTEGER_VALUE);
				this.state = 2623;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ON) {
					{
					this.state = 2615;
					this.match(SparkSqlParser.KW_ON);
					this.state = 2621;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 333, this._ctx) ) {
					case 1:
						{
						this.state = 2616;
						this.identifier();
						}
						break;

					case 2:
						{
						this.state = 2617;
						this.qualifiedName();
						this.state = 2618;
						this.match(SparkSqlParser.LEFT_PAREN);
						this.state = 2619;
						this.match(SparkSqlParser.RIGHT_PAREN);
						}
						break;
					}
					}
				}

				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 2625;
				_localctx._bytes = this.expression();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public identifierList(): IdentifierListContext {
		let _localctx: IdentifierListContext = new IdentifierListContext(this._ctx, this.state);
		this.enterRule(_localctx, 210, SparkSqlParser.RULE_identifierList);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2628;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2629;
			this.identifierSeq();
			this.state = 2630;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public identifierSeq(): IdentifierSeqContext {
		let _localctx: IdentifierSeqContext = new IdentifierSeqContext(this._ctx, this.state);
		this.enterRule(_localctx, 212, SparkSqlParser.RULE_identifierSeq);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2632;
			_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
			_localctx._ident.push(_localctx._errorCapturingIdentifier);
			this.state = 2637;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 336, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2633;
					this.match(SparkSqlParser.COMMA);
					this.state = 2634;
					_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
					_localctx._ident.push(_localctx._errorCapturingIdentifier);
					}
					}
				}
				this.state = 2639;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 336, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public orderedIdentifierList(): OrderedIdentifierListContext {
		let _localctx: OrderedIdentifierListContext = new OrderedIdentifierListContext(this._ctx, this.state);
		this.enterRule(_localctx, 214, SparkSqlParser.RULE_orderedIdentifierList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2640;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2641;
			this.orderedIdentifier();
			this.state = 2646;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2642;
				this.match(SparkSqlParser.COMMA);
				this.state = 2643;
				this.orderedIdentifier();
				}
				}
				this.state = 2648;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2649;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public orderedIdentifier(): OrderedIdentifierContext {
		let _localctx: OrderedIdentifierContext = new OrderedIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 216, SparkSqlParser.RULE_orderedIdentifier);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2651;
			_localctx._ident = this.errorCapturingIdentifier();
			this.state = 2653;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC) {
				{
				this.state = 2652;
				_localctx._ordering = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC)) {
					_localctx._ordering = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public identifierCommentList(): IdentifierCommentListContext {
		let _localctx: IdentifierCommentListContext = new IdentifierCommentListContext(this._ctx, this.state);
		this.enterRule(_localctx, 218, SparkSqlParser.RULE_identifierCommentList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2655;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2656;
			this.identifierComment();
			this.state = 2661;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2657;
				this.match(SparkSqlParser.COMMA);
				this.state = 2658;
				this.identifierComment();
				}
				}
				this.state = 2663;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2664;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public identifierComment(): IdentifierCommentContext {
		let _localctx: IdentifierCommentContext = new IdentifierCommentContext(this._ctx, this.state);
		this.enterRule(_localctx, 220, SparkSqlParser.RULE_identifierComment);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2666;
			this.identifier();
			this.state = 2668;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_COMMENT) {
				{
				this.state = 2667;
				this.commentSpec();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public relationPrimary(): RelationPrimaryContext {
		let _localctx: RelationPrimaryContext = new RelationPrimaryContext(this._ctx, this.state);
		this.enterRule(_localctx, 222, SparkSqlParser.RULE_relationPrimary);
		try {
			this.state = 2697;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 345, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2670;
				this.identifierReference();
				this.state = 2672;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 341, this._ctx) ) {
				case 1:
					{
					this.state = 2671;
					this.temporalClause();
					}
					break;
				}
				this.state = 2675;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 342, this._ctx) ) {
				case 1:
					{
					this.state = 2674;
					this.sample();
					}
					break;
				}
				this.state = 2677;
				this.tableAlias();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2679;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2680;
				this.query();
				this.state = 2681;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2683;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 343, this._ctx) ) {
				case 1:
					{
					this.state = 2682;
					this.sample();
					}
					break;
				}
				this.state = 2685;
				this.tableAlias();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2687;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2688;
				this.relation();
				this.state = 2689;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2691;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 344, this._ctx) ) {
				case 1:
					{
					this.state = 2690;
					this.sample();
					}
					break;
				}
				this.state = 2693;
				this.tableAlias();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 2695;
				this.inlineTable();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 2696;
				this.functionTable();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public inlineTable(): InlineTableContext {
		let _localctx: InlineTableContext = new InlineTableContext(this._ctx, this.state);
		this.enterRule(_localctx, 224, SparkSqlParser.RULE_inlineTable);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2699;
			this.match(SparkSqlParser.KW_VALUES);
			this.state = 2700;
			this.expression();
			this.state = 2705;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 346, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2701;
					this.match(SparkSqlParser.COMMA);
					this.state = 2702;
					this.expression();
					}
					}
				}
				this.state = 2707;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 346, this._ctx);
			}
			this.state = 2708;
			this.tableAlias();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext {
		let _localctx: FunctionTableSubqueryArgumentContext = new FunctionTableSubqueryArgumentContext(this._ctx, this.state);
		this.enterRule(_localctx, 226, SparkSqlParser.RULE_functionTableSubqueryArgument);
		let _la: number;
		try {
			this.state = 2729;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 350, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2710;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 2711;
				this.tableName();
				this.state = 2713;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
					{
					this.state = 2712;
					this.tableArgumentPartitioning();
					}
				}

				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2715;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 2716;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2717;
				this.tableName();
				this.state = 2718;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2720;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
					{
					this.state = 2719;
					this.tableArgumentPartitioning();
					}
				}

				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2722;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 2723;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2724;
				this.query();
				this.state = 2725;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2727;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
					{
					this.state = 2726;
					this.tableArgumentPartitioning();
					}
				}

				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public tableArgumentPartitioning(): TableArgumentPartitioningContext {
		let _localctx: TableArgumentPartitioningContext = new TableArgumentPartitioningContext(this._ctx, this.state);
		this.enterRule(_localctx, 228, SparkSqlParser.RULE_tableArgumentPartitioning);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2750;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_WITH:
				{
				{
				this.state = 2731;
				this.match(SparkSqlParser.KW_WITH);
				this.state = 2732;
				this.match(SparkSqlParser.KW_SINGLE);
				this.state = 2733;
				this.match(SparkSqlParser.KW_PARTITION);
				}
				}
				break;
			case SparkSqlParser.KW_DISTRIBUTE:
			case SparkSqlParser.KW_PARTITION:
				{
				{
				this.state = 2734;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2735;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2748;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 352, this._ctx) ) {
				case 1:
					{
					{
					{
					this.state = 2736;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2737;
					_localctx._expression = this.expression();
					_localctx._partition.push(_localctx._expression);
					this.state = 2742;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2738;
						this.match(SparkSqlParser.COMMA);
						this.state = 2739;
						_localctx._expression = this.expression();
						_localctx._partition.push(_localctx._expression);
						}
						}
						this.state = 2744;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 2745;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					}
					break;

				case 2:
					{
					this.state = 2747;
					_localctx._expression = this.expression();
					_localctx._partition.push(_localctx._expression);
					}
					break;
				}
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			this.state = 2768;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT) {
				{
				this.state = 2752;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2753;
				this.match(SparkSqlParser.KW_BY);
				{
				this.state = 2766;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 355, this._ctx) ) {
				case 1:
					{
					{
					this.state = 2754;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2755;
					this.sortItem();
					this.state = 2760;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2756;
						this.match(SparkSqlParser.COMMA);
						this.state = 2757;
						this.sortItem();
						}
						}
						this.state = 2762;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 2763;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					break;

				case 2:
					{
					this.state = 2765;
					this.sortItem();
					}
					break;
				}
				}
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext {
		let _localctx: FunctionTableNamedArgumentExpressionContext = new FunctionTableNamedArgumentExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 230, SparkSqlParser.RULE_functionTableNamedArgumentExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2770;
			_localctx._key = this.identifier();
			this.state = 2771;
			this.match(SparkSqlParser.FAT_ARROW);
			this.state = 2772;
			_localctx._table = this.functionTableSubqueryArgument();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext {
		let _localctx: FunctionTableReferenceArgumentContext = new FunctionTableReferenceArgumentContext(this._ctx, this.state);
		this.enterRule(_localctx, 232, SparkSqlParser.RULE_functionTableReferenceArgument);
		try {
			this.state = 2776;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 357, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2774;
				this.functionTableSubqueryArgument();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2775;
				this.functionTableNamedArgumentExpression();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionTableArgument(): FunctionTableArgumentContext {
		let _localctx: FunctionTableArgumentContext = new FunctionTableArgumentContext(this._ctx, this.state);
		this.enterRule(_localctx, 234, SparkSqlParser.RULE_functionTableArgument);
		try {
			this.state = 2780;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 358, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2778;
				this.functionTableReferenceArgument();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2779;
				this.functionArgument();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionTable(): FunctionTableContext {
		let _localctx: FunctionTableContext = new FunctionTableContext(this._ctx, this.state);
		this.enterRule(_localctx, 236, SparkSqlParser.RULE_functionTable);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2782;
			this.functionName();
			this.state = 2783;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2792;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
				{
				this.state = 2784;
				this.functionTableArgument();
				this.state = 2789;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2785;
					this.match(SparkSqlParser.COMMA);
					this.state = 2786;
					this.functionTableArgument();
					}
					}
					this.state = 2791;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
			}

			this.state = 2794;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2795;
			this.tableAlias();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public tableAlias(): TableAliasContext {
		let _localctx: TableAliasContext = new TableAliasContext(this._ctx, this.state);
		this.enterRule(_localctx, 238, SparkSqlParser.RULE_tableAlias);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2804;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 363, this._ctx) ) {
			case 1:
				{
				this.state = 2798;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 361, this._ctx) ) {
				case 1:
					{
					this.state = 2797;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2800;
				this.strictIdentifier();
				this.state = 2802;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 362, this._ctx) ) {
				case 1:
					{
					this.state = 2801;
					this.identifierList();
					}
					break;
				}
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public rowFormat(): RowFormatContext {
		let _localctx: RowFormatContext = new RowFormatContext(this._ctx, this.state);
		this.enterRule(_localctx, 240, SparkSqlParser.RULE_rowFormat);
		try {
			this.state = 2855;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 371, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2806;
				this.match(SparkSqlParser.KW_ROW);
				this.state = 2807;
				this.match(SparkSqlParser.KW_FORMAT);
				this.state = 2808;
				this.match(SparkSqlParser.KW_SERDE);
				this.state = 2809;
				_localctx._name = this.stringLit();
				this.state = 2813;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 364, this._ctx) ) {
				case 1:
					{
					this.state = 2810;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 2811;
					this.match(SparkSqlParser.KW_SERDEPROPERTIES);
					this.state = 2812;
					_localctx._props = this.propertyList();
					}
					break;
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2815;
				this.match(SparkSqlParser.KW_ROW);
				this.state = 2816;
				this.match(SparkSqlParser.KW_FORMAT);
				this.state = 2817;
				this.match(SparkSqlParser.KW_DELIMITED);
				this.state = 2827;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 366, this._ctx) ) {
				case 1:
					{
					this.state = 2818;
					this.match(SparkSqlParser.KW_FIELDS);
					this.state = 2819;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2820;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2821;
					_localctx._fieldsTerminatedBy = this.stringLit();
					this.state = 2825;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 365, this._ctx) ) {
					case 1:
						{
						this.state = 2822;
						this.match(SparkSqlParser.KW_ESCAPED);
						this.state = 2823;
						this.match(SparkSqlParser.KW_BY);
						this.state = 2824;
						_localctx._escapedBy = this.stringLit();
						}
						break;
					}
					}
					break;
				}
				this.state = 2834;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 367, this._ctx) ) {
				case 1:
					{
					this.state = 2829;
					this.match(SparkSqlParser.KW_COLLECTION);
					this.state = 2830;
					this.match(SparkSqlParser.KW_ITEMS);
					this.state = 2831;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2832;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2833;
					_localctx._collectionItemsTerminatedBy = this.stringLit();
					}
					break;
				}
				this.state = 2841;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 368, this._ctx) ) {
				case 1:
					{
					this.state = 2836;
					this.match(SparkSqlParser.KW_MAP);
					this.state = 2837;
					this.match(SparkSqlParser.KW_KEYS);
					this.state = 2838;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2839;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2840;
					_localctx._keysTerminatedBy = this.stringLit();
					}
					break;
				}
				this.state = 2847;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 369, this._ctx) ) {
				case 1:
					{
					this.state = 2843;
					this.match(SparkSqlParser.KW_LINES);
					this.state = 2844;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2845;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2846;
					_localctx._linesSeparatedBy = this.stringLit();
					}
					break;
				}
				this.state = 2853;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 370, this._ctx) ) {
				case 1:
					{
					this.state = 2849;
					this.match(SparkSqlParser.KW_NULL);
					this.state = 2850;
					this.match(SparkSqlParser.KW_DEFINED);
					this.state = 2851;
					this.match(SparkSqlParser.KW_AS);
					this.state = 2852;
					_localctx._nullDefinedAs = this.stringLit();
					}
					break;
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public multipartIdentifierList(): MultipartIdentifierListContext {
		let _localctx: MultipartIdentifierListContext = new MultipartIdentifierListContext(this._ctx, this.state);
		this.enterRule(_localctx, 242, SparkSqlParser.RULE_multipartIdentifierList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2857;
			this.multipartIdentifier();
			this.state = 2862;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2858;
				this.match(SparkSqlParser.COMMA);
				this.state = 2859;
				this.multipartIdentifier();
				}
				}
				this.state = 2864;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public multipartIdentifier(): MultipartIdentifierContext {
		let _localctx: MultipartIdentifierContext = new MultipartIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 244, SparkSqlParser.RULE_multipartIdentifier);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2865;
			_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
			_localctx._parts.push(_localctx._errorCapturingIdentifier);
			this.state = 2870;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 373, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2866;
					this.match(SparkSqlParser.DOT);
					this.state = 2867;
					_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
					_localctx._parts.push(_localctx._errorCapturingIdentifier);
					}
					}
				}
				this.state = 2872;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 373, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext {
		let _localctx: MultipartIdentifierPropertyListContext = new MultipartIdentifierPropertyListContext(this._ctx, this.state);
		this.enterRule(_localctx, 246, SparkSqlParser.RULE_multipartIdentifierPropertyList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2873;
			this.multipartIdentifierProperty();
			this.state = 2878;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2874;
				this.match(SparkSqlParser.COMMA);
				this.state = 2875;
				this.multipartIdentifierProperty();
				}
				}
				this.state = 2880;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public multipartIdentifierProperty(): MultipartIdentifierPropertyContext {
		let _localctx: MultipartIdentifierPropertyContext = new MultipartIdentifierPropertyContext(this._ctx, this.state);
		this.enterRule(_localctx, 248, SparkSqlParser.RULE_multipartIdentifierProperty);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2881;
			this.multipartIdentifier();
			this.state = 2884;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_OPTIONS) {
				{
				this.state = 2882;
				this.match(SparkSqlParser.KW_OPTIONS);
				this.state = 2883;
				_localctx._options = this.propertyList();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public tableIdentifier(): TableIdentifierContext {
		let _localctx: TableIdentifierContext = new TableIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 250, SparkSqlParser.RULE_tableIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2889;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 376, this._ctx) ) {
			case 1:
				{
				this.state = 2886;
				_localctx._db = this.errorCapturingIdentifier();
				this.state = 2887;
				this.match(SparkSqlParser.DOT);
				}
				break;
			}
			this.state = 2891;
			_localctx._table = this.errorCapturingIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public viewIdentifier(): ViewIdentifierContext {
		let _localctx: ViewIdentifierContext = new ViewIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 252, SparkSqlParser.RULE_viewIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2896;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 377, this._ctx) ) {
			case 1:
				{
				this.state = 2893;
				_localctx._db = this.errorCapturingIdentifier();
				this.state = 2894;
				this.match(SparkSqlParser.DOT);
				}
				break;
			}
			this.state = 2898;
			_localctx._view = this.errorCapturingIdentifier();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public namedExpression(): NamedExpressionContext {
		let _localctx: NamedExpressionContext = new NamedExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 254, SparkSqlParser.RULE_namedExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2902;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 378, this._ctx) ) {
			case 1:
				{
				this.state = 2900;
				this.columnName();
				}
				break;

			case 2:
				{
				this.state = 2901;
				this.expression();
				}
				break;
			}
			this.state = 2911;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 381, this._ctx) ) {
			case 1:
				{
				this.state = 2905;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 379, this._ctx) ) {
				case 1:
					{
					this.state = 2904;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2909;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_ADD:
				case SparkSqlParser.KW_AFTER:
				case SparkSqlParser.KW_ALL:
				case SparkSqlParser.KW_ALTER:
				case SparkSqlParser.KW_ALWAYS:
				case SparkSqlParser.KW_ANALYZE:
				case SparkSqlParser.KW_AND:
				case SparkSqlParser.KW_ANTI:
				case SparkSqlParser.KW_ANY:
				case SparkSqlParser.KW_ANY_VALUE:
				case SparkSqlParser.KW_ARCHIVE:
				case SparkSqlParser.KW_ARRAY:
				case SparkSqlParser.KW_AS:
				case SparkSqlParser.KW_ASC:
				case SparkSqlParser.KW_AT:
				case SparkSqlParser.KW_AUTHORIZATION:
				case SparkSqlParser.KW_BETWEEN:
				case SparkSqlParser.KW_BIGINT:
				case SparkSqlParser.KW_BINARY:
				case SparkSqlParser.KW_BOOLEAN:
				case SparkSqlParser.KW_BOTH:
				case SparkSqlParser.KW_BUCKET:
				case SparkSqlParser.KW_BUCKETS:
				case SparkSqlParser.KW_BY:
				case SparkSqlParser.KW_BYTE:
				case SparkSqlParser.KW_CACHE:
				case SparkSqlParser.KW_CASCADE:
				case SparkSqlParser.KW_CASE:
				case SparkSqlParser.KW_CAST:
				case SparkSqlParser.KW_CATALOG:
				case SparkSqlParser.KW_CATALOGS:
				case SparkSqlParser.KW_CHANGE:
				case SparkSqlParser.KW_CHAR:
				case SparkSqlParser.KW_CHARACTER:
				case SparkSqlParser.KW_CHECK:
				case SparkSqlParser.KW_CLEAR:
				case SparkSqlParser.KW_CLUSTER:
				case SparkSqlParser.KW_CLUSTERED:
				case SparkSqlParser.KW_CODEGEN:
				case SparkSqlParser.KW_COLLATE:
				case SparkSqlParser.KW_COLLECTION:
				case SparkSqlParser.KW_COLUMN:
				case SparkSqlParser.KW_COLUMNS:
				case SparkSqlParser.KW_COMMENT:
				case SparkSqlParser.KW_COMMIT:
				case SparkSqlParser.KW_COMPACT:
				case SparkSqlParser.KW_COMPACTIONS:
				case SparkSqlParser.KW_COMPUTE:
				case SparkSqlParser.KW_CONCATENATE:
				case SparkSqlParser.KW_CONSTRAINT:
				case SparkSqlParser.KW_COST:
				case SparkSqlParser.KW_CREATE:
				case SparkSqlParser.KW_CROSS:
				case SparkSqlParser.KW_CUBE:
				case SparkSqlParser.KW_CURRENT:
				case SparkSqlParser.KW_CURRENT_DATE:
				case SparkSqlParser.KW_CURRENT_TIME:
				case SparkSqlParser.KW_CURRENT_TIMESTAMP:
				case SparkSqlParser.KW_CURRENT_USER:
				case SparkSqlParser.KW_DAY:
				case SparkSqlParser.KW_DAYS:
				case SparkSqlParser.KW_DAYOFYEAR:
				case SparkSqlParser.KW_DATA:
				case SparkSqlParser.KW_DATE:
				case SparkSqlParser.KW_DATABASE:
				case SparkSqlParser.KW_DATABASES:
				case SparkSqlParser.KW_DATEADD:
				case SparkSqlParser.KW_DATE_ADD:
				case SparkSqlParser.KW_DATEDIFF:
				case SparkSqlParser.KW_DATE_DIFF:
				case SparkSqlParser.KW_DBPROPERTIES:
				case SparkSqlParser.KW_DEC:
				case SparkSqlParser.KW_DECIMAL:
				case SparkSqlParser.KW_DECLARE:
				case SparkSqlParser.KW_DEFAULT:
				case SparkSqlParser.KW_DEFINED:
				case SparkSqlParser.KW_DELETE:
				case SparkSqlParser.KW_DELIMITED:
				case SparkSqlParser.KW_DESC:
				case SparkSqlParser.KW_DESCRIBE:
				case SparkSqlParser.KW_DFS:
				case SparkSqlParser.KW_DIRECTORIES:
				case SparkSqlParser.KW_DIRECTORY:
				case SparkSqlParser.KW_DISTINCT:
				case SparkSqlParser.KW_DISTRIBUTE:
				case SparkSqlParser.KW_DIV:
				case SparkSqlParser.KW_DOUBLE:
				case SparkSqlParser.KW_DROP:
				case SparkSqlParser.KW_ELSE:
				case SparkSqlParser.KW_END:
				case SparkSqlParser.KW_ESCAPE:
				case SparkSqlParser.KW_ESCAPED:
				case SparkSqlParser.KW_EXCEPT:
				case SparkSqlParser.KW_EXCHANGE:
				case SparkSqlParser.KW_EXCLUDE:
				case SparkSqlParser.KW_EXISTS:
				case SparkSqlParser.KW_EXPLAIN:
				case SparkSqlParser.KW_EXPORT:
				case SparkSqlParser.KW_EXTENDED:
				case SparkSqlParser.KW_EXTERNAL:
				case SparkSqlParser.KW_EXTRACT:
				case SparkSqlParser.KW_FALSE:
				case SparkSqlParser.KW_FETCH:
				case SparkSqlParser.KW_FIELDS:
				case SparkSqlParser.KW_FILTER:
				case SparkSqlParser.KW_FILEFORMAT:
				case SparkSqlParser.KW_FIRST:
				case SparkSqlParser.KW_FLOAT:
				case SparkSqlParser.KW_FOLLOWING:
				case SparkSqlParser.KW_FOR:
				case SparkSqlParser.KW_FOREIGN:
				case SparkSqlParser.KW_FORMAT:
				case SparkSqlParser.KW_FORMATTED:
				case SparkSqlParser.KW_FROM:
				case SparkSqlParser.KW_FULL:
				case SparkSqlParser.KW_FUNCTION:
				case SparkSqlParser.KW_FUNCTIONS:
				case SparkSqlParser.KW_GENERATED:
				case SparkSqlParser.KW_GLOBAL:
				case SparkSqlParser.KW_GRANT:
				case SparkSqlParser.KW_GROUP:
				case SparkSqlParser.KW_GROUPING:
				case SparkSqlParser.KW_HAVING:
				case SparkSqlParser.KW_BINARY_HEX:
				case SparkSqlParser.KW_HOUR:
				case SparkSqlParser.KW_HOURS:
				case SparkSqlParser.KW_IDENTIFIER:
				case SparkSqlParser.KW_IF:
				case SparkSqlParser.KW_IGNORE:
				case SparkSqlParser.KW_IMPORT:
				case SparkSqlParser.KW_IN:
				case SparkSqlParser.KW_INCLUDE:
				case SparkSqlParser.KW_INDEX:
				case SparkSqlParser.KW_INDEXES:
				case SparkSqlParser.KW_INNER:
				case SparkSqlParser.KW_INPATH:
				case SparkSqlParser.KW_INPUTFORMAT:
				case SparkSqlParser.KW_INSERT:
				case SparkSqlParser.KW_INTERSECT:
				case SparkSqlParser.KW_INTERVAL:
				case SparkSqlParser.KW_INT:
				case SparkSqlParser.KW_INTEGER:
				case SparkSqlParser.KW_INTO:
				case SparkSqlParser.KW_IS:
				case SparkSqlParser.KW_ITEMS:
				case SparkSqlParser.KW_JOIN:
				case SparkSqlParser.KW_KEYS:
				case SparkSqlParser.KW_LAST:
				case SparkSqlParser.KW_LATERAL:
				case SparkSqlParser.KW_LAZY:
				case SparkSqlParser.KW_LEADING:
				case SparkSqlParser.KW_LEFT:
				case SparkSqlParser.KW_LIKE:
				case SparkSqlParser.KW_ILIKE:
				case SparkSqlParser.KW_LIMIT:
				case SparkSqlParser.KW_LINES:
				case SparkSqlParser.KW_LIST:
				case SparkSqlParser.KW_LOAD:
				case SparkSqlParser.KW_LOCAL:
				case SparkSqlParser.KW_LOCATION:
				case SparkSqlParser.KW_LOCK:
				case SparkSqlParser.KW_LOCKS:
				case SparkSqlParser.KW_LOGICAL:
				case SparkSqlParser.KW_LONG:
				case SparkSqlParser.KW_MACRO:
				case SparkSqlParser.KW_MAP:
				case SparkSqlParser.KW_MATCHED:
				case SparkSqlParser.KW_MERGE:
				case SparkSqlParser.KW_MICROSECOND:
				case SparkSqlParser.KW_MICROSECONDS:
				case SparkSqlParser.KW_MILLISECOND:
				case SparkSqlParser.KW_MILLISECONDS:
				case SparkSqlParser.KW_MINUTE:
				case SparkSqlParser.KW_MINUTES:
				case SparkSqlParser.KW_MONTH:
				case SparkSqlParser.KW_MONTHS:
				case SparkSqlParser.KW_MSCK:
				case SparkSqlParser.KW_NAME:
				case SparkSqlParser.KW_NAMESPACE:
				case SparkSqlParser.KW_NAMESPACES:
				case SparkSqlParser.KW_NANOSECOND:
				case SparkSqlParser.KW_NANOSECONDS:
				case SparkSqlParser.KW_NATURAL:
				case SparkSqlParser.KW_NO:
				case SparkSqlParser.KW_NOT:
				case SparkSqlParser.KW_NULL:
				case SparkSqlParser.KW_NULLS:
				case SparkSqlParser.KW_NUMERIC:
				case SparkSqlParser.KW_OF:
				case SparkSqlParser.KW_OFFSET:
				case SparkSqlParser.KW_ON:
				case SparkSqlParser.KW_ONLY:
				case SparkSqlParser.KW_OPTION:
				case SparkSqlParser.KW_OPTIONS:
				case SparkSqlParser.KW_OR:
				case SparkSqlParser.KW_ORDER:
				case SparkSqlParser.KW_OUT:
				case SparkSqlParser.KW_OUTER:
				case SparkSqlParser.KW_OUTPUTFORMAT:
				case SparkSqlParser.KW_OVER:
				case SparkSqlParser.KW_OVERLAPS:
				case SparkSqlParser.KW_OVERLAY:
				case SparkSqlParser.KW_OVERWRITE:
				case SparkSqlParser.KW_PARTITION:
				case SparkSqlParser.KW_PARTITIONED:
				case SparkSqlParser.KW_PARTITIONS:
				case SparkSqlParser.KW_PERCENTILE_CONT:
				case SparkSqlParser.KW_PERCENTILE_DISC:
				case SparkSqlParser.KW_PERCENTLIT:
				case SparkSqlParser.KW_PIVOT:
				case SparkSqlParser.KW_PLACING:
				case SparkSqlParser.KW_POSITION:
				case SparkSqlParser.KW_PRECEDING:
				case SparkSqlParser.KW_PRIMARY:
				case SparkSqlParser.KW_PRINCIPALS:
				case SparkSqlParser.KW_PROPERTIES:
				case SparkSqlParser.KW_PURGE:
				case SparkSqlParser.KW_QUARTER:
				case SparkSqlParser.KW_QUERY:
				case SparkSqlParser.KW_RANGE:
				case SparkSqlParser.KW_REAL:
				case SparkSqlParser.KW_RECORDREADER:
				case SparkSqlParser.KW_RECORDWRITER:
				case SparkSqlParser.KW_RECOVER:
				case SparkSqlParser.KW_REDUCE:
				case SparkSqlParser.KW_REFERENCES:
				case SparkSqlParser.KW_REFRESH:
				case SparkSqlParser.KW_RENAME:
				case SparkSqlParser.KW_REPAIR:
				case SparkSqlParser.KW_REPEATABLE:
				case SparkSqlParser.KW_REPLACE:
				case SparkSqlParser.KW_RESET:
				case SparkSqlParser.KW_RESPECT:
				case SparkSqlParser.KW_RESTRICT:
				case SparkSqlParser.KW_REVOKE:
				case SparkSqlParser.KW_RIGHT:
				case SparkSqlParser.KW_RLIKE:
				case SparkSqlParser.KW_REGEXP:
				case SparkSqlParser.KW_ROLE:
				case SparkSqlParser.KW_ROLES:
				case SparkSqlParser.KW_ROLLBACK:
				case SparkSqlParser.KW_ROLLUP:
				case SparkSqlParser.KW_ROW:
				case SparkSqlParser.KW_ROWS:
				case SparkSqlParser.KW_SECOND:
				case SparkSqlParser.KW_SECONDS:
				case SparkSqlParser.KW_SCHEMA:
				case SparkSqlParser.KW_SCHEMAS:
				case SparkSqlParser.KW_SELECT:
				case SparkSqlParser.KW_SEMI:
				case SparkSqlParser.KW_SEPARATED:
				case SparkSqlParser.KW_SERDE:
				case SparkSqlParser.KW_SERDEPROPERTIES:
				case SparkSqlParser.KW_SESSION_USER:
				case SparkSqlParser.KW_SET:
				case SparkSqlParser.KW_MINUS:
				case SparkSqlParser.KW_SETS:
				case SparkSqlParser.KW_SHORT:
				case SparkSqlParser.KW_SHOW:
				case SparkSqlParser.KW_SINGLE:
				case SparkSqlParser.KW_SKEWED:
				case SparkSqlParser.KW_SMALLINT:
				case SparkSqlParser.KW_SOME:
				case SparkSqlParser.KW_SORT:
				case SparkSqlParser.KW_SORTED:
				case SparkSqlParser.KW_SOURCE:
				case SparkSqlParser.KW_START:
				case SparkSqlParser.KW_STATISTICS:
				case SparkSqlParser.KW_STORED:
				case SparkSqlParser.KW_STRATIFY:
				case SparkSqlParser.KW_STRING:
				case SparkSqlParser.KW_STRUCT:
				case SparkSqlParser.KW_SUBSTR:
				case SparkSqlParser.KW_SUBSTRING:
				case SparkSqlParser.KW_SYNC:
				case SparkSqlParser.KW_SYSTEM:
				case SparkSqlParser.KW_SYSTEM_TIME:
				case SparkSqlParser.KW_SYSTEM_VERSION:
				case SparkSqlParser.KW_TABLE:
				case SparkSqlParser.KW_TABLES:
				case SparkSqlParser.KW_TABLESAMPLE:
				case SparkSqlParser.KW_TARGET:
				case SparkSqlParser.KW_TBLPROPERTIES:
				case SparkSqlParser.KW_TEMPORARY:
				case SparkSqlParser.KW_TERMINATED:
				case SparkSqlParser.KW_THEN:
				case SparkSqlParser.KW_TIME:
				case SparkSqlParser.KW_TIMEDIFF:
				case SparkSqlParser.KW_TIMESTAMP:
				case SparkSqlParser.KW_TIMESTAMP_LTZ:
				case SparkSqlParser.KW_TIMESTAMP_NTZ:
				case SparkSqlParser.KW_TIMESTAMPADD:
				case SparkSqlParser.KW_TIMESTAMPDIFF:
				case SparkSqlParser.KW_TINYINT:
				case SparkSqlParser.KW_TO:
				case SparkSqlParser.KW_TOUCH:
				case SparkSqlParser.KW_TRAILING:
				case SparkSqlParser.KW_TRANSACTION:
				case SparkSqlParser.KW_TRANSACTIONS:
				case SparkSqlParser.KW_TRANSFORM:
				case SparkSqlParser.KW_TRIM:
				case SparkSqlParser.KW_TRUE:
				case SparkSqlParser.KW_TRUNCATE:
				case SparkSqlParser.KW_TRY_CAST:
				case SparkSqlParser.KW_TYPE:
				case SparkSqlParser.KW_UNARCHIVE:
				case SparkSqlParser.KW_UNBOUNDED:
				case SparkSqlParser.KW_UNCACHE:
				case SparkSqlParser.KW_UNION:
				case SparkSqlParser.KW_UNIQUE:
				case SparkSqlParser.KW_UNKNOWN:
				case SparkSqlParser.KW_UNLOCK:
				case SparkSqlParser.KW_UNPIVOT:
				case SparkSqlParser.KW_UNSET:
				case SparkSqlParser.KW_UPDATE:
				case SparkSqlParser.KW_USE:
				case SparkSqlParser.KW_USER:
				case SparkSqlParser.KW_USING:
				case SparkSqlParser.KW_VALUES:
				case SparkSqlParser.KW_VARCHAR:
				case SparkSqlParser.KW_VAR:
				case SparkSqlParser.KW_VARIABLE:
				case SparkSqlParser.KW_VERSION:
				case SparkSqlParser.KW_VIEW:
				case SparkSqlParser.KW_VIEWS:
				case SparkSqlParser.KW_VOID:
				case SparkSqlParser.KW_WEEK:
				case SparkSqlParser.KW_WEEKS:
				case SparkSqlParser.KW_WHEN:
				case SparkSqlParser.KW_WHERE:
				case SparkSqlParser.KW_WINDOW:
				case SparkSqlParser.KW_WITH:
				case SparkSqlParser.KW_WITHIN:
				case SparkSqlParser.KW_YEAR:
				case SparkSqlParser.KW_YEARS:
				case SparkSqlParser.KW_ZONE:
				case SparkSqlParser.DOUBLEQUOTED_STRING:
				case SparkSqlParser.IDENTIFIER:
				case SparkSqlParser.BACKQUOTED_IDENTIFIER:
					{
					this.state = 2907;
					_localctx._name = this.errorCapturingIdentifier();
					}
					break;
				case SparkSqlParser.LEFT_PAREN:
					{
					this.state = 2908;
					this.identifierList();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public namedExpressionSeq(): NamedExpressionSeqContext {
		let _localctx: NamedExpressionSeqContext = new NamedExpressionSeqContext(this._ctx, this.state);
		this.enterRule(_localctx, 256, SparkSqlParser.RULE_namedExpressionSeq);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2913;
			this.namedExpression();
			this.state = 2918;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 382, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2914;
					this.match(SparkSqlParser.COMMA);
					this.state = 2915;
					this.namedExpression();
					}
					}
				}
				this.state = 2920;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 382, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public partitionFieldList(): PartitionFieldListContext {
		let _localctx: PartitionFieldListContext = new PartitionFieldListContext(this._ctx, this.state);
		this.enterRule(_localctx, 258, SparkSqlParser.RULE_partitionFieldList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2921;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2922;
			_localctx._partitionField = this.partitionField();
			_localctx._fields.push(_localctx._partitionField);
			this.state = 2927;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2923;
				this.match(SparkSqlParser.COMMA);
				this.state = 2924;
				_localctx._partitionField = this.partitionField();
				_localctx._fields.push(_localctx._partitionField);
				}
				}
				this.state = 2929;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2930;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public partitionField(): PartitionFieldContext {
		let _localctx: PartitionFieldContext = new PartitionFieldContext(this._ctx, this.state);
		this.enterRule(_localctx, 260, SparkSqlParser.RULE_partitionField);
		try {
			this.state = 2934;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 384, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2932;
				this.transform();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2933;
				this.colType();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public transform(): TransformContext {
		let _localctx: TransformContext = new TransformContext(this._ctx, this.state);
		this.enterRule(_localctx, 262, SparkSqlParser.RULE_transform);
		let _la: number;
		try {
			this.state = 2949;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 386, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2936;
				this.qualifiedName();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2937;
				_localctx._transformName = this.identifier();
				this.state = 2938;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2939;
				this.transformArgument();
				this.state = 2944;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2940;
					this.match(SparkSqlParser.COMMA);
					this.state = 2941;
					this.transformArgument();
					}
					}
					this.state = 2946;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2947;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public transformArgument(): TransformArgumentContext {
		let _localctx: TransformArgumentContext = new TransformArgumentContext(this._ctx, this.state);
		this.enterRule(_localctx, 264, SparkSqlParser.RULE_transformArgument);
		try {
			this.state = 2953;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 387, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2951;
				this.qualifiedName();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2952;
				this.constant();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expression(): ExpressionContext {
		let _localctx: ExpressionContext = new ExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 266, SparkSqlParser.RULE_expression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2955;
			this.booleanExpression(0);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public namedArgumentExpression(): NamedArgumentExpressionContext {
		let _localctx: NamedArgumentExpressionContext = new NamedArgumentExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 268, SparkSqlParser.RULE_namedArgumentExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2957;
			_localctx._key = this.identifier();
			this.state = 2958;
			this.match(SparkSqlParser.FAT_ARROW);
			this.state = 2959;
			_localctx._value = this.expression();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionArgument(): FunctionArgumentContext {
		let _localctx: FunctionArgumentContext = new FunctionArgumentContext(this._ctx, this.state);
		this.enterRule(_localctx, 270, SparkSqlParser.RULE_functionArgument);
		try {
			this.state = 2963;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 388, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2961;
				this.expression();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2962;
				this.namedArgumentExpression();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public expressionSeq(): ExpressionSeqContext {
		let _localctx: ExpressionSeqContext = new ExpressionSeqContext(this._ctx, this.state);
		this.enterRule(_localctx, 272, SparkSqlParser.RULE_expressionSeq);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2965;
			this.expression();
			this.state = 2970;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2966;
				this.match(SparkSqlParser.COMMA);
				this.state = 2967;
				this.expression();
				}
				}
				this.state = 2972;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public booleanExpression(): BooleanExpressionContext;
	public booleanExpression(_p: number): BooleanExpressionContext;
	// @RuleVersion(0)
	public booleanExpression(_p?: number): BooleanExpressionContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: BooleanExpressionContext = new BooleanExpressionContext(this._ctx, _parentState);
		let _prevctx: BooleanExpressionContext = _localctx;
		let _startState: number = 274;
		this.enterRecursionRule(_localctx, 274, SparkSqlParser.RULE_booleanExpression, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2985;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 391, this._ctx) ) {
			case 1:
				{
				this.state = 2974;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_NOT || _la === SparkSqlParser.NOT)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 2975;
				this.booleanExpression(5);
				}
				break;

			case 2:
				{
				this.state = 2976;
				this.match(SparkSqlParser.KW_EXISTS);
				this.state = 2977;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2978;
				this.query();
				this.state = 2979;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				{
				this.state = 2981;
				this.valueExpression(0);
				this.state = 2983;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 390, this._ctx) ) {
				case 1:
					{
					this.state = 2982;
					this.predicate();
					}
					break;
				}
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 2995;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 393, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 2993;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 392, this._ctx) ) {
					case 1:
						{
						_localctx = new BooleanExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_booleanExpression);
						this.state = 2987;
						if (!(this.precpred(this._ctx, 2))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
						}
						this.state = 2988;
						_localctx._operator = this.match(SparkSqlParser.KW_AND);
						this.state = 2989;
						_localctx._right = this.booleanExpression(3);
						}
						break;

					case 2:
						{
						_localctx = new BooleanExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_booleanExpression);
						this.state = 2990;
						if (!(this.precpred(this._ctx, 1))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
						}
						this.state = 2991;
						_localctx._operator = this.match(SparkSqlParser.KW_OR);
						this.state = 2992;
						_localctx._right = this.booleanExpression(2);
						}
						break;
					}
					}
				}
				this.state = 2997;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 393, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public predicate(): PredicateContext {
		let _localctx: PredicateContext = new PredicateContext(this._ctx, this.state);
		this.enterRule(_localctx, 276, SparkSqlParser.RULE_predicate);
		let _la: number;
		try {
			this.state = 3080;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 407, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2999;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 2998;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3001;
				_localctx._kind = this.match(SparkSqlParser.KW_BETWEEN);
				this.state = 3002;
				_localctx._lower = this.valueExpression(0);
				this.state = 3003;
				this.match(SparkSqlParser.KW_AND);
				this.state = 3004;
				_localctx._upper = this.valueExpression(0);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3007;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3006;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3009;
				_localctx._kind = this.match(SparkSqlParser.KW_IN);
				this.state = 3010;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3011;
				this.expression();
				this.state = 3016;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 3012;
					this.match(SparkSqlParser.COMMA);
					this.state = 3013;
					this.expression();
					}
					}
					this.state = 3018;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 3019;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3022;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3021;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3024;
				_localctx._kind = this.match(SparkSqlParser.KW_IN);
				this.state = 3025;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3026;
				this.query();
				this.state = 3027;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3030;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3029;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3032;
				_localctx._kind = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_RLIKE || _la === SparkSqlParser.KW_REGEXP)) {
					_localctx._kind = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3033;
				_localctx._pattern = this.valueExpression(0);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3035;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3034;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3037;
				_localctx._kind = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.KW_ILIKE)) {
					_localctx._kind = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3038;
				_localctx._quantifier = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_ANY || _la === SparkSqlParser.KW_SOME)) {
					_localctx._quantifier = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3052;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 401, this._ctx) ) {
				case 1:
					{
					this.state = 3039;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3040;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;

				case 2:
					{
					this.state = 3041;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3042;
					this.expression();
					this.state = 3047;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3043;
						this.match(SparkSqlParser.COMMA);
						this.state = 3044;
						this.expression();
						}
						}
						this.state = 3049;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 3050;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3055;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3054;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3057;
				_localctx._kind = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_LIKE || _la === SparkSqlParser.KW_ILIKE)) {
					_localctx._kind = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3058;
				_localctx._pattern = this.valueExpression(0);
				this.state = 3061;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 403, this._ctx) ) {
				case 1:
					{
					this.state = 3059;
					this.match(SparkSqlParser.KW_ESCAPE);
					this.state = 3060;
					_localctx._escapeChar = this.stringLit();
					}
					break;
				}
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 3063;
				this.match(SparkSqlParser.KW_IS);
				this.state = 3065;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3064;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3067;
				_localctx._kind = this.match(SparkSqlParser.KW_NULL);
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 3068;
				this.match(SparkSqlParser.KW_IS);
				this.state = 3070;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3069;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3072;
				_localctx._kind = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_FALSE || _la === SparkSqlParser.KW_TRUE || _la === SparkSqlParser.KW_UNKNOWN)) {
					_localctx._kind = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 3073;
				this.match(SparkSqlParser.KW_IS);
				this.state = 3075;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3074;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3077;
				_localctx._kind = this.match(SparkSqlParser.KW_DISTINCT);
				this.state = 3078;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3079;
				_localctx._right = this.valueExpression(0);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public valueExpression(): ValueExpressionContext;
	public valueExpression(_p: number): ValueExpressionContext;
	// @RuleVersion(0)
	public valueExpression(_p?: number): ValueExpressionContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: ValueExpressionContext = new ValueExpressionContext(this._ctx, _parentState);
		let _prevctx: ValueExpressionContext = _localctx;
		let _startState: number = 278;
		this.enterRecursionRule(_localctx, 278, SparkSqlParser.RULE_valueExpression, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3086;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 408, this._ctx) ) {
			case 1:
				{
				this.state = 3083;
				this.primaryExpression(0);
				}
				break;

			case 2:
				{
				this.state = 3084;
				_localctx._operator = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(((((_la - 354)) & ~0x1F) === 0 && ((1 << (_la - 354)) & ((1 << (SparkSqlParser.PLUS - 354)) | (1 << (SparkSqlParser.MINUS - 354)) | (1 << (SparkSqlParser.TILDE - 354)))) !== 0))) {
					_localctx._operator = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3085;
				this.valueExpression(7);
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 3109;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 410, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 3107;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 409, this._ctx) ) {
					case 1:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3088;
						if (!(this.precpred(this._ctx, 6))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
						}
						this.state = 3089;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_DIV || ((((_la - 356)) & ~0x1F) === 0 && ((1 << (_la - 356)) & ((1 << (SparkSqlParser.ASTERISK - 356)) | (1 << (SparkSqlParser.SLASH - 356)) | (1 << (SparkSqlParser.PERCENT - 356)))) !== 0))) {
							_localctx._operator = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 3090;
						_localctx._right = this.valueExpression(7);
						}
						break;

					case 2:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3091;
						if (!(this.precpred(this._ctx, 5))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
						}
						this.state = 3092;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(((((_la - 354)) & ~0x1F) === 0 && ((1 << (_la - 354)) & ((1 << (SparkSqlParser.PLUS - 354)) | (1 << (SparkSqlParser.MINUS - 354)) | (1 << (SparkSqlParser.CONCAT_PIPE - 354)))) !== 0))) {
							_localctx._operator = this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 3093;
						_localctx._right = this.valueExpression(6);
						}
						break;

					case 3:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3094;
						if (!(this.precpred(this._ctx, 4))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
						}
						this.state = 3095;
						_localctx._operator = this.match(SparkSqlParser.AMPERSAND);
						this.state = 3096;
						_localctx._right = this.valueExpression(5);
						}
						break;

					case 4:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3097;
						if (!(this.precpred(this._ctx, 3))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
						}
						this.state = 3098;
						_localctx._operator = this.match(SparkSqlParser.HAT);
						this.state = 3099;
						_localctx._right = this.valueExpression(4);
						}
						break;

					case 5:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3100;
						if (!(this.precpred(this._ctx, 2))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
						}
						this.state = 3101;
						_localctx._operator = this.match(SparkSqlParser.PIPE);
						this.state = 3102;
						_localctx._right = this.valueExpression(3);
						}
						break;

					case 6:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3103;
						if (!(this.precpred(this._ctx, 1))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
						}
						this.state = 3104;
						this.comparisonOperator();
						this.state = 3105;
						_localctx._right = this.valueExpression(2);
						}
						break;
					}
					}
				}
				this.state = 3111;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 410, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public datetimeUnit(): DatetimeUnitContext {
		let _localctx: DatetimeUnitContext = new DatetimeUnitContext(this._ctx, this.state);
		this.enterRule(_localctx, 280, SparkSqlParser.RULE_datetimeUnit);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3112;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_DAYOFYEAR || _la === SparkSqlParser.KW_HOUR || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (SparkSqlParser.KW_MICROSECOND - 176)) | (1 << (SparkSqlParser.KW_MILLISECOND - 176)) | (1 << (SparkSqlParser.KW_MINUTE - 176)) | (1 << (SparkSqlParser.KW_MONTH - 176)))) !== 0) || _la === SparkSqlParser.KW_QUARTER || _la === SparkSqlParser.KW_SECOND || _la === SparkSqlParser.KW_WEEK || _la === SparkSqlParser.KW_YEAR)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public primaryExpression(): PrimaryExpressionContext;
	public primaryExpression(_p: number): PrimaryExpressionContext;
	// @RuleVersion(0)
	public primaryExpression(_p?: number): PrimaryExpressionContext {
		if (_p === undefined) {
			_p = 0;
		}

		let _parentctx: ParserRuleContext = this._ctx;
		let _parentState: number = this.state;
		let _localctx: PrimaryExpressionContext = new PrimaryExpressionContext(this._ctx, _parentState);
		let _prevctx: PrimaryExpressionContext = _localctx;
		let _startState: number = 282;
		this.enterRecursionRule(_localctx, 282, SparkSqlParser.RULE_primaryExpression, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3363;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 436, this._ctx) ) {
			case 1:
				{
				this.state = 3115;
				_localctx._name = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(((((_la - 63)) & ~0x1F) === 0 && ((1 << (_la - 63)) & ((1 << (SparkSqlParser.KW_CURRENT_DATE - 63)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 63)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 63)))) !== 0) || _la === SparkSqlParser.KW_SESSION_USER || _la === SparkSqlParser.KW_USER)) {
					_localctx._name = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;

			case 2:
				{
				this.state = 3116;
				_localctx._name = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DATEADD || _la === SparkSqlParser.KW_DATE_ADD || _la === SparkSqlParser.KW_TIMESTAMPADD)) {
					_localctx._name = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3117;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3120;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_DAY:
				case SparkSqlParser.KW_DAYOFYEAR:
				case SparkSqlParser.KW_HOUR:
				case SparkSqlParser.KW_MICROSECOND:
				case SparkSqlParser.KW_MILLISECOND:
				case SparkSqlParser.KW_MINUTE:
				case SparkSqlParser.KW_MONTH:
				case SparkSqlParser.KW_QUARTER:
				case SparkSqlParser.KW_SECOND:
				case SparkSqlParser.KW_WEEK:
				case SparkSqlParser.KW_YEAR:
					{
					this.state = 3118;
					_localctx._unit = this.datetimeUnit();
					}
					break;
				case SparkSqlParser.STRING_LITERAL:
				case SparkSqlParser.DOUBLEQUOTED_STRING:
					{
					this.state = 3119;
					_localctx._invalidUnit = this.stringLit();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 3122;
				this.match(SparkSqlParser.COMMA);
				this.state = 3123;
				_localctx._unitsAmount = this.valueExpression(0);
				this.state = 3124;
				this.match(SparkSqlParser.COMMA);
				this.state = 3125;
				_localctx._timestamp = this.valueExpression(0);
				this.state = 3126;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				{
				this.state = 3128;
				_localctx._name = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DATEDIFF || _la === SparkSqlParser.KW_DATE_DIFF || _la === SparkSqlParser.KW_TIMEDIFF || _la === SparkSqlParser.KW_TIMESTAMPDIFF)) {
					_localctx._name = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3129;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3132;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_DAY:
				case SparkSqlParser.KW_DAYOFYEAR:
				case SparkSqlParser.KW_HOUR:
				case SparkSqlParser.KW_MICROSECOND:
				case SparkSqlParser.KW_MILLISECOND:
				case SparkSqlParser.KW_MINUTE:
				case SparkSqlParser.KW_MONTH:
				case SparkSqlParser.KW_QUARTER:
				case SparkSqlParser.KW_SECOND:
				case SparkSqlParser.KW_WEEK:
				case SparkSqlParser.KW_YEAR:
					{
					this.state = 3130;
					_localctx._unit = this.datetimeUnit();
					}
					break;
				case SparkSqlParser.STRING_LITERAL:
				case SparkSqlParser.DOUBLEQUOTED_STRING:
					{
					this.state = 3131;
					_localctx._invalidUnit = this.stringLit();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 3134;
				this.match(SparkSqlParser.COMMA);
				this.state = 3135;
				_localctx._startTimestamp = this.valueExpression(0);
				this.state = 3136;
				this.match(SparkSqlParser.COMMA);
				this.state = 3137;
				_localctx._endTimestamp = this.valueExpression(0);
				this.state = 3138;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 4:
				{
				this.state = 3140;
				this.match(SparkSqlParser.KW_CASE);
				this.state = 3142;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3141;
					this.whenClause();
					}
					}
					this.state = 3144;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.KW_WHEN);
				this.state = 3148;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ELSE) {
					{
					this.state = 3146;
					this.match(SparkSqlParser.KW_ELSE);
					this.state = 3147;
					_localctx._elseExpression = this.expression();
					}
				}

				this.state = 3150;
				this.match(SparkSqlParser.KW_END);
				}
				break;

			case 5:
				{
				this.state = 3152;
				this.match(SparkSqlParser.KW_CASE);
				this.state = 3153;
				this.expression();
				this.state = 3155;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3154;
					this.whenClause();
					}
					}
					this.state = 3157;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.KW_WHEN);
				this.state = 3161;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ELSE) {
					{
					this.state = 3159;
					this.match(SparkSqlParser.KW_ELSE);
					this.state = 3160;
					_localctx._elseExpression = this.expression();
					}
				}

				this.state = 3163;
				this.match(SparkSqlParser.KW_END);
				}
				break;

			case 6:
				{
				this.state = 3165;
				_localctx._name = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_CAST || _la === SparkSqlParser.KW_TRY_CAST)) {
					_localctx._name = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3166;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3167;
				this.expression();
				this.state = 3168;
				this.match(SparkSqlParser.KW_AS);
				this.state = 3169;
				this.dataType();
				this.state = 3170;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 7:
				{
				this.state = 3172;
				this.match(SparkSqlParser.KW_STRUCT);
				this.state = 3173;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3182;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
					{
					this.state = 3174;
					this.namedExpression();
					this.state = 3179;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3175;
						this.match(SparkSqlParser.COMMA);
						this.state = 3176;
						this.namedExpression();
						}
						}
						this.state = 3181;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
				}

				this.state = 3184;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 8:
				{
				this.state = 3185;
				this.match(SparkSqlParser.KW_FIRST);
				this.state = 3186;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3187;
				this.expression();
				this.state = 3190;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IGNORE) {
					{
					this.state = 3188;
					this.match(SparkSqlParser.KW_IGNORE);
					this.state = 3189;
					this.match(SparkSqlParser.KW_NULLS);
					}
				}

				this.state = 3192;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 9:
				{
				this.state = 3194;
				this.match(SparkSqlParser.KW_ANY_VALUE);
				this.state = 3195;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3196;
				this.expression();
				this.state = 3199;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IGNORE) {
					{
					this.state = 3197;
					this.match(SparkSqlParser.KW_IGNORE);
					this.state = 3198;
					this.match(SparkSqlParser.KW_NULLS);
					}
				}

				this.state = 3201;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 10:
				{
				this.state = 3203;
				this.match(SparkSqlParser.KW_LAST);
				this.state = 3204;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3205;
				this.expression();
				this.state = 3208;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IGNORE) {
					{
					this.state = 3206;
					this.match(SparkSqlParser.KW_IGNORE);
					this.state = 3207;
					this.match(SparkSqlParser.KW_NULLS);
					}
				}

				this.state = 3210;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 11:
				{
				this.state = 3212;
				this.match(SparkSqlParser.KW_POSITION);
				this.state = 3213;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3214;
				_localctx._substr = this.valueExpression(0);
				this.state = 3215;
				this.match(SparkSqlParser.KW_IN);
				this.state = 3216;
				_localctx._str = this.valueExpression(0);
				this.state = 3217;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 12:
				{
				this.state = 3219;
				this.constant();
				}
				break;

			case 13:
				{
				this.state = 3220;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 14:
				{
				this.state = 3221;
				this.qualifiedName();
				this.state = 3222;
				this.match(SparkSqlParser.DOT);
				this.state = 3223;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 15:
				{
				this.state = 3225;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3226;
				this.namedExpression();
				this.state = 3229;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3227;
					this.match(SparkSqlParser.COMMA);
					this.state = 3228;
					this.namedExpression();
					}
					}
					this.state = 3231;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.COMMA);
				this.state = 3233;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 16:
				{
				this.state = 3235;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3236;
				this.query();
				this.state = 3237;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 17:
				{
				this.state = 3239;
				this.match(SparkSqlParser.KW_IDENTIFIER);
				this.state = 3240;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3241;
				this.expression();
				this.state = 3242;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 18:
				{
				this.state = 3244;
				this.functionName();
				this.state = 3245;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3257;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.LEFT_PAREN) | (1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.NOT - 353)) | (1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.COLON - 353)) | (1 << (SparkSqlParser.QUESTION - 353)) | (1 << (SparkSqlParser.STRING_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 353)) | (1 << (SparkSqlParser.BIGINT_LITERAL - 353)) | (1 << (SparkSqlParser.SMALLINT_LITERAL - 353)) | (1 << (SparkSqlParser.TINYINT_LITERAL - 353)) | (1 << (SparkSqlParser.INTEGER_VALUE - 353)) | (1 << (SparkSqlParser.EXPONENT_VALUE - 353)) | (1 << (SparkSqlParser.DECIMAL_VALUE - 353)) | (1 << (SparkSqlParser.FLOAT_LITERAL - 353)) | (1 << (SparkSqlParser.DOUBLE_LITERAL - 353)) | (1 << (SparkSqlParser.BIGDECIMAL_LITERAL - 353)) | (1 << (SparkSqlParser.IDENTIFIER - 353)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 353)))) !== 0)) {
					{
					this.state = 3247;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 423, this._ctx) ) {
					case 1:
						{
						this.state = 3246;
						this.setQuantifier();
						}
						break;
					}
					this.state = 3249;
					this.functionArgument();
					this.state = 3254;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3250;
						this.match(SparkSqlParser.COMMA);
						this.state = 3251;
						this.functionArgument();
						}
						}
						this.state = 3256;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
				}

				this.state = 3259;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3266;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 426, this._ctx) ) {
				case 1:
					{
					this.state = 3260;
					this.match(SparkSqlParser.KW_FILTER);
					this.state = 3261;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3262;
					this.match(SparkSqlParser.KW_WHERE);
					this.state = 3263;
					_localctx._where = this.booleanExpression(0);
					this.state = 3264;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 3270;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 427, this._ctx) ) {
				case 1:
					{
					this.state = 3268;
					_localctx._nullsOption = this._input.LT(1);
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_IGNORE || _la === SparkSqlParser.KW_RESPECT)) {
						_localctx._nullsOption = this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 3269;
					this.match(SparkSqlParser.KW_NULLS);
					}
					break;
				}
				this.state = 3274;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 428, this._ctx) ) {
				case 1:
					{
					this.state = 3272;
					this.match(SparkSqlParser.KW_OVER);
					this.state = 3273;
					this.windowSpec();
					}
					break;
				}
				}
				break;

			case 19:
				{
				this.state = 3276;
				this.identifier();
				this.state = 3277;
				this.match(SparkSqlParser.ARROW);
				this.state = 3278;
				this.expression();
				}
				break;

			case 20:
				{
				this.state = 3280;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3281;
				this.identifier();
				this.state = 3284;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3282;
					this.match(SparkSqlParser.COMMA);
					this.state = 3283;
					this.identifier();
					}
					}
					this.state = 3286;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.COMMA);
				this.state = 3288;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3289;
				this.match(SparkSqlParser.ARROW);
				this.state = 3290;
				this.expression();
				}
				break;

			case 21:
				{
				this.state = 3292;
				this.identifier();
				}
				break;

			case 22:
				{
				this.state = 3293;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3294;
				this.expression();
				this.state = 3295;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 23:
				{
				this.state = 3297;
				this.match(SparkSqlParser.KW_EXTRACT);
				this.state = 3298;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3299;
				_localctx._field = this.identifier();
				this.state = 3300;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3301;
				_localctx._source = this.valueExpression(0);
				this.state = 3302;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 24:
				{
				this.state = 3304;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_SUBSTR || _la === SparkSqlParser.KW_SUBSTRING)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3305;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3306;
				_localctx._str = this.valueExpression(0);
				this.state = 3307;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FROM)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3308;
				_localctx._pos = this.valueExpression(0);
				this.state = 3311;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FOR) {
					{
					this.state = 3309;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FOR)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					this.state = 3310;
					_localctx._len = this.valueExpression(0);
					}
				}

				this.state = 3313;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 25:
				{
				this.state = 3315;
				this.match(SparkSqlParser.KW_TRIM);
				this.state = 3316;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3318;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 431, this._ctx) ) {
				case 1:
					{
					this.state = 3317;
					_localctx._trimOption = this._input.LT(1);
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_BOTH || _la === SparkSqlParser.KW_LEADING || _la === SparkSqlParser.KW_TRAILING)) {
						_localctx._trimOption = this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					}
					break;
				}
				this.state = 3321;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 432, this._ctx) ) {
				case 1:
					{
					this.state = 3320;
					_localctx._trimStr = this.valueExpression(0);
					}
					break;
				}
				this.state = 3323;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3324;
				_localctx._srcStr = this.valueExpression(0);
				this.state = 3325;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 26:
				{
				this.state = 3327;
				this.match(SparkSqlParser.KW_OVERLAY);
				this.state = 3328;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3329;
				_localctx._input = this.valueExpression(0);
				this.state = 3330;
				this.match(SparkSqlParser.KW_PLACING);
				this.state = 3331;
				_localctx._replace = this.valueExpression(0);
				this.state = 3332;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3333;
				_localctx._position = this.valueExpression(0);
				this.state = 3336;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FOR) {
					{
					this.state = 3334;
					this.match(SparkSqlParser.KW_FOR);
					this.state = 3335;
					_localctx._length = this.valueExpression(0);
					}
				}

				this.state = 3338;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 27:
				{
				this.state = 3340;
				_localctx._name = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_PERCENTILE_CONT || _la === SparkSqlParser.KW_PERCENTILE_DISC)) {
					_localctx._name = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3341;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3342;
				_localctx._percentage = this.valueExpression(0);
				this.state = 3343;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3344;
				this.match(SparkSqlParser.KW_WITHIN);
				this.state = 3345;
				this.match(SparkSqlParser.KW_GROUP);
				this.state = 3346;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3347;
				this.match(SparkSqlParser.KW_ORDER);
				this.state = 3348;
				this.match(SparkSqlParser.KW_BY);
				this.state = 3349;
				this.sortItem();
				this.state = 3350;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3357;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 434, this._ctx) ) {
				case 1:
					{
					this.state = 3351;
					this.match(SparkSqlParser.KW_FILTER);
					this.state = 3352;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3353;
					this.match(SparkSqlParser.KW_WHERE);
					this.state = 3354;
					_localctx._where = this.booleanExpression(0);
					this.state = 3355;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 3361;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 435, this._ctx) ) {
				case 1:
					{
					this.state = 3359;
					this.match(SparkSqlParser.KW_OVER);
					this.state = 3360;
					this.windowSpec();
					}
					break;
				}
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 3375;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 438, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 3373;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 437, this._ctx) ) {
					case 1:
						{
						_localctx = new PrimaryExpressionContext(_parentctx, _parentState);
						_localctx._value = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_primaryExpression);
						this.state = 3365;
						if (!(this.precpred(this._ctx, 9))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
						}
						this.state = 3366;
						this.match(SparkSqlParser.LEFT_BRACKET);
						this.state = 3367;
						_localctx._index = this.valueExpression(0);
						this.state = 3368;
						this.match(SparkSqlParser.RIGHT_BRACKET);
						}
						break;

					case 2:
						{
						_localctx = new PrimaryExpressionContext(_parentctx, _parentState);
						_localctx._base = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_primaryExpression);
						this.state = 3370;
						if (!(this.precpred(this._ctx, 7))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
						}
						this.state = 3371;
						this.match(SparkSqlParser.DOT);
						this.state = 3372;
						_localctx._fieldName = this.identifier();
						}
						break;
					}
					}
				}
				this.state = 3377;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 438, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.unrollRecursionContexts(_parentctx);
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public literalType(): LiteralTypeContext {
		let _localctx: LiteralTypeContext = new LiteralTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 284, SparkSqlParser.RULE_literalType);
		try {
			this.state = 3385;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 439, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3378;
				this.match(SparkSqlParser.KW_DATE);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3379;
				this.match(SparkSqlParser.KW_TIMESTAMP);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3380;
				this.match(SparkSqlParser.KW_TIMESTAMP_LTZ);
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3381;
				this.match(SparkSqlParser.KW_TIMESTAMP_NTZ);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3382;
				this.match(SparkSqlParser.KW_INTERVAL);
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3383;
				this.match(SparkSqlParser.KW_BINARY_HEX);
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 3384;
				_localctx._unsupportedType = this.identifier();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public constant(): ConstantContext {
		let _localctx: ConstantContext = new ConstantContext(this._ctx, this.state);
		this.enterRule(_localctx, 286, SparkSqlParser.RULE_constant);
		try {
			let _alt: number;
			this.state = 3402;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 441, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3387;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3388;
				this.match(SparkSqlParser.QUESTION);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3389;
				this.match(SparkSqlParser.COLON);
				this.state = 3390;
				this.identifier();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3391;
				this.interval();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3392;
				this.literalType();
				this.state = 3393;
				this.stringLit();
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3395;
				this.number();
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 3396;
				this.booleanValue();
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 3398;
				this._errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						this.state = 3397;
						this.stringLit();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					this.state = 3400;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 440, this._ctx);
				} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public comparisonOperator(): ComparisonOperatorContext {
		let _localctx: ComparisonOperatorContext = new ComparisonOperatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 288, SparkSqlParser.RULE_comparisonOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3404;
			_la = this._input.LA(1);
			if (!(((((_la - 345)) & ~0x1F) === 0 && ((1 << (_la - 345)) & ((1 << (SparkSqlParser.EQ - 345)) | (1 << (SparkSqlParser.NSEQ - 345)) | (1 << (SparkSqlParser.NEQ - 345)) | (1 << (SparkSqlParser.NEQJ - 345)) | (1 << (SparkSqlParser.LT - 345)) | (1 << (SparkSqlParser.LTE - 345)) | (1 << (SparkSqlParser.GT - 345)) | (1 << (SparkSqlParser.GTE - 345)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public arithmeticOperator(): ArithmeticOperatorContext {
		let _localctx: ArithmeticOperatorContext = new ArithmeticOperatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 290, SparkSqlParser.RULE_arithmeticOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3406;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DIV || ((((_la - 354)) & ~0x1F) === 0 && ((1 << (_la - 354)) & ((1 << (SparkSqlParser.PLUS - 354)) | (1 << (SparkSqlParser.MINUS - 354)) | (1 << (SparkSqlParser.ASTERISK - 354)) | (1 << (SparkSqlParser.SLASH - 354)) | (1 << (SparkSqlParser.PERCENT - 354)) | (1 << (SparkSqlParser.TILDE - 354)) | (1 << (SparkSqlParser.AMPERSAND - 354)) | (1 << (SparkSqlParser.PIPE - 354)) | (1 << (SparkSqlParser.CONCAT_PIPE - 354)) | (1 << (SparkSqlParser.HAT - 354)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public predicateOperator(): PredicateOperatorContext {
		let _localctx: PredicateOperatorContext = new PredicateOperatorContext(this._ctx, this.state);
		this.enterRule(_localctx, 292, SparkSqlParser.RULE_predicateOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3408;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_AND || _la === SparkSqlParser.KW_IN || _la === SparkSqlParser.KW_NOT || _la === SparkSqlParser.KW_OR)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public booleanValue(): BooleanValueContext {
		let _localctx: BooleanValueContext = new BooleanValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 294, SparkSqlParser.RULE_booleanValue);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3410;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_FALSE || _la === SparkSqlParser.KW_TRUE)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public interval(): IntervalContext {
		let _localctx: IntervalContext = new IntervalContext(this._ctx, this.state);
		this.enterRule(_localctx, 296, SparkSqlParser.RULE_interval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3412;
			this.match(SparkSqlParser.KW_INTERVAL);
			this.state = 3415;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 442, this._ctx) ) {
			case 1:
				{
				this.state = 3413;
				this.errorCapturingMultiUnitsInterval();
				}
				break;

			case 2:
				{
				this.state = 3414;
				this.errorCapturingUnitToUnitInterval();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext {
		let _localctx: ErrorCapturingMultiUnitsIntervalContext = new ErrorCapturingMultiUnitsIntervalContext(this._ctx, this.state);
		this.enterRule(_localctx, 298, SparkSqlParser.RULE_errorCapturingMultiUnitsInterval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3417;
			_localctx._body = this.multiUnitsInterval();
			this.state = 3419;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 443, this._ctx) ) {
			case 1:
				{
				this.state = 3418;
				this.unitToUnitInterval();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public multiUnitsInterval(): MultiUnitsIntervalContext {
		let _localctx: MultiUnitsIntervalContext = new MultiUnitsIntervalContext(this._ctx, this.state);
		this.enterRule(_localctx, 300, SparkSqlParser.RULE_multiUnitsInterval);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3424;
			this._errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					this.state = 3421;
					this.intervalValue();
					this.state = 3422;
					_localctx._unitInMultiUnits = this.unitInMultiUnits();
					_localctx._unit.push(_localctx._unitInMultiUnits);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 3426;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 444, this._ctx);
			} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext {
		let _localctx: ErrorCapturingUnitToUnitIntervalContext = new ErrorCapturingUnitToUnitIntervalContext(this._ctx, this.state);
		this.enterRule(_localctx, 302, SparkSqlParser.RULE_errorCapturingUnitToUnitInterval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3428;
			_localctx._body = this.unitToUnitInterval();
			this.state = 3431;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 445, this._ctx) ) {
			case 1:
				{
				this.state = 3429;
				_localctx._error1 = this.multiUnitsInterval();
				}
				break;

			case 2:
				{
				this.state = 3430;
				_localctx._error2 = this.unitToUnitInterval();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unitToUnitInterval(): UnitToUnitIntervalContext {
		let _localctx: UnitToUnitIntervalContext = new UnitToUnitIntervalContext(this._ctx, this.state);
		this.enterRule(_localctx, 304, SparkSqlParser.RULE_unitToUnitInterval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3433;
			_localctx._value = this.intervalValue();
			this.state = 3434;
			this.unitInUnitToUnit();
			this.state = 3435;
			this.match(SparkSqlParser.KW_TO);
			this.state = 3436;
			this.unitInUnitToUnit();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public intervalValue(): IntervalValueContext {
		let _localctx: IntervalValueContext = new IntervalValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 306, SparkSqlParser.RULE_intervalValue);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3439;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.PLUS || _la === SparkSqlParser.MINUS) {
				{
				this.state = 3438;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.PLUS || _la === SparkSqlParser.MINUS)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
			}

			this.state = 3444;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.INTEGER_VALUE:
				{
				this.state = 3441;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;
			case SparkSqlParser.DECIMAL_VALUE:
				{
				this.state = 3442;
				this.match(SparkSqlParser.DECIMAL_VALUE);
				}
				break;
			case SparkSqlParser.STRING_LITERAL:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
				{
				this.state = 3443;
				this.stringLit();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unitInMultiUnits(): UnitInMultiUnitsContext {
		let _localctx: UnitInMultiUnitsContext = new UnitInMultiUnitsContext(this._ctx, this.state);
		this.enterRule(_localctx, 308, SparkSqlParser.RULE_unitInMultiUnits);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3446;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_DAYS || _la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_HOURS || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (SparkSqlParser.KW_MICROSECOND - 176)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 176)) | (1 << (SparkSqlParser.KW_MILLISECOND - 176)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 176)) | (1 << (SparkSqlParser.KW_MINUTE - 176)) | (1 << (SparkSqlParser.KW_MINUTES - 176)) | (1 << (SparkSqlParser.KW_MONTH - 176)) | (1 << (SparkSqlParser.KW_MONTHS - 176)) | (1 << (SparkSqlParser.KW_NANOSECOND - 176)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 176)))) !== 0) || _la === SparkSqlParser.KW_SECOND || _la === SparkSqlParser.KW_SECONDS || ((((_la - 335)) & ~0x1F) === 0 && ((1 << (_la - 335)) & ((1 << (SparkSqlParser.KW_WEEK - 335)) | (1 << (SparkSqlParser.KW_WEEKS - 335)) | (1 << (SparkSqlParser.KW_YEAR - 335)) | (1 << (SparkSqlParser.KW_YEARS - 335)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public unitInUnitToUnit(): UnitInUnitToUnitContext {
		let _localctx: UnitInUnitToUnitContext = new UnitInUnitToUnitContext(this._ctx, this.state);
		this.enterRule(_localctx, 310, SparkSqlParser.RULE_unitInUnitToUnit);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3448;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_MINUTE || _la === SparkSqlParser.KW_MONTH || _la === SparkSqlParser.KW_SECOND || _la === SparkSqlParser.KW_YEAR)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public colPosition(): ColPositionContext {
		let _localctx: ColPositionContext = new ColPositionContext(this._ctx, this.state);
		this.enterRule(_localctx, 312, SparkSqlParser.RULE_colPosition);
		try {
			this.state = 3453;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_FIRST:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3450;
				_localctx._position = this.match(SparkSqlParser.KW_FIRST);
				}
				break;
			case SparkSqlParser.KW_AFTER:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3451;
				_localctx._position = this.match(SparkSqlParser.KW_AFTER);
				this.state = 3452;
				_localctx._afterCol = this.errorCapturingIdentifier();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public type(): TypeContext {
		let _localctx: TypeContext = new TypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 314, SparkSqlParser.RULE_type);
		try {
			this.state = 3485;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 449, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3455;
				this.match(SparkSqlParser.KW_BOOLEAN);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3456;
				this.match(SparkSqlParser.KW_TINYINT);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3457;
				this.match(SparkSqlParser.KW_BYTE);
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3458;
				this.match(SparkSqlParser.KW_SMALLINT);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3459;
				this.match(SparkSqlParser.KW_SHORT);
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3460;
				this.match(SparkSqlParser.KW_INT);
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 3461;
				this.match(SparkSqlParser.KW_INTEGER);
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 3462;
				this.match(SparkSqlParser.KW_BIGINT);
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 3463;
				this.match(SparkSqlParser.KW_LONG);
				}
				break;

			case 10:
				this.enterOuterAlt(_localctx, 10);
				{
				this.state = 3464;
				this.match(SparkSqlParser.KW_FLOAT);
				}
				break;

			case 11:
				this.enterOuterAlt(_localctx, 11);
				{
				this.state = 3465;
				this.match(SparkSqlParser.KW_REAL);
				}
				break;

			case 12:
				this.enterOuterAlt(_localctx, 12);
				{
				this.state = 3466;
				this.match(SparkSqlParser.KW_DOUBLE);
				}
				break;

			case 13:
				this.enterOuterAlt(_localctx, 13);
				{
				this.state = 3467;
				this.match(SparkSqlParser.KW_DATE);
				}
				break;

			case 14:
				this.enterOuterAlt(_localctx, 14);
				{
				this.state = 3468;
				this.match(SparkSqlParser.KW_TIMESTAMP);
				}
				break;

			case 15:
				this.enterOuterAlt(_localctx, 15);
				{
				this.state = 3469;
				this.match(SparkSqlParser.KW_TIMESTAMP_NTZ);
				}
				break;

			case 16:
				this.enterOuterAlt(_localctx, 16);
				{
				this.state = 3470;
				this.match(SparkSqlParser.KW_TIMESTAMP_LTZ);
				}
				break;

			case 17:
				this.enterOuterAlt(_localctx, 17);
				{
				this.state = 3471;
				this.match(SparkSqlParser.KW_STRING);
				}
				break;

			case 18:
				this.enterOuterAlt(_localctx, 18);
				{
				this.state = 3472;
				this.match(SparkSqlParser.KW_CHARACTER);
				}
				break;

			case 19:
				this.enterOuterAlt(_localctx, 19);
				{
				this.state = 3473;
				this.match(SparkSqlParser.KW_CHAR);
				}
				break;

			case 20:
				this.enterOuterAlt(_localctx, 20);
				{
				this.state = 3474;
				this.match(SparkSqlParser.KW_VARCHAR);
				}
				break;

			case 21:
				this.enterOuterAlt(_localctx, 21);
				{
				this.state = 3475;
				this.match(SparkSqlParser.KW_BINARY);
				}
				break;

			case 22:
				this.enterOuterAlt(_localctx, 22);
				{
				this.state = 3476;
				this.match(SparkSqlParser.KW_DECIMAL);
				}
				break;

			case 23:
				this.enterOuterAlt(_localctx, 23);
				{
				this.state = 3477;
				this.match(SparkSqlParser.KW_DEC);
				}
				break;

			case 24:
				this.enterOuterAlt(_localctx, 24);
				{
				this.state = 3478;
				this.match(SparkSqlParser.KW_NUMERIC);
				}
				break;

			case 25:
				this.enterOuterAlt(_localctx, 25);
				{
				this.state = 3479;
				this.match(SparkSqlParser.KW_VOID);
				}
				break;

			case 26:
				this.enterOuterAlt(_localctx, 26);
				{
				this.state = 3480;
				this.match(SparkSqlParser.KW_INTERVAL);
				}
				break;

			case 27:
				this.enterOuterAlt(_localctx, 27);
				{
				this.state = 3481;
				this.match(SparkSqlParser.KW_ARRAY);
				}
				break;

			case 28:
				this.enterOuterAlt(_localctx, 28);
				{
				this.state = 3482;
				this.match(SparkSqlParser.KW_STRUCT);
				}
				break;

			case 29:
				this.enterOuterAlt(_localctx, 29);
				{
				this.state = 3483;
				this.match(SparkSqlParser.KW_MAP);
				}
				break;

			case 30:
				this.enterOuterAlt(_localctx, 30);
				{
				this.state = 3484;
				_localctx._unsupportedType = this.identifier();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public dataType(): DataTypeContext {
		let _localctx: DataTypeContext = new DataTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 316, SparkSqlParser.RULE_dataType);
		let _la: number;
		try {
			this.state = 3533;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 456, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3487;
				_localctx._complex = this.match(SparkSqlParser.KW_ARRAY);
				this.state = 3488;
				this.match(SparkSqlParser.LT);
				this.state = 3489;
				this.dataType();
				this.state = 3490;
				this.match(SparkSqlParser.GT);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3492;
				_localctx._complex = this.match(SparkSqlParser.KW_MAP);
				this.state = 3493;
				this.match(SparkSqlParser.LT);
				this.state = 3494;
				this.dataType();
				this.state = 3495;
				this.match(SparkSqlParser.COMMA);
				this.state = 3496;
				this.dataType();
				this.state = 3497;
				this.match(SparkSqlParser.GT);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3499;
				_localctx._complex = this.match(SparkSqlParser.KW_STRUCT);
				this.state = 3506;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.LT:
					{
					this.state = 3500;
					this.match(SparkSqlParser.LT);
					this.state = 3502;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CROSS - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCEPT - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FULL - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INNER - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERSECT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_JOIN - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LATERAL - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)) | (1 << (SparkSqlParser.KW_LEFT - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NATURAL - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ON - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RIGHT - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEMI - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_MINUS - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNION - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_USING - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0) || ((((_la - 371)) & ~0x1F) === 0 && ((1 << (_la - 371)) & ((1 << (SparkSqlParser.DOUBLEQUOTED_STRING - 371)) | (1 << (SparkSqlParser.IDENTIFIER - 371)) | (1 << (SparkSqlParser.BACKQUOTED_IDENTIFIER - 371)))) !== 0)) {
						{
						this.state = 3501;
						this.complexColTypeList();
						}
					}

					this.state = 3504;
					this.match(SparkSqlParser.GT);
					}
					break;
				case SparkSqlParser.NEQ:
					{
					this.state = 3505;
					this.match(SparkSqlParser.NEQ);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3508;
				this.match(SparkSqlParser.KW_INTERVAL);
				this.state = 3509;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_MONTH || _la === SparkSqlParser.KW_YEAR)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3512;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 452, this._ctx) ) {
				case 1:
					{
					this.state = 3510;
					this.match(SparkSqlParser.KW_TO);
					this.state = 3511;
					this.match(SparkSqlParser.KW_MONTH);
					}
					break;
				}
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3514;
				this.match(SparkSqlParser.KW_INTERVAL);
				this.state = 3515;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DAY || _la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_MINUTE || _la === SparkSqlParser.KW_SECOND)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3518;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 453, this._ctx) ) {
				case 1:
					{
					this.state = 3516;
					this.match(SparkSqlParser.KW_TO);
					this.state = 3517;
					_la = this._input.LA(1);
					if (!(_la === SparkSqlParser.KW_HOUR || _la === SparkSqlParser.KW_MINUTE || _la === SparkSqlParser.KW_SECOND)) {
					this._errHandler.recoverInline(this);
					} else {
						if (this._input.LA(1) === Token.EOF) {
							this.matchedEOF = true;
						}

						this._errHandler.reportMatch(this);
						this.consume();
					}
					}
					break;
				}
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3520;
				this.type();
				this.state = 3531;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 455, this._ctx) ) {
				case 1:
					{
					this.state = 3521;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3522;
					this.match(SparkSqlParser.INTEGER_VALUE);
					this.state = 3527;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3523;
						this.match(SparkSqlParser.COMMA);
						this.state = 3524;
						this.match(SparkSqlParser.INTEGER_VALUE);
						}
						}
						this.state = 3529;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 3530;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public qualifiedColTypeWithPositionSeqForAdd(): QualifiedColTypeWithPositionSeqForAddContext {
		let _localctx: QualifiedColTypeWithPositionSeqForAddContext = new QualifiedColTypeWithPositionSeqForAddContext(this._ctx, this.state);
		this.enterRule(_localctx, 318, SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForAdd);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3535;
			this.qualifiedColTypeWithPositionForAdd();
			this.state = 3540;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3536;
				this.match(SparkSqlParser.COMMA);
				this.state = 3537;
				this.qualifiedColTypeWithPositionForAdd();
				}
				}
				this.state = 3542;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext {
		let _localctx: QualifiedColTypeWithPositionForAddContext = new QualifiedColTypeWithPositionForAddContext(this._ctx, this.state);
		this.enterRule(_localctx, 320, SparkSqlParser.RULE_qualifiedColTypeWithPositionForAdd);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3543;
			_localctx._name = this.columnNameCreate();
			this.state = 3544;
			this.dataType();
			this.state = 3548;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 458, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3545;
					this.colDefinitionDescriptorWithPosition();
					}
					}
				}
				this.state = 3550;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 458, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public qualifiedColTypeWithPositionSeqForReplace(): QualifiedColTypeWithPositionSeqForReplaceContext {
		let _localctx: QualifiedColTypeWithPositionSeqForReplaceContext = new QualifiedColTypeWithPositionSeqForReplaceContext(this._ctx, this.state);
		this.enterRule(_localctx, 322, SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForReplace);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3551;
			this.qualifiedColTypeWithPositionForReplace();
			this.state = 3556;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3552;
				this.match(SparkSqlParser.COMMA);
				this.state = 3553;
				this.qualifiedColTypeWithPositionForReplace();
				}
				}
				this.state = 3558;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public qualifiedColTypeWithPositionForReplace(): QualifiedColTypeWithPositionForReplaceContext {
		let _localctx: QualifiedColTypeWithPositionForReplaceContext = new QualifiedColTypeWithPositionForReplaceContext(this._ctx, this.state);
		this.enterRule(_localctx, 324, SparkSqlParser.RULE_qualifiedColTypeWithPositionForReplace);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3559;
			_localctx._name = this.columnName();
			this.state = 3560;
			this.dataType();
			this.state = 3564;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.KW_AFTER || _la === SparkSqlParser.KW_COMMENT || _la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.KW_FIRST || _la === SparkSqlParser.KW_NOT) {
				{
				{
				this.state = 3561;
				this.colDefinitionDescriptorWithPosition();
				}
				}
				this.state = 3566;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext {
		let _localctx: ColDefinitionDescriptorWithPositionContext = new ColDefinitionDescriptorWithPositionContext(this._ctx, this.state);
		this.enterRule(_localctx, 326, SparkSqlParser.RULE_colDefinitionDescriptorWithPosition);
		try {
			this.state = 3572;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_NOT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3567;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3568;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			case SparkSqlParser.KW_DEFAULT:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3569;
				this.defaultExpression();
				}
				break;
			case SparkSqlParser.KW_COMMENT:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3570;
				this.commentSpec();
				}
				break;
			case SparkSqlParser.KW_AFTER:
			case SparkSqlParser.KW_FIRST:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3571;
				this.colPosition();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public defaultExpression(): DefaultExpressionContext {
		let _localctx: DefaultExpressionContext = new DefaultExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 328, SparkSqlParser.RULE_defaultExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3574;
			this.match(SparkSqlParser.KW_DEFAULT);
			this.state = 3575;
			this.expression();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public variableDefaultExpression(): VariableDefaultExpressionContext {
		let _localctx: VariableDefaultExpressionContext = new VariableDefaultExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 330, SparkSqlParser.RULE_variableDefaultExpression);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3577;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.EQ)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			this.state = 3578;
			this.expression();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public colTypeList(): ColTypeListContext {
		let _localctx: ColTypeListContext = new ColTypeListContext(this._ctx, this.state);
		this.enterRule(_localctx, 332, SparkSqlParser.RULE_colTypeList);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3580;
			this.colType();
			this.state = 3585;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 462, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3581;
					this.match(SparkSqlParser.COMMA);
					this.state = 3582;
					this.colType();
					}
					}
				}
				this.state = 3587;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 462, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public colType(): ColTypeContext {
		let _localctx: ColTypeContext = new ColTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 334, SparkSqlParser.RULE_colType);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3588;
			_localctx._colName = this.errorCapturingIdentifier();
			this.state = 3589;
			this.dataType();
			this.state = 3592;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 463, this._ctx) ) {
			case 1:
				{
				this.state = 3590;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3591;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			}
			this.state = 3595;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 464, this._ctx) ) {
			case 1:
				{
				this.state = 3594;
				this.commentSpec();
				}
				break;
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext {
		let _localctx: CreateOrReplaceTableColTypeListContext = new CreateOrReplaceTableColTypeListContext(this._ctx, this.state);
		this.enterRule(_localctx, 336, SparkSqlParser.RULE_createOrReplaceTableColTypeList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3597;
			this.createOrReplaceTableColType();
			this.state = 3602;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3598;
				this.match(SparkSqlParser.COMMA);
				this.state = 3599;
				this.createOrReplaceTableColType();
				}
				}
				this.state = 3604;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext {
		let _localctx: CreateOrReplaceTableColTypeContext = new CreateOrReplaceTableColTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 338, SparkSqlParser.RULE_createOrReplaceTableColType);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3605;
			_localctx._colName = this.columnNameCreate();
			this.state = 3606;
			this.dataType();
			this.state = 3610;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.KW_COMMENT || _la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.KW_GENERATED || _la === SparkSqlParser.KW_NOT) {
				{
				{
				this.state = 3607;
				this.colDefinitionOption();
				}
				}
				this.state = 3612;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public colDefinitionOption(): ColDefinitionOptionContext {
		let _localctx: ColDefinitionOptionContext = new ColDefinitionOptionContext(this._ctx, this.state);
		this.enterRule(_localctx, 340, SparkSqlParser.RULE_colDefinitionOption);
		try {
			this.state = 3618;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_NOT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3613;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3614;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			case SparkSqlParser.KW_DEFAULT:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3615;
				this.defaultExpression();
				}
				break;
			case SparkSqlParser.KW_GENERATED:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3616;
				this.generationExpression();
				}
				break;
			case SparkSqlParser.KW_COMMENT:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3617;
				this.commentSpec();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public generationExpression(): GenerationExpressionContext {
		let _localctx: GenerationExpressionContext = new GenerationExpressionContext(this._ctx, this.state);
		this.enterRule(_localctx, 342, SparkSqlParser.RULE_generationExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3620;
			this.match(SparkSqlParser.KW_GENERATED);
			this.state = 3621;
			this.match(SparkSqlParser.KW_ALWAYS);
			this.state = 3622;
			this.match(SparkSqlParser.KW_AS);
			this.state = 3623;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 3624;
			this.expression();
			this.state = 3625;
			this.match(SparkSqlParser.RIGHT_PAREN);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public complexColTypeList(): ComplexColTypeListContext {
		let _localctx: ComplexColTypeListContext = new ComplexColTypeListContext(this._ctx, this.state);
		this.enterRule(_localctx, 344, SparkSqlParser.RULE_complexColTypeList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3627;
			this.complexColType();
			this.state = 3632;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3628;
				this.match(SparkSqlParser.COMMA);
				this.state = 3629;
				this.complexColType();
				}
				}
				this.state = 3634;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public complexColType(): ComplexColTypeContext {
		let _localctx: ComplexColTypeContext = new ComplexColTypeContext(this._ctx, this.state);
		this.enterRule(_localctx, 346, SparkSqlParser.RULE_complexColType);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3635;
			this.identifier();
			this.state = 3637;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.COLON) {
				{
				this.state = 3636;
				this.match(SparkSqlParser.COLON);
				}
			}

			this.state = 3639;
			this.dataType();
			this.state = 3642;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_NOT) {
				{
				this.state = 3640;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3641;
				this.match(SparkSqlParser.KW_NULL);
				}
			}

			this.state = 3645;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_COMMENT) {
				{
				this.state = 3644;
				this.commentSpec();
				}
			}

			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public whenClause(): WhenClauseContext {
		let _localctx: WhenClauseContext = new WhenClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 348, SparkSqlParser.RULE_whenClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3647;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 3648;
			_localctx._condition = this.expression();
			this.state = 3649;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 3650;
			_localctx._result = this.expression();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public windowClause(): WindowClauseContext {
		let _localctx: WindowClauseContext = new WindowClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 350, SparkSqlParser.RULE_windowClause);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3652;
			this.match(SparkSqlParser.KW_WINDOW);
			this.state = 3653;
			this.namedWindow();
			this.state = 3658;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 472, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3654;
					this.match(SparkSqlParser.COMMA);
					this.state = 3655;
					this.namedWindow();
					}
					}
				}
				this.state = 3660;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 472, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public namedWindow(): NamedWindowContext {
		let _localctx: NamedWindowContext = new NamedWindowContext(this._ctx, this.state);
		this.enterRule(_localctx, 352, SparkSqlParser.RULE_namedWindow);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3661;
			_localctx._name = this.errorCapturingIdentifier();
			this.state = 3662;
			this.match(SparkSqlParser.KW_AS);
			this.state = 3663;
			this.windowSpec();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public windowSpec(): WindowSpecContext {
		let _localctx: WindowSpecContext = new WindowSpecContext(this._ctx, this.state);
		this.enterRule(_localctx, 354, SparkSqlParser.RULE_windowSpec);
		let _la: number;
		try {
			this.state = 3711;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 480, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3665;
				_localctx._name = this.errorCapturingIdentifier();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3666;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3667;
				_localctx._name = this.errorCapturingIdentifier();
				this.state = 3668;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3670;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3705;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_CLUSTER:
					{
					this.state = 3671;
					this.match(SparkSqlParser.KW_CLUSTER);
					this.state = 3672;
					this.match(SparkSqlParser.KW_BY);
					this.state = 3673;
					_localctx._expression = this.expression();
					_localctx._partition.push(_localctx._expression);
					this.state = 3678;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3674;
						this.match(SparkSqlParser.COMMA);
						this.state = 3675;
						_localctx._expression = this.expression();
						_localctx._partition.push(_localctx._expression);
						}
						}
						this.state = 3680;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
					break;
				case SparkSqlParser.RIGHT_PAREN:
				case SparkSqlParser.KW_DISTRIBUTE:
				case SparkSqlParser.KW_ORDER:
				case SparkSqlParser.KW_PARTITION:
				case SparkSqlParser.KW_RANGE:
				case SparkSqlParser.KW_ROWS:
				case SparkSqlParser.KW_SORT:
					{
					this.state = 3691;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION) {
						{
						this.state = 3681;
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION)) {
						this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 3682;
						this.match(SparkSqlParser.KW_BY);
						this.state = 3683;
						_localctx._expression = this.expression();
						_localctx._partition.push(_localctx._expression);
						this.state = 3688;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						while (_la === SparkSqlParser.COMMA) {
							{
							{
							this.state = 3684;
							this.match(SparkSqlParser.COMMA);
							this.state = 3685;
							_localctx._expression = this.expression();
							_localctx._partition.push(_localctx._expression);
							}
							}
							this.state = 3690;
							this._errHandler.sync(this);
							_la = this._input.LA(1);
						}
						}
					}

					this.state = 3703;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT) {
						{
						this.state = 3693;
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT)) {
						this._errHandler.recoverInline(this);
						} else {
							if (this._input.LA(1) === Token.EOF) {
								this.matchedEOF = true;
							}

							this._errHandler.reportMatch(this);
							this.consume();
						}
						this.state = 3694;
						this.match(SparkSqlParser.KW_BY);
						this.state = 3695;
						this.sortItem();
						this.state = 3700;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						while (_la === SparkSqlParser.COMMA) {
							{
							{
							this.state = 3696;
							this.match(SparkSqlParser.COMMA);
							this.state = 3697;
							this.sortItem();
							}
							}
							this.state = 3702;
							this._errHandler.sync(this);
							_la = this._input.LA(1);
						}
						}
					}

					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 3708;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_RANGE || _la === SparkSqlParser.KW_ROWS) {
					{
					this.state = 3707;
					this.windowFrame();
					}
				}

				this.state = 3710;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public windowFrame(): WindowFrameContext {
		let _localctx: WindowFrameContext = new WindowFrameContext(this._ctx, this.state);
		this.enterRule(_localctx, 356, SparkSqlParser.RULE_windowFrame);
		try {
			this.state = 3729;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 481, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3713;
				_localctx._frameType = this.match(SparkSqlParser.KW_RANGE);
				this.state = 3714;
				_localctx._start_ = this.frameBound();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3715;
				_localctx._frameType = this.match(SparkSqlParser.KW_ROWS);
				this.state = 3716;
				_localctx._start_ = this.frameBound();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3717;
				_localctx._frameType = this.match(SparkSqlParser.KW_RANGE);
				this.state = 3718;
				this.match(SparkSqlParser.KW_BETWEEN);
				this.state = 3719;
				_localctx._start_ = this.frameBound();
				this.state = 3720;
				this.match(SparkSqlParser.KW_AND);
				this.state = 3721;
				_localctx._end = this.frameBound();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3723;
				_localctx._frameType = this.match(SparkSqlParser.KW_ROWS);
				this.state = 3724;
				this.match(SparkSqlParser.KW_BETWEEN);
				this.state = 3725;
				_localctx._start_ = this.frameBound();
				this.state = 3726;
				this.match(SparkSqlParser.KW_AND);
				this.state = 3727;
				_localctx._end = this.frameBound();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public frameBound(): FrameBoundContext {
		let _localctx: FrameBoundContext = new FrameBoundContext(this._ctx, this.state);
		this.enterRule(_localctx, 358, SparkSqlParser.RULE_frameBound);
		let _la: number;
		try {
			this.state = 3738;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 482, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3731;
				this.match(SparkSqlParser.KW_UNBOUNDED);
				this.state = 3732;
				_localctx._boundType = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_FOLLOWING || _la === SparkSqlParser.KW_PRECEDING)) {
					_localctx._boundType = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3733;
				_localctx._boundType = this.match(SparkSqlParser.KW_CURRENT);
				this.state = 3734;
				this.match(SparkSqlParser.KW_ROW);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3735;
				this.expression();
				this.state = 3736;
				_localctx._boundType = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_FOLLOWING || _la === SparkSqlParser.KW_PRECEDING)) {
					_localctx._boundType = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public qualifiedNameList(): QualifiedNameListContext {
		let _localctx: QualifiedNameListContext = new QualifiedNameListContext(this._ctx, this.state);
		this.enterRule(_localctx, 360, SparkSqlParser.RULE_qualifiedNameList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3740;
			this.qualifiedName();
			this.state = 3745;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3741;
				this.match(SparkSqlParser.COMMA);
				this.state = 3742;
				this.qualifiedName();
				}
				}
				this.state = 3747;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionName(): FunctionNameContext {
		let _localctx: FunctionNameContext = new FunctionNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 362, SparkSqlParser.RULE_functionName);
		try {
			this.state = 3757;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 484, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3748;
				this.match(SparkSqlParser.KW_IDENTIFIER);
				this.state = 3749;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3750;
				this.expression();
				this.state = 3751;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3753;
				this.qualifiedName();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3754;
				this.match(SparkSqlParser.KW_FILTER);
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3755;
				this.match(SparkSqlParser.KW_LEFT);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3756;
				this.match(SparkSqlParser.KW_RIGHT);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public functionNameCreate(): FunctionNameCreateContext {
		let _localctx: FunctionNameCreateContext = new FunctionNameCreateContext(this._ctx, this.state);
		this.enterRule(_localctx, 364, SparkSqlParser.RULE_functionNameCreate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3759;
			this.qualifiedName();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public qualifiedName(): QualifiedNameContext {
		let _localctx: QualifiedNameContext = new QualifiedNameContext(this._ctx, this.state);
		this.enterRule(_localctx, 366, SparkSqlParser.RULE_qualifiedName);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3761;
			this.identifier();
			this.state = 3766;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 485, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3762;
					this.match(SparkSqlParser.DOT);
					this.state = 3763;
					this.identifier();
					}
					}
				}
				this.state = 3768;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 485, this._ctx);
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		let _localctx: ErrorCapturingIdentifierContext = new ErrorCapturingIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 368, SparkSqlParser.RULE_errorCapturingIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3769;
			this.identifier();
			this.state = 3770;
			this.errorCapturingIdentifierExtra();
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext {
		let _localctx: ErrorCapturingIdentifierExtraContext = new ErrorCapturingIdentifierExtraContext(this._ctx, this.state);
		this.enterRule(_localctx, 370, SparkSqlParser.RULE_errorCapturingIdentifierExtra);
		try {
			let _alt: number;
			this.state = 3779;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 487, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3774;
				this._errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						this.state = 3772;
						this.match(SparkSqlParser.MINUS);
						this.state = 3773;
						this.identifier();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					this.state = 3776;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 486, this._ctx);
				} while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				// tslint:disable-next-line:no-empty
				{
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public identifier(): IdentifierContext {
		let _localctx: IdentifierContext = new IdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 372, SparkSqlParser.RULE_identifier);
		try {
			this.state = 3783;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 488, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3781;
				this.strictIdentifier();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3782;
				this.strictNonReserved();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public strictIdentifier(): StrictIdentifierContext {
		let _localctx: StrictIdentifierContext = new StrictIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 374, SparkSqlParser.RULE_strictIdentifier);
		try {
			this.state = 3789;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 489, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3785;
				this.match(SparkSqlParser.IDENTIFIER);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3786;
				this.quotedIdentifier();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3787;
				this.ansiNonReserved();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3788;
				this.nonReserved();
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public quotedIdentifier(): QuotedIdentifierContext {
		let _localctx: QuotedIdentifierContext = new QuotedIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 376, SparkSqlParser.RULE_quotedIdentifier);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3791;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.DOUBLEQUOTED_STRING || _la === SparkSqlParser.BACKQUOTED_IDENTIFIER)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public backQuotedIdentifier(): BackQuotedIdentifierContext {
		let _localctx: BackQuotedIdentifierContext = new BackQuotedIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 378, SparkSqlParser.RULE_backQuotedIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3793;
			this.match(SparkSqlParser.BACKQUOTED_IDENTIFIER);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public number(): NumberContext {
		let _localctx: NumberContext = new NumberContext(this._ctx, this.state);
		this.enterRule(_localctx, 380, SparkSqlParser.RULE_number);
		let _la: number;
		try {
			this.state = 3835;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 500, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3796;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3795;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3798;
				this.match(SparkSqlParser.EXPONENT_VALUE);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3800;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3799;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3802;
				this.match(SparkSqlParser.DECIMAL_VALUE);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3804;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3803;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3806;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.EXPONENT_VALUE || _la === SparkSqlParser.DECIMAL_VALUE)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3808;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3807;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3810;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3812;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3811;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3814;
				this.match(SparkSqlParser.BIGINT_LITERAL);
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3816;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3815;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3818;
				this.match(SparkSqlParser.SMALLINT_LITERAL);
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 3820;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3819;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3822;
				this.match(SparkSqlParser.TINYINT_LITERAL);
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 3824;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3823;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3826;
				this.match(SparkSqlParser.DOUBLE_LITERAL);
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 3828;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3827;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3830;
				this.match(SparkSqlParser.FLOAT_LITERAL);
				}
				break;

			case 10:
				this.enterOuterAlt(_localctx, 10);
				{
				this.state = 3832;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3831;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3834;
				this.match(SparkSqlParser.BIGDECIMAL_LITERAL);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public alterColumnAction(): AlterColumnActionContext {
		let _localctx: AlterColumnActionContext = new AlterColumnActionContext(this._ctx, this.state);
		this.enterRule(_localctx, 382, SparkSqlParser.RULE_alterColumnAction);
		let _la: number;
		try {
			this.state = 3848;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 501, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3837;
				this.match(SparkSqlParser.KW_TYPE);
				this.state = 3838;
				this.dataType();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3839;
				this.commentSpec();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3840;
				this.colPosition();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3841;
				_localctx._setOrDrop = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_DROP || _la === SparkSqlParser.KW_SET)) {
					_localctx._setOrDrop = this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 3842;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3843;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3844;
				this.match(SparkSqlParser.KW_SET);
				this.state = 3845;
				this.defaultExpression();
				}
				break;

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3846;
				_localctx._dropDefault = this.match(SparkSqlParser.KW_DROP);
				this.state = 3847;
				this.match(SparkSqlParser.KW_DEFAULT);
				}
				break;
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public stringLit(): StringLitContext {
		let _localctx: StringLitContext = new StringLitContext(this._ctx, this.state);
		this.enterRule(_localctx, 384, SparkSqlParser.RULE_stringLit);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3850;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.STRING_LITERAL || _la === SparkSqlParser.DOUBLEQUOTED_STRING)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public comment(): CommentContext {
		let _localctx: CommentContext = new CommentContext(this._ctx, this.state);
		this.enterRule(_localctx, 386, SparkSqlParser.RULE_comment);
		try {
			this.state = 3854;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.STRING_LITERAL:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3852;
				this.stringLit();
				}
				break;
			case SparkSqlParser.KW_NULL:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3853;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public version(): VersionContext {
		let _localctx: VersionContext = new VersionContext(this._ctx, this.state);
		this.enterRule(_localctx, 388, SparkSqlParser.RULE_version);
		try {
			this.state = 3858;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.INTEGER_VALUE:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3856;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;
			case SparkSqlParser.STRING_LITERAL:
			case SparkSqlParser.DOUBLEQUOTED_STRING:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3857;
				this.stringLit();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public ansiNonReserved(): AnsiNonReservedContext {
		let _localctx: AnsiNonReservedContext = new AnsiNonReservedContext(this._ctx, this.state);
		this.enterRule(_localctx, 390, SparkSqlParser.RULE_ansiNonReserved);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3860;
			_la = this._input.LA(1);
			if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_ANTI) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)))) !== 0) || ((((_la - 67)) & ~0x1F) === 0 && ((1 << (_la - 67)) & ((1 << (SparkSqlParser.KW_DAY - 67)) | (1 << (SparkSqlParser.KW_DAYS - 67)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 67)) | (1 << (SparkSqlParser.KW_DATA - 67)) | (1 << (SparkSqlParser.KW_DATE - 67)) | (1 << (SparkSqlParser.KW_DATABASE - 67)) | (1 << (SparkSqlParser.KW_DATABASES - 67)) | (1 << (SparkSqlParser.KW_DATEADD - 67)) | (1 << (SparkSqlParser.KW_DATE_ADD - 67)) | (1 << (SparkSqlParser.KW_DATEDIFF - 67)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 67)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 67)) | (1 << (SparkSqlParser.KW_DEC - 67)) | (1 << (SparkSqlParser.KW_DECIMAL - 67)) | (1 << (SparkSqlParser.KW_DECLARE - 67)) | (1 << (SparkSqlParser.KW_DEFAULT - 67)) | (1 << (SparkSqlParser.KW_DEFINED - 67)) | (1 << (SparkSqlParser.KW_DELETE - 67)) | (1 << (SparkSqlParser.KW_DELIMITED - 67)) | (1 << (SparkSqlParser.KW_DESC - 67)) | (1 << (SparkSqlParser.KW_DESCRIBE - 67)) | (1 << (SparkSqlParser.KW_DFS - 67)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 67)) | (1 << (SparkSqlParser.KW_DIRECTORY - 67)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 67)) | (1 << (SparkSqlParser.KW_DIV - 67)) | (1 << (SparkSqlParser.KW_DOUBLE - 67)) | (1 << (SparkSqlParser.KW_DROP - 67)))) !== 0) || ((((_la - 99)) & ~0x1F) === 0 && ((1 << (_la - 99)) & ((1 << (SparkSqlParser.KW_ESCAPED - 99)) | (1 << (SparkSqlParser.KW_EXCHANGE - 99)) | (1 << (SparkSqlParser.KW_EXCLUDE - 99)) | (1 << (SparkSqlParser.KW_EXISTS - 99)) | (1 << (SparkSqlParser.KW_EXPLAIN - 99)) | (1 << (SparkSqlParser.KW_EXPORT - 99)) | (1 << (SparkSqlParser.KW_EXTENDED - 99)) | (1 << (SparkSqlParser.KW_EXTERNAL - 99)) | (1 << (SparkSqlParser.KW_EXTRACT - 99)) | (1 << (SparkSqlParser.KW_FIELDS - 99)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 99)) | (1 << (SparkSqlParser.KW_FIRST - 99)) | (1 << (SparkSqlParser.KW_FLOAT - 99)) | (1 << (SparkSqlParser.KW_FOLLOWING - 99)) | (1 << (SparkSqlParser.KW_FORMAT - 99)) | (1 << (SparkSqlParser.KW_FORMATTED - 99)) | (1 << (SparkSqlParser.KW_FUNCTION - 99)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 99)) | (1 << (SparkSqlParser.KW_GENERATED - 99)) | (1 << (SparkSqlParser.KW_GLOBAL - 99)) | (1 << (SparkSqlParser.KW_GROUPING - 99)))) !== 0) || ((((_la - 131)) & ~0x1F) === 0 && ((1 << (_la - 131)) & ((1 << (SparkSqlParser.KW_BINARY_HEX - 131)) | (1 << (SparkSqlParser.KW_HOUR - 131)) | (1 << (SparkSqlParser.KW_HOURS - 131)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 131)) | (1 << (SparkSqlParser.KW_IF - 131)) | (1 << (SparkSqlParser.KW_IGNORE - 131)) | (1 << (SparkSqlParser.KW_IMPORT - 131)) | (1 << (SparkSqlParser.KW_INCLUDE - 131)) | (1 << (SparkSqlParser.KW_INDEX - 131)) | (1 << (SparkSqlParser.KW_INDEXES - 131)) | (1 << (SparkSqlParser.KW_INPATH - 131)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 131)) | (1 << (SparkSqlParser.KW_INSERT - 131)) | (1 << (SparkSqlParser.KW_INTERVAL - 131)) | (1 << (SparkSqlParser.KW_INT - 131)) | (1 << (SparkSqlParser.KW_INTEGER - 131)) | (1 << (SparkSqlParser.KW_ITEMS - 131)) | (1 << (SparkSqlParser.KW_KEYS - 131)) | (1 << (SparkSqlParser.KW_LAST - 131)) | (1 << (SparkSqlParser.KW_LAZY - 131)) | (1 << (SparkSqlParser.KW_LIKE - 131)) | (1 << (SparkSqlParser.KW_ILIKE - 131)) | (1 << (SparkSqlParser.KW_LIMIT - 131)))) !== 0) || ((((_la - 163)) & ~0x1F) === 0 && ((1 << (_la - 163)) & ((1 << (SparkSqlParser.KW_LINES - 163)) | (1 << (SparkSqlParser.KW_LIST - 163)) | (1 << (SparkSqlParser.KW_LOAD - 163)) | (1 << (SparkSqlParser.KW_LOCAL - 163)) | (1 << (SparkSqlParser.KW_LOCATION - 163)) | (1 << (SparkSqlParser.KW_LOCK - 163)) | (1 << (SparkSqlParser.KW_LOCKS - 163)) | (1 << (SparkSqlParser.KW_LOGICAL - 163)) | (1 << (SparkSqlParser.KW_LONG - 163)) | (1 << (SparkSqlParser.KW_MACRO - 163)) | (1 << (SparkSqlParser.KW_MAP - 163)) | (1 << (SparkSqlParser.KW_MATCHED - 163)) | (1 << (SparkSqlParser.KW_MERGE - 163)) | (1 << (SparkSqlParser.KW_MICROSECOND - 163)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 163)) | (1 << (SparkSqlParser.KW_MILLISECOND - 163)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 163)) | (1 << (SparkSqlParser.KW_MINUTE - 163)) | (1 << (SparkSqlParser.KW_MINUTES - 163)) | (1 << (SparkSqlParser.KW_MONTH - 163)) | (1 << (SparkSqlParser.KW_MONTHS - 163)) | (1 << (SparkSqlParser.KW_MSCK - 163)) | (1 << (SparkSqlParser.KW_NAME - 163)) | (1 << (SparkSqlParser.KW_NAMESPACE - 163)) | (1 << (SparkSqlParser.KW_NAMESPACES - 163)) | (1 << (SparkSqlParser.KW_NANOSECOND - 163)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 163)) | (1 << (SparkSqlParser.KW_NO - 163)))) !== 0) || ((((_la - 195)) & ~0x1F) === 0 && ((1 << (_la - 195)) & ((1 << (SparkSqlParser.KW_NULLS - 195)) | (1 << (SparkSqlParser.KW_NUMERIC - 195)) | (1 << (SparkSqlParser.KW_OF - 195)) | (1 << (SparkSqlParser.KW_OPTION - 195)) | (1 << (SparkSqlParser.KW_OPTIONS - 195)) | (1 << (SparkSqlParser.KW_OUT - 195)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 195)) | (1 << (SparkSqlParser.KW_OVER - 195)) | (1 << (SparkSqlParser.KW_OVERLAY - 195)) | (1 << (SparkSqlParser.KW_OVERWRITE - 195)) | (1 << (SparkSqlParser.KW_PARTITION - 195)) | (1 << (SparkSqlParser.KW_PARTITIONED - 195)) | (1 << (SparkSqlParser.KW_PARTITIONS - 195)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 195)) | (1 << (SparkSqlParser.KW_PIVOT - 195)) | (1 << (SparkSqlParser.KW_PLACING - 195)) | (1 << (SparkSqlParser.KW_POSITION - 195)) | (1 << (SparkSqlParser.KW_PRECEDING - 195)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 195)) | (1 << (SparkSqlParser.KW_PROPERTIES - 195)) | (1 << (SparkSqlParser.KW_PURGE - 195)) | (1 << (SparkSqlParser.KW_QUARTER - 195)))) !== 0) || ((((_la - 227)) & ~0x1F) === 0 && ((1 << (_la - 227)) & ((1 << (SparkSqlParser.KW_QUERY - 227)) | (1 << (SparkSqlParser.KW_RANGE - 227)) | (1 << (SparkSqlParser.KW_REAL - 227)) | (1 << (SparkSqlParser.KW_RECORDREADER - 227)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 227)) | (1 << (SparkSqlParser.KW_RECOVER - 227)) | (1 << (SparkSqlParser.KW_REDUCE - 227)) | (1 << (SparkSqlParser.KW_REFRESH - 227)) | (1 << (SparkSqlParser.KW_RENAME - 227)) | (1 << (SparkSqlParser.KW_REPAIR - 227)) | (1 << (SparkSqlParser.KW_REPEATABLE - 227)) | (1 << (SparkSqlParser.KW_REPLACE - 227)) | (1 << (SparkSqlParser.KW_RESET - 227)) | (1 << (SparkSqlParser.KW_RESPECT - 227)) | (1 << (SparkSqlParser.KW_RESTRICT - 227)) | (1 << (SparkSqlParser.KW_REVOKE - 227)) | (1 << (SparkSqlParser.KW_RLIKE - 227)) | (1 << (SparkSqlParser.KW_REGEXP - 227)) | (1 << (SparkSqlParser.KW_ROLE - 227)) | (1 << (SparkSqlParser.KW_ROLES - 227)) | (1 << (SparkSqlParser.KW_ROLLBACK - 227)) | (1 << (SparkSqlParser.KW_ROLLUP - 227)) | (1 << (SparkSqlParser.KW_ROW - 227)) | (1 << (SparkSqlParser.KW_ROWS - 227)) | (1 << (SparkSqlParser.KW_SECOND - 227)) | (1 << (SparkSqlParser.KW_SECONDS - 227)) | (1 << (SparkSqlParser.KW_SCHEMA - 227)) | (1 << (SparkSqlParser.KW_SCHEMAS - 227)) | (1 << (SparkSqlParser.KW_SEMI - 227)))) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & ((1 << (SparkSqlParser.KW_SEPARATED - 259)) | (1 << (SparkSqlParser.KW_SERDE - 259)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 259)) | (1 << (SparkSqlParser.KW_SET - 259)) | (1 << (SparkSqlParser.KW_MINUS - 259)) | (1 << (SparkSqlParser.KW_SETS - 259)) | (1 << (SparkSqlParser.KW_SHORT - 259)) | (1 << (SparkSqlParser.KW_SHOW - 259)) | (1 << (SparkSqlParser.KW_SINGLE - 259)) | (1 << (SparkSqlParser.KW_SKEWED - 259)) | (1 << (SparkSqlParser.KW_SMALLINT - 259)) | (1 << (SparkSqlParser.KW_SORT - 259)) | (1 << (SparkSqlParser.KW_SORTED - 259)) | (1 << (SparkSqlParser.KW_SOURCE - 259)) | (1 << (SparkSqlParser.KW_START - 259)) | (1 << (SparkSqlParser.KW_STATISTICS - 259)) | (1 << (SparkSqlParser.KW_STORED - 259)) | (1 << (SparkSqlParser.KW_STRATIFY - 259)) | (1 << (SparkSqlParser.KW_STRING - 259)) | (1 << (SparkSqlParser.KW_STRUCT - 259)) | (1 << (SparkSqlParser.KW_SUBSTR - 259)) | (1 << (SparkSqlParser.KW_SUBSTRING - 259)) | (1 << (SparkSqlParser.KW_SYNC - 259)) | (1 << (SparkSqlParser.KW_SYSTEM - 259)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 259)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 259)) | (1 << (SparkSqlParser.KW_TABLES - 259)) | (1 << (SparkSqlParser.KW_TABLESAMPLE - 259)) | (1 << (SparkSqlParser.KW_TARGET - 259)))) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 291)) & ((1 << (SparkSqlParser.KW_TBLPROPERTIES - 291)) | (1 << (SparkSqlParser.KW_TEMPORARY - 291)) | (1 << (SparkSqlParser.KW_TERMINATED - 291)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 291)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 291)) | (1 << (SparkSqlParser.KW_TINYINT - 291)) | (1 << (SparkSqlParser.KW_TOUCH - 291)) | (1 << (SparkSqlParser.KW_TRANSACTION - 291)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 291)) | (1 << (SparkSqlParser.KW_TRANSFORM - 291)) | (1 << (SparkSqlParser.KW_TRIM - 291)) | (1 << (SparkSqlParser.KW_TRUE - 291)) | (1 << (SparkSqlParser.KW_TRUNCATE - 291)) | (1 << (SparkSqlParser.KW_TRY_CAST - 291)) | (1 << (SparkSqlParser.KW_TYPE - 291)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 291)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 291)) | (1 << (SparkSqlParser.KW_UNCACHE - 291)) | (1 << (SparkSqlParser.KW_UNLOCK - 291)) | (1 << (SparkSqlParser.KW_UNPIVOT - 291)) | (1 << (SparkSqlParser.KW_UNSET - 291)))) !== 0) || ((((_la - 323)) & ~0x1F) === 0 && ((1 << (_la - 323)) & ((1 << (SparkSqlParser.KW_UPDATE - 323)) | (1 << (SparkSqlParser.KW_USE - 323)) | (1 << (SparkSqlParser.KW_VALUES - 323)) | (1 << (SparkSqlParser.KW_VARCHAR - 323)) | (1 << (SparkSqlParser.KW_VAR - 323)) | (1 << (SparkSqlParser.KW_VARIABLE - 323)) | (1 << (SparkSqlParser.KW_VERSION - 323)) | (1 << (SparkSqlParser.KW_VIEW - 323)) | (1 << (SparkSqlParser.KW_VIEWS - 323)) | (1 << (SparkSqlParser.KW_VOID - 323)) | (1 << (SparkSqlParser.KW_WEEK - 323)) | (1 << (SparkSqlParser.KW_WEEKS - 323)) | (1 << (SparkSqlParser.KW_WINDOW - 323)) | (1 << (SparkSqlParser.KW_YEAR - 323)) | (1 << (SparkSqlParser.KW_YEARS - 323)) | (1 << (SparkSqlParser.KW_ZONE - 323)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public strictNonReserved(): StrictNonReservedContext {
		let _localctx: StrictNonReservedContext = new StrictNonReservedContext(this._ctx, this.state);
		this.enterRule(_localctx, 392, SparkSqlParser.RULE_strictNonReserved);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3862;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_ANTI || _la === SparkSqlParser.KW_CROSS || _la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_FULL || ((((_la - 142)) & ~0x1F) === 0 && ((1 << (_la - 142)) & ((1 << (SparkSqlParser.KW_INNER - 142)) | (1 << (SparkSqlParser.KW_INTERSECT - 142)) | (1 << (SparkSqlParser.KW_JOIN - 142)) | (1 << (SparkSqlParser.KW_LATERAL - 142)) | (1 << (SparkSqlParser.KW_LEFT - 142)))) !== 0) || _la === SparkSqlParser.KW_NATURAL || _la === SparkSqlParser.KW_ON || ((((_la - 244)) & ~0x1F) === 0 && ((1 << (_la - 244)) & ((1 << (SparkSqlParser.KW_RIGHT - 244)) | (1 << (SparkSqlParser.KW_SEMI - 244)) | (1 << (SparkSqlParser.KW_MINUS - 244)))) !== 0) || _la === SparkSqlParser.KW_UNION || _la === SparkSqlParser.KW_USING)) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}
	// @RuleVersion(0)
	public nonReserved(): NonReservedContext {
		let _localctx: NonReservedContext = new NonReservedContext(this._ctx, this.state);
		this.enterRule(_localctx, 394, SparkSqlParser.RULE_nonReserved);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3864;
			_la = this._input.LA(1);
			if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << SparkSqlParser.KW_ADD) | (1 << SparkSqlParser.KW_AFTER) | (1 << SparkSqlParser.KW_ALL) | (1 << SparkSqlParser.KW_ALTER) | (1 << SparkSqlParser.KW_ALWAYS) | (1 << SparkSqlParser.KW_ANALYZE) | (1 << SparkSqlParser.KW_AND) | (1 << SparkSqlParser.KW_ANY) | (1 << SparkSqlParser.KW_ANY_VALUE) | (1 << SparkSqlParser.KW_ARCHIVE) | (1 << SparkSqlParser.KW_ARRAY) | (1 << SparkSqlParser.KW_AS) | (1 << SparkSqlParser.KW_ASC) | (1 << SparkSqlParser.KW_AT) | (1 << SparkSqlParser.KW_AUTHORIZATION) | (1 << SparkSqlParser.KW_BETWEEN) | (1 << SparkSqlParser.KW_BIGINT) | (1 << SparkSqlParser.KW_BINARY) | (1 << SparkSqlParser.KW_BOOLEAN) | (1 << SparkSqlParser.KW_BOTH) | (1 << SparkSqlParser.KW_BUCKET) | (1 << SparkSqlParser.KW_BUCKETS) | (1 << SparkSqlParser.KW_BY))) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (SparkSqlParser.KW_BYTE - 32)) | (1 << (SparkSqlParser.KW_CACHE - 32)) | (1 << (SparkSqlParser.KW_CASCADE - 32)) | (1 << (SparkSqlParser.KW_CASE - 32)) | (1 << (SparkSqlParser.KW_CAST - 32)) | (1 << (SparkSqlParser.KW_CATALOG - 32)) | (1 << (SparkSqlParser.KW_CATALOGS - 32)) | (1 << (SparkSqlParser.KW_CHANGE - 32)) | (1 << (SparkSqlParser.KW_CHAR - 32)) | (1 << (SparkSqlParser.KW_CHARACTER - 32)) | (1 << (SparkSqlParser.KW_CHECK - 32)) | (1 << (SparkSqlParser.KW_CLEAR - 32)) | (1 << (SparkSqlParser.KW_CLUSTER - 32)) | (1 << (SparkSqlParser.KW_CLUSTERED - 32)) | (1 << (SparkSqlParser.KW_CODEGEN - 32)) | (1 << (SparkSqlParser.KW_COLLATE - 32)) | (1 << (SparkSqlParser.KW_COLLECTION - 32)) | (1 << (SparkSqlParser.KW_COLUMN - 32)) | (1 << (SparkSqlParser.KW_COLUMNS - 32)) | (1 << (SparkSqlParser.KW_COMMENT - 32)) | (1 << (SparkSqlParser.KW_COMMIT - 32)) | (1 << (SparkSqlParser.KW_COMPACT - 32)) | (1 << (SparkSqlParser.KW_COMPACTIONS - 32)) | (1 << (SparkSqlParser.KW_COMPUTE - 32)) | (1 << (SparkSqlParser.KW_CONCATENATE - 32)) | (1 << (SparkSqlParser.KW_CONSTRAINT - 32)) | (1 << (SparkSqlParser.KW_COST - 32)) | (1 << (SparkSqlParser.KW_CREATE - 32)) | (1 << (SparkSqlParser.KW_CUBE - 32)) | (1 << (SparkSqlParser.KW_CURRENT - 32)) | (1 << (SparkSqlParser.KW_CURRENT_DATE - 32)))) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & ((1 << (SparkSqlParser.KW_CURRENT_TIME - 64)) | (1 << (SparkSqlParser.KW_CURRENT_TIMESTAMP - 64)) | (1 << (SparkSqlParser.KW_CURRENT_USER - 64)) | (1 << (SparkSqlParser.KW_DAY - 64)) | (1 << (SparkSqlParser.KW_DAYS - 64)) | (1 << (SparkSqlParser.KW_DAYOFYEAR - 64)) | (1 << (SparkSqlParser.KW_DATA - 64)) | (1 << (SparkSqlParser.KW_DATE - 64)) | (1 << (SparkSqlParser.KW_DATABASE - 64)) | (1 << (SparkSqlParser.KW_DATABASES - 64)) | (1 << (SparkSqlParser.KW_DATEADD - 64)) | (1 << (SparkSqlParser.KW_DATE_ADD - 64)) | (1 << (SparkSqlParser.KW_DATEDIFF - 64)) | (1 << (SparkSqlParser.KW_DATE_DIFF - 64)) | (1 << (SparkSqlParser.KW_DBPROPERTIES - 64)) | (1 << (SparkSqlParser.KW_DEC - 64)) | (1 << (SparkSqlParser.KW_DECIMAL - 64)) | (1 << (SparkSqlParser.KW_DECLARE - 64)) | (1 << (SparkSqlParser.KW_DEFAULT - 64)) | (1 << (SparkSqlParser.KW_DEFINED - 64)) | (1 << (SparkSqlParser.KW_DELETE - 64)) | (1 << (SparkSqlParser.KW_DELIMITED - 64)) | (1 << (SparkSqlParser.KW_DESC - 64)) | (1 << (SparkSqlParser.KW_DESCRIBE - 64)) | (1 << (SparkSqlParser.KW_DFS - 64)) | (1 << (SparkSqlParser.KW_DIRECTORIES - 64)) | (1 << (SparkSqlParser.KW_DIRECTORY - 64)) | (1 << (SparkSqlParser.KW_DISTINCT - 64)) | (1 << (SparkSqlParser.KW_DISTRIBUTE - 64)) | (1 << (SparkSqlParser.KW_DIV - 64)) | (1 << (SparkSqlParser.KW_DOUBLE - 64)) | (1 << (SparkSqlParser.KW_DROP - 64)))) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & ((1 << (SparkSqlParser.KW_ELSE - 96)) | (1 << (SparkSqlParser.KW_END - 96)) | (1 << (SparkSqlParser.KW_ESCAPE - 96)) | (1 << (SparkSqlParser.KW_ESCAPED - 96)) | (1 << (SparkSqlParser.KW_EXCHANGE - 96)) | (1 << (SparkSqlParser.KW_EXCLUDE - 96)) | (1 << (SparkSqlParser.KW_EXISTS - 96)) | (1 << (SparkSqlParser.KW_EXPLAIN - 96)) | (1 << (SparkSqlParser.KW_EXPORT - 96)) | (1 << (SparkSqlParser.KW_EXTENDED - 96)) | (1 << (SparkSqlParser.KW_EXTERNAL - 96)) | (1 << (SparkSqlParser.KW_EXTRACT - 96)) | (1 << (SparkSqlParser.KW_FALSE - 96)) | (1 << (SparkSqlParser.KW_FETCH - 96)) | (1 << (SparkSqlParser.KW_FIELDS - 96)) | (1 << (SparkSqlParser.KW_FILTER - 96)) | (1 << (SparkSqlParser.KW_FILEFORMAT - 96)) | (1 << (SparkSqlParser.KW_FIRST - 96)) | (1 << (SparkSqlParser.KW_FLOAT - 96)) | (1 << (SparkSqlParser.KW_FOLLOWING - 96)) | (1 << (SparkSqlParser.KW_FOR - 96)) | (1 << (SparkSqlParser.KW_FOREIGN - 96)) | (1 << (SparkSqlParser.KW_FORMAT - 96)) | (1 << (SparkSqlParser.KW_FORMATTED - 96)) | (1 << (SparkSqlParser.KW_FROM - 96)) | (1 << (SparkSqlParser.KW_FUNCTION - 96)) | (1 << (SparkSqlParser.KW_FUNCTIONS - 96)) | (1 << (SparkSqlParser.KW_GENERATED - 96)) | (1 << (SparkSqlParser.KW_GLOBAL - 96)) | (1 << (SparkSqlParser.KW_GRANT - 96)))) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & ((1 << (SparkSqlParser.KW_GROUP - 128)) | (1 << (SparkSqlParser.KW_GROUPING - 128)) | (1 << (SparkSqlParser.KW_HAVING - 128)) | (1 << (SparkSqlParser.KW_BINARY_HEX - 128)) | (1 << (SparkSqlParser.KW_HOUR - 128)) | (1 << (SparkSqlParser.KW_HOURS - 128)) | (1 << (SparkSqlParser.KW_IDENTIFIER - 128)) | (1 << (SparkSqlParser.KW_IF - 128)) | (1 << (SparkSqlParser.KW_IGNORE - 128)) | (1 << (SparkSqlParser.KW_IMPORT - 128)) | (1 << (SparkSqlParser.KW_IN - 128)) | (1 << (SparkSqlParser.KW_INCLUDE - 128)) | (1 << (SparkSqlParser.KW_INDEX - 128)) | (1 << (SparkSqlParser.KW_INDEXES - 128)) | (1 << (SparkSqlParser.KW_INPATH - 128)) | (1 << (SparkSqlParser.KW_INPUTFORMAT - 128)) | (1 << (SparkSqlParser.KW_INSERT - 128)) | (1 << (SparkSqlParser.KW_INTERVAL - 128)) | (1 << (SparkSqlParser.KW_INT - 128)) | (1 << (SparkSqlParser.KW_INTEGER - 128)) | (1 << (SparkSqlParser.KW_INTO - 128)) | (1 << (SparkSqlParser.KW_IS - 128)) | (1 << (SparkSqlParser.KW_ITEMS - 128)) | (1 << (SparkSqlParser.KW_KEYS - 128)) | (1 << (SparkSqlParser.KW_LAST - 128)) | (1 << (SparkSqlParser.KW_LAZY - 128)) | (1 << (SparkSqlParser.KW_LEADING - 128)))) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (SparkSqlParser.KW_LIKE - 160)) | (1 << (SparkSqlParser.KW_ILIKE - 160)) | (1 << (SparkSqlParser.KW_LIMIT - 160)) | (1 << (SparkSqlParser.KW_LINES - 160)) | (1 << (SparkSqlParser.KW_LIST - 160)) | (1 << (SparkSqlParser.KW_LOAD - 160)) | (1 << (SparkSqlParser.KW_LOCAL - 160)) | (1 << (SparkSqlParser.KW_LOCATION - 160)) | (1 << (SparkSqlParser.KW_LOCK - 160)) | (1 << (SparkSqlParser.KW_LOCKS - 160)) | (1 << (SparkSqlParser.KW_LOGICAL - 160)) | (1 << (SparkSqlParser.KW_LONG - 160)) | (1 << (SparkSqlParser.KW_MACRO - 160)) | (1 << (SparkSqlParser.KW_MAP - 160)) | (1 << (SparkSqlParser.KW_MATCHED - 160)) | (1 << (SparkSqlParser.KW_MERGE - 160)) | (1 << (SparkSqlParser.KW_MICROSECOND - 160)) | (1 << (SparkSqlParser.KW_MICROSECONDS - 160)) | (1 << (SparkSqlParser.KW_MILLISECOND - 160)) | (1 << (SparkSqlParser.KW_MILLISECONDS - 160)) | (1 << (SparkSqlParser.KW_MINUTE - 160)) | (1 << (SparkSqlParser.KW_MINUTES - 160)) | (1 << (SparkSqlParser.KW_MONTH - 160)) | (1 << (SparkSqlParser.KW_MONTHS - 160)) | (1 << (SparkSqlParser.KW_MSCK - 160)) | (1 << (SparkSqlParser.KW_NAME - 160)) | (1 << (SparkSqlParser.KW_NAMESPACE - 160)) | (1 << (SparkSqlParser.KW_NAMESPACES - 160)) | (1 << (SparkSqlParser.KW_NANOSECOND - 160)) | (1 << (SparkSqlParser.KW_NANOSECONDS - 160)) | (1 << (SparkSqlParser.KW_NO - 160)))) !== 0) || ((((_la - 193)) & ~0x1F) === 0 && ((1 << (_la - 193)) & ((1 << (SparkSqlParser.KW_NOT - 193)) | (1 << (SparkSqlParser.KW_NULL - 193)) | (1 << (SparkSqlParser.KW_NULLS - 193)) | (1 << (SparkSqlParser.KW_NUMERIC - 193)) | (1 << (SparkSqlParser.KW_OF - 193)) | (1 << (SparkSqlParser.KW_OFFSET - 193)) | (1 << (SparkSqlParser.KW_ONLY - 193)) | (1 << (SparkSqlParser.KW_OPTION - 193)) | (1 << (SparkSqlParser.KW_OPTIONS - 193)) | (1 << (SparkSqlParser.KW_OR - 193)) | (1 << (SparkSqlParser.KW_ORDER - 193)) | (1 << (SparkSqlParser.KW_OUT - 193)) | (1 << (SparkSqlParser.KW_OUTER - 193)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 193)) | (1 << (SparkSqlParser.KW_OVER - 193)) | (1 << (SparkSqlParser.KW_OVERLAPS - 193)) | (1 << (SparkSqlParser.KW_OVERLAY - 193)) | (1 << (SparkSqlParser.KW_OVERWRITE - 193)) | (1 << (SparkSqlParser.KW_PARTITION - 193)) | (1 << (SparkSqlParser.KW_PARTITIONED - 193)) | (1 << (SparkSqlParser.KW_PARTITIONS - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 193)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 193)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 193)) | (1 << (SparkSqlParser.KW_PIVOT - 193)) | (1 << (SparkSqlParser.KW_PLACING - 193)) | (1 << (SparkSqlParser.KW_POSITION - 193)) | (1 << (SparkSqlParser.KW_PRECEDING - 193)) | (1 << (SparkSqlParser.KW_PRIMARY - 193)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 193)) | (1 << (SparkSqlParser.KW_PROPERTIES - 193)))) !== 0) || ((((_la - 225)) & ~0x1F) === 0 && ((1 << (_la - 225)) & ((1 << (SparkSqlParser.KW_PURGE - 225)) | (1 << (SparkSqlParser.KW_QUARTER - 225)) | (1 << (SparkSqlParser.KW_QUERY - 225)) | (1 << (SparkSqlParser.KW_RANGE - 225)) | (1 << (SparkSqlParser.KW_REAL - 225)) | (1 << (SparkSqlParser.KW_RECORDREADER - 225)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 225)) | (1 << (SparkSqlParser.KW_RECOVER - 225)) | (1 << (SparkSqlParser.KW_REDUCE - 225)) | (1 << (SparkSqlParser.KW_REFERENCES - 225)) | (1 << (SparkSqlParser.KW_REFRESH - 225)) | (1 << (SparkSqlParser.KW_RENAME - 225)) | (1 << (SparkSqlParser.KW_REPAIR - 225)) | (1 << (SparkSqlParser.KW_REPEATABLE - 225)) | (1 << (SparkSqlParser.KW_REPLACE - 225)) | (1 << (SparkSqlParser.KW_RESET - 225)) | (1 << (SparkSqlParser.KW_RESPECT - 225)) | (1 << (SparkSqlParser.KW_RESTRICT - 225)) | (1 << (SparkSqlParser.KW_REVOKE - 225)) | (1 << (SparkSqlParser.KW_RLIKE - 225)) | (1 << (SparkSqlParser.KW_REGEXP - 225)) | (1 << (SparkSqlParser.KW_ROLE - 225)) | (1 << (SparkSqlParser.KW_ROLES - 225)) | (1 << (SparkSqlParser.KW_ROLLBACK - 225)) | (1 << (SparkSqlParser.KW_ROLLUP - 225)) | (1 << (SparkSqlParser.KW_ROW - 225)) | (1 << (SparkSqlParser.KW_ROWS - 225)) | (1 << (SparkSqlParser.KW_SECOND - 225)) | (1 << (SparkSqlParser.KW_SECONDS - 225)) | (1 << (SparkSqlParser.KW_SCHEMA - 225)) | (1 << (SparkSqlParser.KW_SCHEMAS - 225)))) !== 0) || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & ((1 << (SparkSqlParser.KW_SELECT - 257)) | (1 << (SparkSqlParser.KW_SEPARATED - 257)) | (1 << (SparkSqlParser.KW_SERDE - 257)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 257)) | (1 << (SparkSqlParser.KW_SESSION_USER - 257)) | (1 << (SparkSqlParser.KW_SET - 257)) | (1 << (SparkSqlParser.KW_SETS - 257)) | (1 << (SparkSqlParser.KW_SHORT - 257)) | (1 << (SparkSqlParser.KW_SHOW - 257)) | (1 << (SparkSqlParser.KW_SINGLE - 257)) | (1 << (SparkSqlParser.KW_SKEWED - 257)) | (1 << (SparkSqlParser.KW_SMALLINT - 257)) | (1 << (SparkSqlParser.KW_SOME - 257)) | (1 << (SparkSqlParser.KW_SORT - 257)) | (1 << (SparkSqlParser.KW_SORTED - 257)) | (1 << (SparkSqlParser.KW_SOURCE - 257)) | (1 << (SparkSqlParser.KW_START - 257)) | (1 << (SparkSqlParser.KW_STATISTICS - 257)) | (1 << (SparkSqlParser.KW_STORED - 257)) | (1 << (SparkSqlParser.KW_STRATIFY - 257)) | (1 << (SparkSqlParser.KW_STRING - 257)) | (1 << (SparkSqlParser.KW_STRUCT - 257)) | (1 << (SparkSqlParser.KW_SUBSTR - 257)) | (1 << (SparkSqlParser.KW_SUBSTRING - 257)) | (1 << (SparkSqlParser.KW_SYNC - 257)) | (1 << (SparkSqlParser.KW_SYSTEM - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 257)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 257)) | (1 << (SparkSqlParser.KW_TABLE - 257)) | (1 << (SparkSqlParser.KW_TABLES - 257)))) !== 0) || ((((_la - 289)) & ~0x1F) === 0 && ((1 << (_la - 289)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 289)) | (1 << (SparkSqlParser.KW_TARGET - 289)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 289)) | (1 << (SparkSqlParser.KW_TEMPORARY - 289)) | (1 << (SparkSqlParser.KW_TERMINATED - 289)) | (1 << (SparkSqlParser.KW_THEN - 289)) | (1 << (SparkSqlParser.KW_TIME - 289)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 289)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 289)) | (1 << (SparkSqlParser.KW_TINYINT - 289)) | (1 << (SparkSqlParser.KW_TO - 289)) | (1 << (SparkSqlParser.KW_TOUCH - 289)) | (1 << (SparkSqlParser.KW_TRAILING - 289)) | (1 << (SparkSqlParser.KW_TRANSACTION - 289)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 289)) | (1 << (SparkSqlParser.KW_TRANSFORM - 289)) | (1 << (SparkSqlParser.KW_TRIM - 289)) | (1 << (SparkSqlParser.KW_TRUE - 289)) | (1 << (SparkSqlParser.KW_TRUNCATE - 289)) | (1 << (SparkSqlParser.KW_TRY_CAST - 289)) | (1 << (SparkSqlParser.KW_TYPE - 289)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 289)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 289)) | (1 << (SparkSqlParser.KW_UNCACHE - 289)) | (1 << (SparkSqlParser.KW_UNIQUE - 289)) | (1 << (SparkSqlParser.KW_UNKNOWN - 289)) | (1 << (SparkSqlParser.KW_UNLOCK - 289)))) !== 0) || ((((_la - 321)) & ~0x1F) === 0 && ((1 << (_la - 321)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 321)) | (1 << (SparkSqlParser.KW_UNSET - 321)) | (1 << (SparkSqlParser.KW_UPDATE - 321)) | (1 << (SparkSqlParser.KW_USE - 321)) | (1 << (SparkSqlParser.KW_USER - 321)) | (1 << (SparkSqlParser.KW_VALUES - 321)) | (1 << (SparkSqlParser.KW_VARCHAR - 321)) | (1 << (SparkSqlParser.KW_VAR - 321)) | (1 << (SparkSqlParser.KW_VARIABLE - 321)) | (1 << (SparkSqlParser.KW_VERSION - 321)) | (1 << (SparkSqlParser.KW_VIEW - 321)) | (1 << (SparkSqlParser.KW_VIEWS - 321)) | (1 << (SparkSqlParser.KW_VOID - 321)) | (1 << (SparkSqlParser.KW_WEEK - 321)) | (1 << (SparkSqlParser.KW_WEEKS - 321)) | (1 << (SparkSqlParser.KW_WHEN - 321)) | (1 << (SparkSqlParser.KW_WHERE - 321)) | (1 << (SparkSqlParser.KW_WINDOW - 321)) | (1 << (SparkSqlParser.KW_WITH - 321)) | (1 << (SparkSqlParser.KW_WITHIN - 321)) | (1 << (SparkSqlParser.KW_YEAR - 321)) | (1 << (SparkSqlParser.KW_YEARS - 321)) | (1 << (SparkSqlParser.KW_ZONE - 321)))) !== 0))) {
			this._errHandler.recoverInline(this);
			} else {
				if (this._input.LA(1) === Token.EOF) {
					this.matchedEOF = true;
				}

				this._errHandler.reportMatch(this);
				this.consume();
			}
			}
		}
		catch (re) {
			if (re instanceof RecognitionException) {
				_localctx.exception = re;
				this._errHandler.reportError(this, re);
				this._errHandler.recover(this, re);
			} else {
				throw re;
			}
		}
		finally {
			this.exitRule();
		}
		return _localctx;
	}

	public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean {
		switch (ruleIndex) {
		case 51:
			return this.queryTerm_sempred(_localctx as QueryTermContext, predIndex);

		case 137:
			return this.booleanExpression_sempred(_localctx as BooleanExpressionContext, predIndex);

		case 139:
			return this.valueExpression_sempred(_localctx as ValueExpressionContext, predIndex);

		case 141:
			return this.primaryExpression_sempred(_localctx as PrimaryExpressionContext, predIndex);
		}
		return true;
	}
	private queryTerm_sempred(_localctx: QueryTermContext, predIndex: number): boolean {
		switch (predIndex) {
		case 0:
			return this.precpred(this._ctx, 3);

		case 1:
			return this.precpred(this._ctx, 2);

		case 2:
			return this.precpred(this._ctx, 1);
		}
		return true;
	}
	private booleanExpression_sempred(_localctx: BooleanExpressionContext, predIndex: number): boolean {
		switch (predIndex) {
		case 3:
			return this.precpred(this._ctx, 2);

		case 4:
			return this.precpred(this._ctx, 1);
		}
		return true;
	}
	private valueExpression_sempred(_localctx: ValueExpressionContext, predIndex: number): boolean {
		switch (predIndex) {
		case 5:
			return this.precpred(this._ctx, 6);

		case 6:
			return this.precpred(this._ctx, 5);

		case 7:
			return this.precpred(this._ctx, 4);

		case 8:
			return this.precpred(this._ctx, 3);

		case 9:
			return this.precpred(this._ctx, 2);

		case 10:
			return this.precpred(this._ctx, 1);
		}
		return true;
	}
	private primaryExpression_sempred(_localctx: PrimaryExpressionContext, predIndex: number): boolean {
		switch (predIndex) {
		case 11:
			return this.precpred(this._ctx, 9);

		case 12:
			return this.precpred(this._ctx, 7);
		}
		return true;
	}

	private static readonly _serializedATNSegments: number = 8;
	private static readonly _serializedATNSegment0: string =
		"\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\u0184\u0F1D\x04" +
		"\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" +
		"\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" +
		"\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" +
		"\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" +
		"\x04\x18\t\x18\x04\x19\t\x19\x04\x1A\t\x1A\x04\x1B\t\x1B\x04\x1C\t\x1C" +
		"\x04\x1D\t\x1D\x04\x1E\t\x1E\x04\x1F\t\x1F\x04 \t \x04!\t!\x04\"\t\"\x04" +
		"#\t#\x04$\t$\x04%\t%\x04&\t&\x04\'\t\'\x04(\t(\x04)\t)\x04*\t*\x04+\t" +
		"+\x04,\t,\x04-\t-\x04.\t.\x04/\t/\x040\t0\x041\t1\x042\t2\x043\t3\x04" +
		"4\t4\x045\t5\x046\t6\x047\t7\x048\t8\x049\t9\x04:\t:\x04;\t;\x04<\t<\x04" +
		"=\t=\x04>\t>\x04?\t?\x04@\t@\x04A\tA\x04B\tB\x04C\tC\x04D\tD\x04E\tE\x04" +
		"F\tF\x04G\tG\x04H\tH\x04I\tI\x04J\tJ\x04K\tK\x04L\tL\x04M\tM\x04N\tN\x04" +
		"O\tO\x04P\tP\x04Q\tQ\x04R\tR\x04S\tS\x04T\tT\x04U\tU\x04V\tV\x04W\tW\x04" +
		"X\tX\x04Y\tY\x04Z\tZ\x04[\t[\x04\\\t\\\x04]\t]\x04^\t^\x04_\t_\x04`\t" +
		"`\x04a\ta\x04b\tb\x04c\tc\x04d\td\x04e\te\x04f\tf\x04g\tg\x04h\th\x04" +
		"i\ti\x04j\tj\x04k\tk\x04l\tl\x04m\tm\x04n\tn\x04o\to\x04p\tp\x04q\tq\x04" +
		"r\tr\x04s\ts\x04t\tt\x04u\tu\x04v\tv\x04w\tw\x04x\tx\x04y\ty\x04z\tz\x04" +
		"{\t{\x04|\t|\x04}\t}\x04~\t~\x04\x7F\t\x7F\x04\x80\t\x80\x04\x81\t\x81" +
		"\x04\x82\t\x82\x04\x83\t\x83\x04\x84\t\x84\x04\x85\t\x85\x04\x86\t\x86" +
		"\x04\x87\t\x87\x04\x88\t\x88\x04\x89\t\x89\x04\x8A\t\x8A\x04\x8B\t\x8B" +
		"\x04\x8C\t\x8C\x04\x8D\t\x8D\x04\x8E\t\x8E\x04\x8F\t\x8F\x04\x90\t\x90" +
		"\x04\x91\t\x91\x04\x92\t\x92\x04\x93\t\x93\x04\x94\t\x94\x04\x95\t\x95" +
		"\x04\x96\t\x96\x04\x97\t\x97\x04\x98\t\x98\x04\x99\t\x99\x04\x9A\t\x9A" +
		"\x04\x9B\t\x9B\x04\x9C\t\x9C\x04\x9D\t\x9D\x04\x9E\t\x9E\x04\x9F\t\x9F" +
		"\x04\xA0\t\xA0\x04\xA1\t\xA1\x04\xA2\t\xA2\x04\xA3\t\xA3\x04\xA4\t\xA4" +
		"\x04\xA5\t\xA5\x04\xA6\t\xA6\x04\xA7\t\xA7\x04\xA8\t\xA8\x04\xA9\t\xA9" +
		"\x04\xAA\t\xAA\x04\xAB\t\xAB\x04\xAC\t\xAC\x04\xAD\t\xAD\x04\xAE\t\xAE" +
		"\x04\xAF\t\xAF\x04\xB0\t\xB0\x04\xB1\t\xB1\x04\xB2\t\xB2\x04\xB3\t\xB3" +
		"\x04\xB4\t\xB4\x04\xB5\t\xB5\x04\xB6\t\xB6\x04\xB7\t\xB7\x04\xB8\t\xB8" +
		"\x04\xB9\t\xB9\x04\xBA\t\xBA\x04\xBB\t\xBB\x04\xBC\t\xBC\x04\xBD\t\xBD" +
		"\x04\xBE\t\xBE\x04\xBF\t\xBF\x04\xC0\t\xC0\x04\xC1\t\xC1\x04\xC2\t\xC2" +
		"\x04\xC3\t\xC3\x04\xC4\t\xC4\x04\xC5\t\xC5\x04\xC6\t\xC6\x04\xC7\t\xC7" +
		"\x03\x02\x07\x02\u0190\n\x02\f\x02\x0E\x02\u0193\v\x02\x03\x02\x03\x02" +
		"\x03\x03\x03\x03\x05\x03\u0199\n\x03\x03\x04\x03\x04\x05\x04\u019D\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x05\x04\u01AA\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u01AF" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u01B7\n" +
		"\x04\f\x04\x0E\x04\u01BA\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x05\x04\u01CC\n\x04\x03\x04\x03\x04\x05\x04\u01D0\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u01D6\n\x04\x03\x04\x05\x04\u01D9" +
		"\n\x04\x03\x04\x05\x04\u01DC\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x05\x04\u01E3\n\x04\x03\x04\x05\x04\u01E6\n\x04\x03\x04\x03\x04\x05" +
		"\x04\u01EA\n\x04\x03\x04\x05\x04\u01ED\n\x04\x03\x04\x03\x04\x03\x04\x05" +
		"\x04\u01F2\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x07\x04\u01FD\n\x04\f\x04\x0E\x04\u0200\v\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0207\n\x04\x03\x04\x05\x04\u020A" +
		"\n\x04\x03\x04\x03\x04\x05\x04\u020E\n\x04\x03\x04\x05\x04\u0211\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0217\n\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0222\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0228\n\x04\x03\x04\x03\x04\x03" +
		"\x04\x05\x04\u022D\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u024E" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x05\x04\u0258\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x05\x04\u0263\n\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u026E\n\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0279" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u027E\n\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0287\n\x04\x03\x04\x03\x04" +
		"\x05\x04\u028B\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0291\n\x04" +
		"\x03\x04\x03\x04\x05\x04\u0295\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u029A" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02A0\n\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05" +
		"\x04\u02AC\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
		"\u02B4\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02BA\n\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
		"\u02C5\n\x04\x03\x04\x03\x04\x05\x04\u02C9\n\x04\x03\x04\x06\x04\u02CC" +
		"\n\x04\r\x04\x0E\x04\u02CD\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02DD" +
		"\n\x04\x03\x04\x03\x04\x05\x04\u02E1\n\x04\x03\x04\x03\x04\x03\x04\x07" +
		"\x04\u02E6\n\x04\f\x04\x0E\x04\u02E9\v\x04\x03\x04\x05\x04\u02EC\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u02F2\n\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x05\x04\u0300\n\x04\x03\x04\x03\x04\x05\x04\u0304\n\x04\x03\x04\x03" +
		"\x04\x03\x04\x05\x04\u0309\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
		"\u030F\n\x04\x03\x04\x05\x04\u0312\n\x04\x03\x04\x05\x04\u0315\n\x04\x03" +
		"\x04\x03\x04\x05\x04\u0319\n\x04\x03\x04\x03\x04\x05\x04\u031D\n\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0325\n\x04\f\x04" +
		"\x0E\x04\u0328\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05" +
		"\x04\u0330\n\x04\x03\x04\x05\x04\u0333\n\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x05\x04\u033C\n\x04\x03\x04\x03\x04\x03\x04" +
		"\x05\x04\u0341\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0347\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u034E\n\x04\x03\x04\x05" +
		"\x04\u0351\n\x04\x03\x04\x03\x04\x05\x04\u0355\n\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u035E\n\x04\f\x04\x0E\x04" +
		"\u0361\v\x04\x05\x04\u0363\n\x04\x03\x04\x03\x04\x05\x04\u0367\n\x04\x03" +
		"\x04\x03\x04\x05\x04\u036B\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
		"\u0371\n\x04\x03\x04\x05\x04\u0374\n\x04\x03\x04\x03\x04\x05\x04\u0378" +
		"\n\x04\x03\x04\x05\x04\u037B\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05" +
		"\x04\u0381\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0386\n\x04\x03\x04\x03" +
		"\x04\x05\x04\u038A\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
		"\u0391\n\x04\x03\x04\x05\x04\u0394\n\x04\x03\x04\x05\x04\u0397\n\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u039E\n\x04\x03\x04\x03\x04" +
		"\x03\x04\x05\x04\u03A3\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x05\x04\u03AC\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x05\x04\u03B4\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03BA" +
		"\n\x04\x03\x04\x05\x04\u03BD\n\x04\x03\x04\x05\x04\u03C0\n\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x05\x04\u03C6\n\x04\x03\x04\x03\x04\x05\x04\u03CA" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03CF\n\x04\x03\x04\x05\x04\u03D2" +
		"\n\x04\x03\x04\x03\x04\x05\x04\u03D6\n\x04\x05\x04\u03D8\n\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03E0\n\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03E8\n\x04\x03\x04\x05\x04" +
		"\u03EB\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03F0\n\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x05\x04\u03F6\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u03FB" +
		"\n\x04\x03\x04\x05\x04\u03FE\n\x04\x03\x04\x03\x04\x05\x04\u0402\n\x04" +
		"\x03\x04\x05\x04\u0405\n\x04\x03\x04\x03\x04\x05\x04\u0409\n\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0423\n\x04\f\x04\x0E" +
		"\x04\u0426\v\x04\x05\x04\u0428\n\x04\x03\x04\x03\x04\x05\x04\u042C\n\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0432\n\x04\x03\x04\x05\x04\u0435" +
		"\n\x04\x03\x04\x05\x04\u0438\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u043D" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0445\n" +
		"\x04\x03\x04\x03\x04\x03\x04\x05\x04\u044A\n\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x05\x04\u0450\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x05\x04\u0456" +
		"\n\x04\x03\x04\x05\x04\u0459\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x05\x04\u0460\n\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0465\n\x04\f" +
		"\x04\x0E\x04\u0468\v\x04\x03\x04\x03\x04\x03\x04\x07\x04\u046D\n\x04\f" +
		"\x04\x0E\x04\u0470\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u047E\n\x04\f" +
		"\x04\x0E\x04\u0481\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04\u0499" +
		"\n\x04\f\x04\x0E\x04\u049C\v\x04\x05\x04\u049E\n\x04\x03\x04\x03\x04\x07" +
		"\x04\u04A2\n\x04\f\x04\x0E\x04\u04A5\v\x04\x03\x04\x03\x04\x03\x04\x03" +
		"\x04\x07\x04\u04AB\n\x04\f\x04\x0E\x04\u04AE\v\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x07\x04\u04B4\n\x04\f\x04\x0E\x04\u04B7\v\x04\x03\x04\x03" +
		"\x04\x03\x04\x05\x04\u04BC\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u04C1" +
		"\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u04C6\n\x04\x03\x04\x03\x04\x03" +
		"\x04\x03\x04\x03\x04\x05\x04\u04CD\n\x04\x03\x04\x03\x04\x03\x04\x05\x04" +
		"\u04D2\n\x04\x03\x04\x03\x04\x03\x04\x05\x04\u04D7\n\x04\x03\x04\x03\x04" +
		"\x03\x04\x03\x04\x07\x04\u04DD\n\x04\f\x04\x0E\x04\u04E0\v\x04\x05\x04" +
		"\u04E2\n\x04\x03\x05\x03\x05\x05\x05\u04E6\n\x05\x03\x06\x03\x06\x03\x07" +
		"\x03\x07\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u04F2\n\b\x03\b\x03" +
		"\b\x05\b\u04F6\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u04FD\n\b\x03\b" +
		"\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u0571\n\b\x03\b\x03\b\x03\b\x03" +
		"\b\x03\b\x03\b\x05\b\u0579\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05" +
		"\b\u0581\n\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u058A\n\b" +
		"\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x03\b\x05\b\u0594\n\b\x03\t" +
		"\x03\t\x05\t\u0598\n\t\x03\t\x05\t\u059B\n\t\x03\t\x03\t\x05\t\u059F\n" +
		"\t\x03\t\x03\t\x03\n\x03\n\x05\n\u05A5\n\n\x03\n\x03\n\x03\n\x03\n\x03" +
		"\v\x03\v\x03\v\x03\v\x03\v\x03\v\x05\v\u05B1\n\v\x03\v\x03\v\x03\v\x03" +
		"\v\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x05\f\u05BD\n\f\x03\f\x03\f\x03" +
		"\f\x05\f\u05C2\n\f\x03\r\x03\r\x03\r\x03\x0E\x03\x0E\x03\x0E\x03\x0F\x05" +
		"\x0F\u05CB\n\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x10\x05\x10" +
		"\u05D3\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05D8\n\x10\x05\x10\u05DA" +
		"\n\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05E2\n" +
		"\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05E7\n\x10\x03\x10\x03\x10\x05\x10" +
		"\u05EB\n\x10\x03\x10\x05\x10\u05EE\n\x10\x03\x10\x03\x10\x03\x10\x03\x10" +
		"\x03\x10\x03\x10\x05\x10\u05F6\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u05FB" +
		"\n\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x03\x10\x05\x10" +
		"\u0604\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u0609\n\x10\x03\x10\x05\x10" +
		"\u060C\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u0611\n\x10\x03\x10\x03\x10" +
		"\x05\x10\u0615\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\u061A\n\x10\x05\x10" +
		"\u061C\n\x10\x03\x11\x03\x11\x05\x11\u0620\n\x11\x03\x12\x03\x12\x03\x12" +
		"\x03\x12\x03\x12\x07\x12\u0627\n\x12\f\x12\x0E\x12\u062A\v\x12\x03\x12" +
		"\x03\x12\x03\x13\x03\x13\x03\x13\x05\x13\u0631\n\x13\x03\x13\x03\x13\x03" +
		"\x13\x03\x13\x05\x13\u0637\n\x13\x03\x14\x03\x14\x03\x15\x03\x15\x03\x16" +
		"\x03\x16\x03\x16\x03\x16\x03\x16\x05\x16\u0642\n\x16\x03\x17\x03\x17\x03" +
		"\x17\x07\x17\u0647\n\x17\f\x17\x0E\x17\u064A\v\x17\x03\x18\x03\x18\x03" +
		"\x18\x03\x18\x07\x18\u0650\n\x18\f\x18\x0E\x18\u0653\v\x18\x03\x19\x03" +
		"\x19\x05\x19\u0657\n\x19\x03\x19\x05\x19\u065A\n\x19\x03\x19\x03\x19\x03" +
		"\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03" +
		"\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x07" +
		"\x1B\u0670\n\x1B\f\x1B\x0E\x1B\u0673\v\x1B\x03\x1C\x03\x1C\x03\x1C\x03" +
		"\x1C\x07\x1C\u0679\n\x1C\f\x1C\x0E\x1C\u067C\v\x1C\x03\x1C\x03\x1C\x03" +
		"\x1D\x03\x1D\x05\x1D\u0682\n\x1D\x03\x1D\x05\x1D\u0685\n\x1D\x03\x1E\x03" +
		"\x1E\x03\x1E\x07\x1E\u068A\n\x1E\f\x1E\x0E\x1E\u068D\v\x1E\x03\x1E\x05" +
		"\x1E\u0690\n\x1E\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x05\x1F\u0696\n\x1F\x03" +
		" \x03 \x03 \x03 \x07 \u069C\n \f \x0E \u069F\v \x03 \x03 \x03!\x03!\x05" +
		"!\u06A5\n!\x03!\x05!\u06A8\n!\x03\"\x03\"\x03\"\x03\"\x07\"\u06AE\n\"" +
		"\f\"\x0E\"\u06B1\v\"\x03\"\x03\"\x03#\x03#\x03#\x03#\x07#\u06B9\n#\f#" +
		"\x0E#\u06BC\v#\x03#\x03#\x03$\x03$\x03$\x03$\x03$\x03$\x05$\u06C6\n$\x03" +
		"%\x03%\x03%\x03%\x03%\x03%\x05%\u06CE\n%\x03&\x03&\x03&\x03&\x05&\u06D4" +
		"\n&\x03\'\x03\'\x03\'\x03(\x03(\x03(\x03(\x03(\x06(\u06DE\n(\r(\x0E(\u06DF" +
		"\x03(\x03(\x03(\x03(\x03(\x05(\u06E7\n(\x03(\x03(\x03(\x03(\x03(\x05(" +
		"\u06EE\n(\x03(\x03(\x03(\x03(\x03(\x03(\x03(\x03(\x03(\x03(\x05(\u06FA" +
		"\n(\x03(\x03(\x03(\x03(\x07(\u0700\n(\f(\x0E(\u0703\v(\x03(\x07(\u0706" +
		"\n(\f(\x0E(\u0709\v(\x03(\x07(\u070C\n(\f(\x0E(\u070F\v(\x05(\u0711\n" +
		"(\x03)\x03)\x03*\x03*\x03+\x03+\x03,\x03,\x03-\x03-\x03.\x03.\x03/\x03" +
		"/\x030\x030\x030\x070\u0724\n0\f0\x0E0\u0727\v0\x031\x031\x032\x032\x03" +
		"2\x032\x032\x032\x052\u0731\n2\x033\x033\x033\x033\x033\x073\u0738\n3" +
		"\f3\x0E3\u073B\v3\x053\u073D\n3\x033\x033\x033\x033\x033\x073\u0744\n" +
		"3\f3\x0E3\u0747\v3\x053\u0749\n3\x033\x033\x033\x033\x033\x073\u0750\n" +
		"3\f3\x0E3\u0753\v3\x053\u0755\n3\x033\x033\x033\x033\x033\x073\u075C\n" +
		"3\f3\x0E3\u075F\v3\x053\u0761\n3\x033\x053\u0764\n3\x033\x033\x033\x05" +
		"3\u0769\n3\x053\u076B\n3\x033\x033\x053\u076F\n3\x034\x034\x034\x035\x03" +
		"5\x035\x035\x035\x035\x055\u077A\n5\x035\x035\x035\x035\x055\u0780\n5" +
		"\x035\x035\x035\x035\x055\u0786\n5\x035\x075\u0789\n5\f5\x0E5\u078C\v" +
		"5\x036\x036\x036\x036\x036\x036\x036\x036\x036\x056\u0797\n6\x037\x03" +
		"7\x057\u079B\n7\x037\x057\u079E\n7\x037\x037\x057\u07A2\n7\x038\x038\x06" +
		"8\u07A6\n8\r8\x0E8\u07A7\x039\x039\x059\u07AC\n9\x039\x039\x039\x039\x07" +
		"9\u07B2\n9\f9\x0E9\u07B5\v9\x039\x059\u07B8\n9\x039\x059\u07BB\n9\x03" +
		"9\x059\u07BE\n9\x039\x059\u07C1\n9\x039\x039\x059\u07C5\n9\x03:\x03:\x05" +
		":\u07C9\n:\x03:\x07:\u07CC\n:\f:\x0E:\u07CF\v:\x03:\x05:\u07D2\n:\x03" +
		":\x05:\u07D5\n:\x03:\x05:\u07D8\n:\x03:\x05:\u07DB\n:\x03:\x03:\x05:\u07DF" +
		"\n:\x03:\x07:\u07E2\n:\f:\x0E:\u07E5\v:\x03:\x05:\u07E8\n:\x03:\x05:\u07EB" +
		"\n:\x03:\x05:\u07EE\n:\x03:\x05:\u07F1\n:\x05:\u07F3\n:\x03;\x03;\x03" +
		";\x03;\x05;\u07F9\n;\x03;\x03;\x03;\x03;\x03;\x05;\u0800\n;\x03;\x03;" +
		"\x03;\x05;\u0805\n;\x03;\x05;\u0808\n;\x03;\x05;\u080B\n;\x03;\x03;\x05" +
		";\u080F\n;\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x05;\u0819\n;\x03;" +
		"\x03;\x05;\u081D\n;\x05;\u081F\n;\x03;\x05;\u0822\n;\x03;\x03;\x05;\u0826" +
		"\n;\x03<\x03<\x07<\u082A\n<\f<\x0E<\u082D\v<\x03<\x05<\u0830\n<\x03<\x03" +
		"<\x03=\x03=\x03=\x03>\x03>\x03>\x03>\x05>\u083B\n>\x03>\x03>\x03>\x03" +
		"?\x03?\x03?\x03?\x03?\x05?\u0845\n?\x03?\x03?\x05?\u0849\n?\x03?\x03?" +
		"\x03?\x03@\x03@\x03@\x03@\x03@\x03@\x03@\x05@\u0855\n@\x03@\x03@\x03@" +
		"\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x05A\u0861\nA\x03B\x03B\x03B\x03B" +
		"\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x07B\u086E\nB\fB\x0EB\u0871\vB\x03" +
		"B\x03B\x05B\u0875\nB\x03C\x03C\x03C\x03C\x05C\u087B\nC\x03D\x03D\x03D" +
		"\x07D\u0880\nD\fD\x0ED\u0883\vD\x03E\x03E\x03E\x03E\x03F\x03F\x03F\x03" +
		"G\x03G\x03G\x03H\x03H\x03H\x05H\u0892\nH\x03H\x07H\u0895\nH\fH\x0EH\u0898" +
		"\vH\x03H\x03H\x03I\x03I\x03I\x03I\x03I\x03I\x07I\u08A2\nI\fI\x0EI\u08A5" +
		"\vI\x03I\x03I\x05I\u08A9\nI\x03J\x03J\x03J\x03J\x07J\u08AF\nJ\fJ\x0EJ" +
		"\u08B2\vJ\x03J\x07J\u08B5\nJ\fJ\x0EJ\u08B8\vJ\x03J\x05J\u08BB\nJ\x03J" +
		"\x05J\u08BE\nJ\x03K\x03K\x03L\x05L\u08C3\nL\x03L\x03L\x03L\x03L\x03L\x05" +
		"L\u08CA\nL\x03L\x03L\x03L\x03L\x05L\u08D0\nL\x03M\x03M\x03M\x03M\x03M" +
		"\x07M\u08D7\nM\fM\x0EM\u08DA\vM\x03M\x03M\x03M\x03M\x03M\x07M\u08E1\n" +
		"M\fM\x0EM\u08E4\vM\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x07" +
		"M\u08F0\nM\fM\x0EM\u08F3\vM\x03M\x03M\x05M\u08F7\nM\x05M\u08F9\nM\x03" +
		"N\x03N\x03N\x05N\u08FE\nN\x03O\x03O\x03O\x03O\x03O\x07O\u0905\nO\fO\x0E" +
		"O\u0908\vO\x03O\x03O\x03O\x03O\x03O\x03O\x03O\x03O\x07O\u0912\nO\fO\x0E" +
		"O\u0915\vO\x03O\x03O\x05O\u0919\nO";
	private static readonly _serializedATNSegment1: string =
		"\x03P\x03P\x05P\u091D\nP\x03Q\x03Q\x03Q\x03Q\x03Q\x05Q\u0924\nQ\x03Q\x03" +
		"Q\x03Q\x05Q\u0929\nQ\x07Q\u092B\nQ\fQ\x0EQ\u092E\vQ\x05Q\u0930\nQ\x03" +
		"Q\x05Q\u0933\nQ\x03R\x03R\x03R\x03R\x03R\x03R\x03R\x03R\x03R\x03R\x07" +
		"R\u093F\nR\fR\x0ER\u0942\vR\x03R\x03R\x03R\x03S\x03S\x03S\x03S\x03S\x07" +
		"S\u094C\nS\fS\x0ES\u094F\vS\x03S\x03S\x05S\u0953\nS\x03T\x03T\x05T\u0957" +
		"\nT\x03T\x05T\u095A\nT\x03U\x03U\x05U\u095E\nU\x03U\x03U\x03U\x03U\x05" +
		"U\u0964\nU\x03U\x05U\u0967\nU\x03V\x03V\x03V\x03W\x03W\x05W\u096E\nW\x03" +
		"X\x03X\x03X\x03X\x03X\x03X\x03X\x03X\x07X\u0978\nX\fX\x0EX\u097B\vX\x03" +
		"X\x03X\x03Y\x03Y\x03Y\x03Y\x07Y\u0983\nY\fY\x0EY\u0986\vY\x03Y\x03Y\x03" +
		"Y\x03Y\x03Y\x03Y\x03Y\x03Y\x07Y\u0990\nY\fY\x0EY\u0993\vY\x03Y\x03Y\x03" +
		"Z\x03Z\x03Z\x03Z\x07Z\u099B\nZ\fZ\x0EZ\u099E\vZ\x03Z\x03Z\x05Z\u09A2\n" +
		"Z\x03[\x03[\x03\\\x03\\\x03]\x03]\x05]\u09AA\n]\x03^\x03^\x03_\x05_\u09AF" +
		"\n_\x03_\x03_\x03`\x03`\x03`\x03`\x03a\x03a\x03a\x03b\x03b\x03b\x05b\u09BD" +
		"\nb\x03b\x03b\x03b\x03b\x03b\x07b\u09C4\nb\fb\x0Eb\u09C7\vb\x05b\u09C9" +
		"\nb\x03b\x03b\x03b\x05b\u09CE\nb\x03b\x03b\x03b\x07b\u09D3\nb\fb\x0Eb" +
		"\u09D6\vb\x05b\u09D8\nb\x03c\x03c\x03d\x05d\u09DD\nd\x03d\x03d\x07d\u09E1" +
		"\nd\fd\x0Ed\u09E4\vd\x03d\x05d\u09E7\nd\x03e\x03e\x03e\x05e\u09EC\ne\x03" +
		"f\x03f\x03f\x05f\u09F1\nf\x03f\x03f\x05f\u09F5\nf\x03f\x03f\x03f\x03f" +
		"\x05f\u09FB\nf\x03f\x03f\x05f\u09FF\nf\x03g\x05g\u0A02\ng\x03g\x03g\x03" +
		"g\x05g\u0A07\ng\x03g\x05g\u0A0A\ng\x03g\x03g\x03g\x05g\u0A0F\ng\x03g\x03" +
		"g\x05g\u0A13\ng\x03g\x05g\u0A16\ng\x03g\x05g\u0A19\ng\x03h\x03h\x03h\x03" +
		"h\x05h\u0A1F\nh\x03i\x03i\x03i\x05i\u0A24\ni\x03i\x03i\x03i\x03i\x03i" +
		"\x05i\u0A2B\ni\x03j\x05j\u0A2E\nj\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03" +
		"j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x05j\u0A40\nj\x05j\u0A42\nj" +
		"\x03j\x05j\u0A45\nj\x03k\x03k\x03k\x03k\x03l\x03l\x03l\x07l\u0A4E\nl\f" +
		"l\x0El\u0A51\vl\x03m\x03m\x03m\x03m\x07m\u0A57\nm\fm\x0Em\u0A5A\vm\x03" +
		"m\x03m\x03n\x03n\x05n\u0A60\nn\x03o\x03o\x03o\x03o\x07o\u0A66\no\fo\x0E" +
		"o\u0A69\vo\x03o\x03o\x03p\x03p\x05p\u0A6F\np\x03q\x03q\x05q\u0A73\nq\x03" +
		"q\x05q\u0A76\nq\x03q\x03q\x03q\x03q\x03q\x03q\x05q\u0A7E\nq\x03q\x03q" +
		"\x03q\x03q\x03q\x03q\x05q\u0A86\nq\x03q\x03q\x03q\x03q\x05q\u0A8C\nq\x03" +
		"r\x03r\x03r\x03r\x07r\u0A92\nr\fr\x0Er\u0A95\vr\x03r\x03r\x03s\x03s\x03" +
		"s\x05s\u0A9C\ns\x03s\x03s\x03s\x03s\x03s\x05s\u0AA3\ns\x03s\x03s\x03s" +
		"\x03s\x03s\x05s\u0AAA\ns\x05s\u0AAC\ns\x03t\x03t\x03t\x03t\x03t\x03t\x03" +
		"t\x03t\x03t\x07t\u0AB7\nt\ft\x0Et\u0ABA\vt\x03t\x03t\x03t\x05t\u0ABF\n" +
		"t\x05t\u0AC1\nt\x03t\x03t\x03t\x03t\x03t\x03t\x07t\u0AC9\nt\ft\x0Et\u0ACC" +
		"\vt\x03t\x03t\x03t\x05t\u0AD1\nt\x05t\u0AD3\nt\x03u\x03u\x03u\x03u\x03" +
		"v\x03v\x05v\u0ADB\nv\x03w\x03w\x05w\u0ADF\nw\x03x\x03x\x03x\x03x\x03x" +
		"\x07x\u0AE6\nx\fx\x0Ex\u0AE9\vx\x05x\u0AEB\nx\x03x\x03x\x03x\x03y\x05" +
		"y\u0AF1\ny\x03y\x03y\x05y\u0AF5\ny\x05y\u0AF7\ny\x03z\x03z\x03z\x03z\x03" +
		"z\x03z\x03z\x05z\u0B00\nz\x03z\x03z\x03z\x03z\x03z\x03z\x03z\x03z\x03" +
		"z\x03z\x05z\u0B0C\nz\x05z\u0B0E\nz\x03z\x03z\x03z\x03z\x03z\x05z\u0B15" +
		"\nz\x03z\x03z\x03z\x03z\x03z\x05z\u0B1C\nz\x03z\x03z\x03z\x03z\x05z\u0B22" +
		"\nz\x03z\x03z\x03z\x03z\x05z\u0B28\nz\x05z\u0B2A\nz\x03{\x03{\x03{\x07" +
		"{\u0B2F\n{\f{\x0E{\u0B32\v{\x03|\x03|\x03|\x07|\u0B37\n|\f|\x0E|\u0B3A" +
		"\v|\x03}\x03}\x03}\x07}\u0B3F\n}\f}\x0E}\u0B42\v}\x03~\x03~\x03~\x05~" +
		"\u0B47\n~\x03\x7F\x03\x7F\x03\x7F\x05\x7F\u0B4C\n\x7F\x03\x7F\x03\x7F" +
		"\x03\x80\x03\x80\x03\x80\x05\x80\u0B53\n\x80\x03\x80\x03\x80\x03\x81\x03" +
		"\x81\x05\x81\u0B59\n\x81\x03\x81\x05\x81\u0B5C\n\x81\x03\x81\x03\x81\x05" +
		"\x81\u0B60\n\x81\x05\x81\u0B62\n\x81\x03\x82\x03\x82\x03\x82\x07\x82\u0B67" +
		"\n\x82\f\x82\x0E\x82\u0B6A\v\x82\x03\x83\x03\x83\x03\x83\x03\x83\x07\x83" +
		"\u0B70\n\x83\f\x83\x0E\x83\u0B73\v\x83\x03\x83\x03\x83\x03\x84\x03\x84" +
		"\x05\x84\u0B79\n\x84\x03\x85\x03\x85\x03\x85\x03\x85\x03\x85\x03\x85\x07" +
		"\x85\u0B81\n\x85\f\x85\x0E\x85\u0B84\v\x85\x03\x85\x03\x85\x05\x85\u0B88" +
		"\n\x85\x03\x86\x03\x86\x05\x86\u0B8C\n\x86\x03\x87\x03\x87\x03\x88\x03" +
		"\x88\x03\x88\x03\x88\x03\x89\x03\x89\x05\x89\u0B96\n\x89\x03\x8A\x03\x8A" +
		"\x03\x8A\x07\x8A\u0B9B\n\x8A\f\x8A\x0E\x8A\u0B9E\v\x8A\x03\x8B\x03\x8B" +
		"\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x05\x8B" +
		"\u0BAA\n\x8B\x05\x8B\u0BAC\n\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B" +
		"\x03\x8B\x07\x8B\u0BB4\n\x8B\f\x8B\x0E\x8B\u0BB7\v\x8B\x03\x8C\x05\x8C" +
		"\u0BBA\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0BC2" +
		"\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x07\x8C\u0BC9\n\x8C\f\x8C" +
		"\x0E\x8C\u0BCC\v\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0BD1\n\x8C\x03\x8C" +
		"\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0BD9\n\x8C\x03\x8C\x03" +
		"\x8C\x03\x8C\x05\x8C\u0BDE\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C" +
		"\x03\x8C\x03\x8C\x03\x8C\x07\x8C\u0BE8\n\x8C\f\x8C\x0E\x8C\u0BEB\v\x8C" +
		"\x03\x8C\x03\x8C\x05\x8C\u0BEF\n\x8C\x03\x8C\x05\x8C\u0BF2\n\x8C\x03\x8C" +
		"\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0BF8\n\x8C\x03\x8C\x03\x8C\x05\x8C\u0BFC" +
		"\n\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0C01\n\x8C\x03\x8C\x03\x8C\x03" +
		"\x8C\x05\x8C\u0C06\n\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0C0B\n\x8C\x03" +
		"\x8D\x03\x8D\x03\x8D\x03\x8D\x05\x8D\u0C11\n\x8D\x03\x8D\x03\x8D\x03\x8D" +
		"\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D" +
		"\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x07\x8D\u0C26" +
		"\n\x8D\f\x8D\x0E\x8D\u0C29\v\x8D\x03\x8E\x03\x8E\x03\x8F\x03\x8F\x03\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0C33\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0C3F\n\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x06\x8F" +
		"\u0C49\n\x8F\r\x8F\x0E\x8F\u0C4A\x03\x8F\x03\x8F\x05\x8F\u0C4F\n\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x06\x8F\u0C56\n\x8F\r\x8F\x0E\x8F" +
		"\u0C57\x03\x8F\x03\x8F\x05\x8F\u0C5C\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x07\x8F\u0C6C\n\x8F\f\x8F\x0E\x8F\u0C6F\v\x8F\x05\x8F\u0C71" +
		"\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0C79\n" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0C82" +
		"\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F" +
		"\u0C8B\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x06\x8F\u0CA0\n\x8F\r\x8F\x0E\x8F\u0CA1\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0CB2\n\x8F\x03\x8F\x03\x8F\x03\x8F" +
		"\x07\x8F\u0CB7\n\x8F\f\x8F\x0E\x8F\u0CBA\v\x8F\x05\x8F\u0CBC\n\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0CC5\n\x8F" +
		"\x03\x8F\x03\x8F\x05\x8F\u0CC9\n\x8F\x03\x8F\x03\x8F\x05\x8F\u0CCD\n\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x06\x8F" +
		"\u0CD7\n\x8F\r\x8F\x0E\x8F\u0CD8\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F" +
		"\x05\x8F\u0CF2\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0CF9" +
		"\n\x8F\x03\x8F\x05\x8F\u0CFC\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x05" +
		"\x8F\u0D0B\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F" +
		"\x03\x8F\x03\x8F\x03\x8F\x05\x8F\u0D20\n\x8F\x03\x8F\x03\x8F\x05\x8F\u0D24" +
		"\n\x8F\x05\x8F\u0D26\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03" +
		"\x8F\x03\x8F\x03\x8F\x07\x8F\u0D30\n\x8F\f\x8F\x0E\x8F\u0D33\v\x8F\x03" +
		"\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x05\x90\u0D3C\n\x90" +
		"\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91" +
		"\x03\x91\x03\x91\x06\x91\u0D49\n\x91\r\x91\x0E\x91\u0D4A\x05\x91\u0D4D" +
		"\n\x91\x03\x92\x03\x92\x03\x93\x03\x93\x03\x94\x03\x94\x03\x95\x03\x95" +
		"\x03\x96\x03\x96\x03\x96\x05\x96\u0D5A\n\x96\x03\x97\x03\x97\x05\x97\u0D5E" +
		"\n\x97\x03\x98\x03\x98\x03\x98\x06\x98\u0D63\n\x98\r\x98\x0E\x98\u0D64" +
		"\x03\x99\x03\x99\x03\x99\x05\x99\u0D6A\n\x99\x03\x9A\x03\x9A\x03\x9A\x03" +
		"\x9A\x03\x9A\x03\x9B\x05\x9B\u0D72\n\x9B\x03\x9B\x03\x9B\x03\x9B\x05\x9B" +
		"\u0D77\n\x9B\x03\x9C\x03\x9C\x03\x9D\x03\x9D\x03\x9E\x03\x9E\x03\x9E\x05" +
		"\x9E\u0D80\n\x9E\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F" +
		"\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F" +
		"\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F" +
		"\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x05\x9F\u0DA0\n\x9F\x03\xA0\x03" +
		"\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03" +
		"\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x05\xA0\u0DB1\n\xA0\x03\xA0\x03\xA0" +
		"\x05\xA0\u0DB5\n\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x05\xA0\u0DBB\n\xA0" +
		"\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x05\xA0\u0DC1\n\xA0\x03\xA0\x03\xA0\x03" +
		"\xA0\x03\xA0\x03\xA0\x07\xA0\u0DC8\n\xA0\f\xA0\x0E\xA0\u0DCB\v\xA0\x03" +
		"\xA0\x05\xA0\u0DCE\n\xA0\x05\xA0\u0DD0\n\xA0\x03\xA1\x03\xA1\x03\xA1\x07" +
		"\xA1\u0DD5\n\xA1\f\xA1\x0E\xA1\u0DD8\v\xA1\x03\xA2\x03\xA2\x03\xA2\x07" +
		"\xA2\u0DDD\n\xA2\f\xA2\x0E\xA2\u0DE0\v\xA2\x03\xA3\x03\xA3\x03\xA3\x07" +
		"\xA3\u0DE5\n\xA3\f\xA3\x0E\xA3\u0DE8\v\xA3\x03\xA4\x03\xA4\x03\xA4\x07" +
		"\xA4\u0DED\n\xA4\f\xA4\x0E\xA4\u0DF0\v\xA4\x03\xA5\x03\xA5\x03\xA5\x03" +
		"\xA5\x03\xA5\x05\xA5\u0DF7\n\xA5\x03\xA6\x03\xA6\x03\xA6\x03\xA7\x03\xA7" +
		"\x03\xA7\x03\xA8\x03\xA8\x03\xA8\x07\xA8\u0E02\n\xA8\f\xA8\x0E\xA8\u0E05" +
		"\v\xA8\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x05\xA9\u0E0B\n\xA9\x03\xA9\x05" +
		"\xA9\u0E0E\n\xA9\x03\xAA\x03\xAA\x03\xAA\x07\xAA\u0E13\n\xAA\f\xAA\x0E" +
		"\xAA\u0E16\v\xAA\x03\xAB\x03\xAB\x03\xAB\x07\xAB\u0E1B\n\xAB\f\xAB\x0E" +
		"\xAB\u0E1E\v\xAB\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x05\xAC\u0E25" +
		"\n\xAC\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAE" +
		"\x03\xAE\x03\xAE\x07\xAE\u0E31\n\xAE\f\xAE\x0E\xAE\u0E34\v\xAE\x03\xAF" +
		"\x03\xAF\x05\xAF\u0E38\n\xAF\x03\xAF\x03\xAF\x03\xAF\x05\xAF\u0E3D\n\xAF" +
		"\x03\xAF\x05\xAF\u0E40\n\xAF\x03\xB0\x03\xB0\x03\xB0\x03\xB0\x03\xB0\x03" +
		"\xB1\x03\xB1\x03\xB1\x03\xB1\x07\xB1\u0E4B\n\xB1\f\xB1\x0E\xB1\u0E4E\v" +
		"\xB1\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03" +
		"\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x07\xB3\u0E5F\n\xB3" +
		"\f\xB3\x0E\xB3\u0E62\v\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x07" +
		"\xB3\u0E69\n\xB3\f\xB3\x0E\xB3\u0E6C\v\xB3\x05\xB3\u0E6E\n\xB3\x03\xB3" +
		"\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x07\xB3\u0E75\n\xB3\f\xB3\x0E\xB3\u0E78" +
		"\v\xB3\x05\xB3\u0E7A\n\xB3\x05\xB3\u0E7C\n\xB3\x03\xB3\x05\xB3\u0E7F\n" +
		"\xB3\x03\xB3\x05\xB3\u0E82\n\xB3\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4" +
		"\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4" +
		"\x03\xB4\x03\xB4\x05\xB4\u0E94\n\xB4\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x03" +
		"\xB5\x03\xB5\x03\xB5\x05\xB5\u0E9D\n\xB5\x03\xB6\x03\xB6\x03\xB6\x07\xB6" +
		"\u0EA2\n\xB6\f\xB6\x0E\xB6\u0EA5\v\xB6\x03\xB7\x03\xB7\x03\xB7\x03\xB7" +
		"\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x05\xB7\u0EB0\n\xB7\x03\xB8\x03" +
		"\xB8\x03\xB9\x03\xB9\x03\xB9\x07\xB9\u0EB7\n\xB9\f\xB9\x0E\xB9\u0EBA\v" +
		"\xB9\x03\xBA\x03\xBA\x03\xBA\x03\xBB\x03\xBB\x06\xBB\u0EC1\n\xBB\r\xBB" +
		"\x0E\xBB\u0EC2\x03\xBB\x05\xBB\u0EC6\n\xBB\x03\xBC\x03\xBC\x05\xBC\u0ECA" +
		"\n\xBC\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x05\xBD\u0ED0\n\xBD\x03\xBE\x03" +
		"\xBE\x03\xBF\x03\xBF\x03\xC0\x05\xC0\u0ED7\n\xC0\x03\xC0\x03\xC0\x05\xC0" +
		"\u0EDB\n\xC0\x03\xC0\x03\xC0\x05\xC0\u0EDF\n\xC0\x03\xC0\x03\xC0\x05\xC0" +
		"\u0EE3\n\xC0\x03\xC0\x03\xC0\x05\xC0\u0EE7\n\xC0\x03\xC0\x03\xC0\x05\xC0" +
		"\u0EEB\n\xC0\x03\xC0\x03\xC0\x05\xC0\u0EEF\n\xC0\x03\xC0\x03\xC0\x05\xC0" +
		"\u0EF3\n\xC0\x03\xC0\x03\xC0\x05\xC0\u0EF7\n\xC0\x03\xC0\x03\xC0\x05\xC0" +
		"\u0EFB\n\xC0\x03\xC0\x05\xC0\u0EFE\n\xC0\x03\xC1\x03\xC1\x03\xC1\x03\xC1" +
		"\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x05\xC1\u0F0B" +
		"\n\xC1\x03\xC2\x03\xC2\x03\xC3\x03\xC3\x05\xC3\u0F11\n\xC3\x03\xC4\x03" +
		"\xC4\x05\xC4\u0F15\n\xC4\x03\xC5\x03\xC5\x03\xC6\x03\xC6\x03\xC7\x03\xC7" +
		"\x03\xC7\v\u0424\u0466\u046E\u047F\u049A\u04A3\u04AC\u04B5\u04DE\x02\x06" +
		"h\u0114\u0118\u011C\xC8\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E" +
		"\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 " +
		"\x02\"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x022\x024\x026\x028\x02:\x02" +
		"<\x02>\x02@\x02B\x02D\x02F\x02H\x02J\x02L\x02N\x02P\x02R\x02T\x02V\x02" +
		"X\x02Z\x02\\\x02^\x02`\x02b\x02d\x02f\x02h\x02j\x02l\x02n\x02p\x02r\x02" +
		"t\x02v\x02x\x02z\x02|\x02~\x02\x80\x02\x82\x02\x84\x02\x86\x02\x88\x02" +
		"\x8A\x02\x8C\x02\x8E\x02\x90\x02\x92\x02\x94\x02\x96\x02\x98\x02\x9A\x02" +
		"\x9C\x02\x9E\x02\xA0\x02\xA2\x02\xA4\x02\xA6\x02\xA8\x02\xAA\x02\xAC\x02" +
		"\xAE\x02\xB0\x02\xB2\x02\xB4\x02\xB6\x02\xB8\x02\xBA\x02\xBC\x02\xBE\x02" +
		"\xC0\x02\xC2\x02\xC4\x02\xC6\x02\xC8\x02\xCA\x02\xCC\x02\xCE\x02\xD0\x02" +
		"\xD2\x02\xD4\x02\xD6\x02\xD8\x02\xDA\x02\xDC\x02\xDE\x02\xE0\x02\xE2\x02" +
		"\xE4\x02\xE6\x02\xE8\x02\xEA\x02\xEC\x02\xEE\x02\xF0\x02\xF2\x02\xF4\x02" +
		"\xF6\x02\xF8\x02\xFA\x02\xFC\x02\xFE\x02\u0100\x02\u0102\x02\u0104\x02" +
		"\u0106\x02\u0108\x02\u010A\x02\u010C\x02\u010E\x02\u0110\x02\u0112\x02" +
		"\u0114\x02\u0116\x02\u0118\x02\u011A\x02\u011C\x02\u011E\x02\u0120\x02" +
		"\u0122\x02\u0124\x02\u0126\x02\u0128\x02\u012A\x02\u012C\x02\u012E\x02" +
		"\u0130\x02\u0132\x02\u0134\x02\u0136\x02\u0138\x02\u013A\x02\u013C\x02" +
		"\u013E\x02\u0140\x02\u0142\x02\u0144\x02\u0146\x02\u0148\x02\u014A\x02" +
		"\u014C\x02\u014E\x02\u0150\x02\u0152\x02\u0154\x02\u0156\x02\u0158\x02" +
		"\u015A\x02\u015C\x02\u015E\x02\u0160\x02\u0162\x02\u0164\x02\u0166\x02" +
		"\u0168\x02\u016A\x02\u016C\x02\u016E\x02\u0170\x02\u0172\x02\u0174\x02" +
		"\u0176\x02\u0178\x02\u017A\x02\u017C\x02\u017E\x02\u0180\x02\u0182\x02" +
		"\u0184\x02\u0186\x02\u0188\x02\u018A\x02\u018C\x02\x02A\x04\x02PP\xE2" +
		"\xE2\x04\x02$$\xF4\xF4\x04\x02{{\x8C\x8C\x04\x02\r\r))\x07\x0200<<llz" +
		"z\xAC\xAC\x03\x02XY\x04\x02llzz\x05\x02\n\naa\u011D\u011D\x04\x02\n\n" +
		"\xA6\xA6\x03\x02\u014B\u014C\x05\x02JJ\xBC\xBC\u0101\u0101\x05\x02KK\xBD" +
		"\xBD\u0102\u0102\x06\x02ff\x94\x94\u010A\u010A\u013F\u013F\x05\x02ff\u010A" +
		"\u010A\u013F\u013F\x04\x02\x17\x17XX\x04\x02tt\x9D\x9D\x05\x02\f\f\u011E" +
		"\u011E\u0147\u0147\x04\x02\u0120\u0120\u014D\u014D\x04\x02\u011F\u011F" +
		"\u012B\u012B\x04\x02??\xFC\xFC\x04\x02hh\x8D\x8D\x04\x02\f\f]]\x04\x02" +
		"\u0179\u0179\u017B\u017B\x04\x02^^\xD6\xD6\x04\x02\xCE\xCE\u0112\u0112" +
		"\x04\x02\xC3\xC3\u0163\u0163\x03\x02\xF7\xF8\x03\x02\xA2\xA3\x05\x02\f" +
		"\f\x12\x12\u0111\u0111\x05\x02oo\u0138\u0138\u0141\u0141\x04\x02\u0164" +
		"\u0165\u0169\u0169\x04\x02__\u0166\u0168\x04\x02\u0164\u0165\u016C\u016C" +
		"\r\x02EEGG\x86\x86\xB2\xB2\xB4\xB4\xB6\xB6\xB8\xB8\xE4\xE4\xFF\xFF\u0151" +
		"\u0151\u0158\u0158\x06\x02AACD\u0108\u0108\u0147\u0147\x04\x02LM\u012E" +
		"\u012E\x05\x02NO\u012A\u012A\u012F\u012F\x04\x02&&\u013A\u013A\x04\x02" +
		"\x8A\x8A\xF3\xF3\x03\x02\u011B\u011C\x04\x02\x06\x06{{\x04\x02\x06\x06" +
		"ww\x05\x02\x1E\x1E\xA0\xA0\u0133\u0133\x03\x02\xD9\xDA\x03\x02\u015B\u0162" +
		"\x04\x02__\u0164\u016D\x06\x02\x10\x10\x8C\x8C\xC3\xC3\xCD\xCD\x04\x02" +
		"oo\u0138\u0138\x03\x02\u0164\u0165\t\x02EF\x86\x87\xB2\xB9\xBE\xBF\xFF" +
		"\u0100\u0151\u0152\u0158\u0159\b\x02EE\x86\x86\xB6\xB6\xB8\xB8\xFF\xFF" +
		"\u0158\u0158\x04\x02\xB8\xB8\u0158\u0158\x06\x02EE\x86\x86\xB6\xB6\xFF" +
		"\xFF\x05\x02\x86\x86\xB6\xB6\xFF\xFF\x04\x02TT\u015B\u015B\x04\x02vv\xDF" +
		"\xDF\x04\x02\u0175\u0175\u0180\u0180\x03\x02\u017A\u017B\x04\x02aa\u0109" +
		"\u0109\x03\x02\u0174\u01755\x02\n\v\r\x0F\x11\x11\x13\x15\x17\x18\x1A" +
		"\x1D\x1F$\'+-0224:<<?@E\\^aeegnqqsvyz}\x80\x83\x83\x85\x8B\x8D\x8F\x91" +
		"\x93\x95\x97\x9A\x9A\x9C\x9D\x9F\x9F\xA2\xBF\xC1\xC1\xC5\xC7\xCB\xCC\xCF" +
		"\xCF\xD1\xD2\xD4\xD8\xDB\xDF\xE1\xEB\xED\xF5\xF7\u0102\u0104\u0107\u0109" +
		"\u0110\u0112\u0120\u0122\u0127\u012A\u0130\u0132\u0132\u0134\u013E\u0142" +
		"\u0146\u0149\u0152\u0155\u0155\u0158\u015A\x12\x02\x11\x11>>ff||\x90\x90" +
		"\x94\x94\x9B\x9B\x9E\x9E\xA1\xA1\xC0\xC0\xC9\xC9\xF6\xF6\u0104\u0104\u010A" +
		"\u010A\u013F\u013F\u0148\u0148\x14\x02\n\x10\x12=?eg{}\x8F\x91\x93\x95" +
		"\x9A\x9C\x9D\x9F\xA0\xA2\xBF\xC1\xC1\xC3\xC8\xCA\xF5\xF7\u0103\u0105\u0109" +
		"\u010B\u013E\u0140\u0147\u0149\u015A\x02\u1168\x02\u0191\x03\x02\x02\x02" +
		"\x04\u0196\x03\x02\x02\x02\x06\u04E1\x03\x02\x02\x02\b\u04E5\x03\x02\x02" +
		"\x02\n\u04E7\x03\x02\x02\x02\f\u04E9\x03\x02\x02\x02\x0E\u0593\x03\x02" +
		"\x02\x02\x10\u0595\x03\x02\x02\x02\x12\u05A4\x03\x02\x02\x02\x14\u05AA" +
		"\x03\x02\x02\x02\x16\u05B6\x03\x02\x02\x02\x18\u05C3\x03\x02\x02\x02\x1A" +
		"\u05C6\x03\x02\x02\x02\x1C\u05CA\x03\x02\x02\x02\x1E\u061B\x03\x02\x02" +
		"\x02 \u061D\x03\x02\x02\x02\"\u0621\x03\x02\x02\x02$\u0636\x03\x02\x02" +
		"\x02&\u0638\x03\x02\x02\x02(\u063A\x03\x02\x02\x02*\u0641\x03\x02\x02" +
		"\x02,\u0643\x03\x02\x02\x02.\u064B\x03\x02\x02\x020\u0654\x03\x02\x02" +
		"\x022\u065F\x03\x02\x02\x024\u0671\x03\x02\x02\x026\u0674\x03\x02\x02" +
		"\x028\u067F\x03\x02\x02\x02:\u068F\x03\x02\x02\x02<\u0695\x03\x02\x02" +
		"\x02>\u0697\x03\x02\x02\x02@\u06A2\x03\x02\x02\x02B\u06A9\x03\x02\x02" +
		"\x02D\u06B4\x03\x02\x02\x02F\u06C5\x03\x02\x02\x02H\u06CD\x03\x02\x02" +
		"\x02J\u06CF\x03\x02\x02\x02L\u06D5\x03\x02\x02\x02N\u0710\x03\x02\x02" +
		"\x02P\u0712\x03\x02\x02\x02R\u0714\x03\x02\x02\x02T\u0716\x03\x02\x02" +
		"\x02V\u0718\x03\x02\x02\x02X\u071A\x03\x02\x02\x02Z\u071C\x03\x02\x02" +
		"\x02\\\u071E\x03\x02\x02\x02^\u0720\x03\x02\x02\x02`\u0728\x03\x02\x02" +
		"\x02b\u0730\x03\x02\x02\x02d\u073C\x03\x02\x02\x02f\u0770\x03\x02\x02" +
		"\x02h\u0773\x03\x02\x02\x02j\u0796\x03\x02\x02\x02l\u079A\x03\x02\x02" +
		"\x02n\u07A3\x03\x02\x02\x02p\u07C4\x03\x02\x02\x02r\u07F2\x03\x02\x02" +
		"\x02t\u0807\x03\x02\x02\x02v\u0827\x03\x02\x02\x02x\u0833\x03\x02\x02" +
		"\x02z\u0836\x03\x02\x02\x02|\u083F\x03\x02\x02\x02~\u084D\x03\x02\x02" +
		"\x02\x80\u0860\x03\x02\x02\x02\x82\u0874\x03\x02\x02\x02\x84\u087A\x03" +
		"\x02\x02\x02\x86\u087C\x03\x02\x02\x02\x88\u0884\x03\x02\x02\x02\x8A\u0888" +
		"\x03\x02\x02\x02\x8C\u088B\x03\x02\x02\x02\x8E\u088E\x03\x02\x02\x02\x90" +
		"\u08A8\x03\x02\x02\x02\x92\u08AA\x03\x02\x02\x02\x94\u08BF\x03\x02\x02" +
		"\x02\x96\u08CF\x03\x02\x02\x02\x98\u08F8\x03\x02\x02\x02\x9A\u08FD\x03" +
		"\x02\x02\x02\x9C\u0918\x03\x02\x02\x02\x9E\u091C\x03\x02\x02\x02\xA0\u0932" +
		"\x03\x02\x02\x02\xA2\u0934\x03\x02\x02\x02\xA4\u0952\x03\x02\x02\x02\xA6" +
		"\u0954\x03\x02\x02\x02\xA8\u095B\x03\x02\x02\x02\xAA\u0968\x03\x02\x02" +
		"\x02\xAC\u096D\x03\x02\x02\x02\xAE\u096F\x03\x02\x02\x02\xB0\u097E\x03" +
		"\x02\x02\x02\xB2\u0996\x03\x02\x02\x02\xB4\u09A3\x03\x02\x02\x02\xB6\u09A5" +
		"\x03\x02\x02\x02\xB8\u09A7\x03\x02\x02\x02\xBA\u09AB\x03\x02\x02\x02\xBC" +
		"\u09AE\x03\x02\x02\x02\xBE\u09B2\x03\x02\x02\x02\xC0\u09B6\x03\x02\x02" +
		"\x02\xC2\u09B9\x03\x02\x02\x02\xC4\u09D9\x03\x02\x02\x02\xC6\u09E6\x03" +
		"\x02\x02\x02\xC8\u09EB\x03\x02\x02\x02\xCA\u09FE\x03\x02\x02\x02\xCC\u0A18" +
		"\x03\x02\x02\x02\xCE\u0A1E\x03\x02\x02\x02\xD0\u0A20\x03\x02\x02\x02\xD2" +
		"\u0A44\x03\x02\x02\x02\xD4\u0A46\x03\x02\x02\x02\xD6\u0A4A\x03\x02\x02" +
		"\x02\xD8";
	private static readonly _serializedATNSegment2: string =
		"\u0A52\x03\x02\x02\x02\xDA\u0A5D\x03\x02\x02\x02\xDC\u0A61\x03\x02\x02" +
		"\x02\xDE\u0A6C\x03\x02\x02\x02\xE0\u0A8B\x03\x02\x02\x02\xE2\u0A8D\x03" +
		"\x02\x02\x02\xE4\u0AAB\x03\x02\x02\x02\xE6\u0AC0\x03\x02\x02\x02\xE8\u0AD4" +
		"\x03\x02\x02\x02\xEA\u0ADA\x03\x02\x02\x02\xEC\u0ADE\x03\x02\x02\x02\xEE" +
		"\u0AE0\x03\x02\x02\x02\xF0\u0AF6\x03\x02\x02\x02\xF2\u0B29\x03\x02\x02" +
		"\x02\xF4\u0B2B\x03\x02\x02\x02\xF6\u0B33\x03\x02\x02\x02\xF8\u0B3B\x03" +
		"\x02\x02\x02\xFA\u0B43\x03\x02\x02\x02\xFC\u0B4B\x03\x02\x02\x02\xFE\u0B52" +
		"\x03\x02\x02\x02\u0100\u0B58\x03\x02\x02\x02\u0102\u0B63\x03\x02\x02\x02" +
		"\u0104\u0B6B\x03\x02\x02\x02\u0106\u0B78\x03\x02\x02\x02\u0108\u0B87\x03" +
		"\x02\x02\x02\u010A\u0B8B\x03\x02\x02\x02\u010C\u0B8D\x03\x02\x02\x02\u010E" +
		"\u0B8F\x03\x02\x02\x02\u0110\u0B95\x03\x02\x02\x02\u0112\u0B97\x03\x02" +
		"\x02\x02\u0114\u0BAB\x03\x02\x02\x02\u0116\u0C0A\x03\x02\x02\x02\u0118" +
		"\u0C10\x03\x02\x02\x02\u011A\u0C2A\x03\x02\x02\x02\u011C\u0D25\x03\x02" +
		"\x02\x02\u011E\u0D3B\x03\x02\x02\x02\u0120\u0D4C\x03\x02\x02\x02\u0122" +
		"\u0D4E\x03\x02\x02\x02\u0124\u0D50\x03\x02\x02\x02\u0126\u0D52\x03\x02" +
		"\x02\x02\u0128\u0D54\x03\x02\x02\x02\u012A\u0D56\x03\x02\x02\x02\u012C" +
		"\u0D5B\x03\x02\x02\x02\u012E\u0D62\x03\x02\x02\x02\u0130\u0D66\x03\x02" +
		"\x02\x02\u0132\u0D6B\x03\x02\x02\x02\u0134\u0D71\x03\x02\x02\x02\u0136" +
		"\u0D78\x03\x02\x02\x02\u0138\u0D7A\x03\x02\x02\x02\u013A\u0D7F\x03\x02" +
		"\x02\x02\u013C\u0D9F\x03\x02\x02\x02\u013E\u0DCF\x03\x02\x02\x02\u0140" +
		"\u0DD1\x03\x02\x02\x02\u0142\u0DD9\x03\x02\x02\x02\u0144\u0DE1\x03\x02" +
		"\x02\x02\u0146\u0DE9\x03\x02\x02\x02\u0148\u0DF6\x03\x02\x02\x02\u014A" +
		"\u0DF8\x03\x02\x02\x02\u014C\u0DFB\x03\x02\x02\x02\u014E\u0DFE\x03\x02" +
		"\x02\x02\u0150\u0E06\x03\x02\x02\x02\u0152\u0E0F\x03\x02\x02\x02\u0154" +
		"\u0E17\x03\x02\x02\x02\u0156\u0E24\x03\x02\x02\x02\u0158\u0E26\x03\x02" +
		"\x02\x02\u015A\u0E2D\x03\x02\x02\x02\u015C\u0E35\x03\x02\x02\x02\u015E" +
		"\u0E41\x03\x02\x02\x02\u0160\u0E46\x03\x02\x02\x02\u0162\u0E4F\x03\x02" +
		"\x02\x02\u0164\u0E81\x03\x02\x02\x02\u0166\u0E93\x03\x02\x02\x02\u0168" +
		"\u0E9C\x03\x02\x02\x02\u016A\u0E9E\x03\x02\x02\x02\u016C\u0EAF\x03\x02" +
		"\x02\x02\u016E\u0EB1\x03\x02\x02\x02\u0170\u0EB3\x03\x02\x02\x02\u0172" +
		"\u0EBB\x03\x02\x02\x02\u0174\u0EC5\x03\x02\x02\x02\u0176\u0EC9\x03\x02" +
		"\x02\x02\u0178\u0ECF\x03\x02\x02\x02\u017A\u0ED1\x03\x02\x02\x02\u017C" +
		"\u0ED3\x03\x02\x02\x02\u017E\u0EFD\x03\x02\x02\x02\u0180\u0F0A\x03\x02" +
		"\x02\x02\u0182\u0F0C\x03\x02\x02\x02\u0184\u0F10\x03\x02\x02\x02\u0186" +
		"\u0F14\x03\x02\x02\x02\u0188\u0F16\x03\x02\x02\x02\u018A\u0F18\x03\x02" +
		"\x02\x02\u018C\u0F1A\x03\x02\x02\x02\u018E\u0190\x05\x04\x03\x02\u018F" +
		"\u018E\x03\x02\x02\x02\u0190\u0193\x03\x02\x02\x02\u0191\u018F\x03\x02" +
		"\x02\x02\u0191\u0192\x03\x02\x02\x02\u0192\u0194\x03\x02\x02\x02\u0193" +
		"\u0191\x03\x02\x02\x02\u0194\u0195\x07\x02\x02\x03\u0195\x03\x03\x02\x02" +
		"\x02\u0196\u0198\x05\x06\x04\x02\u0197\u0199\x07\x03\x02\x02\u0198\u0197" +
		"\x03\x02\x02\x02\u0198\u0199\x03\x02\x02\x02\u0199\x05\x03\x02\x02\x02" +
		"\u019A\u04E2\x05\x1C\x0F\x02\u019B\u019D\x05.\x18\x02\u019C\u019B\x03" +
		"\x02\x02\x02\u019C\u019D\x03\x02\x02\x02\u019D\u019E\x03\x02\x02\x02\u019E" +
		"\u04E2\x05N(\x02\u019F\u01A0\x07\u0146\x02\x02\u01A0\u04E2\x05P)\x02\u01A1" +
		"\u01A2\x07\u0146\x02\x02\u01A2\u01A3\x05&\x14\x02\u01A3\u01A4\x05P)\x02" +
		"\u01A4\u04E2\x03\x02\x02\x02\u01A5\u01A6\x07\u0109\x02\x02\u01A6\u01A9" +
		"\x07\'\x02\x02\u01A7\u01AA\x05\u0176\xBC\x02\u01A8\u01AA\x05\u0182\xC2" +
		"\x02\u01A9\u01A7\x03\x02\x02\x02\u01A9\u01A8\x03\x02\x02\x02\u01AA\u04E2" +
		"\x03\x02\x02\x02\u01AB\u01AC\x07=\x02\x02\u01AC\u01AE\x05&\x14\x02\u01AD" +
		"\u01AF\x05\xBE`\x02\u01AE\u01AD\x03\x02\x02\x02\u01AE\u01AF\x03\x02\x02" +
		"\x02\u01AF\u01B0\x03\x02\x02\x02\u01B0\u01B8\x05R*\x02\u01B1\u01B7\x05" +
		"\x1A\x0E\x02\u01B2\u01B7\x05\x18\r\x02\u01B3\u01B4\x07\u0156\x02\x02\u01B4" +
		"\u01B5\t\x02\x02\x02\u01B5\u01B7\x056\x1C\x02\u01B6\u01B1\x03\x02\x02" +
		"\x02\u01B6\u01B2\x03\x02\x02\x02\u01B6\u01B3\x03\x02\x02\x02\u01B7\u01BA" +
		"\x03\x02\x02\x02\u01B8\u01B6\x03\x02\x02\x02\u01B8\u01B9\x03\x02\x02\x02" +
		"\u01B9\u04E2\x03\x02\x02\x02\u01BA\u01B8\x03\x02\x02\x02\u01BB\u01BC\x07" +
		"\r\x02\x02\u01BC\u01BD\x05&\x14\x02\u01BD\u01BE\x05P)\x02\u01BE\u01BF" +
		"\x07\u0109\x02\x02\u01BF\u01C0\t\x02\x02\x02\u01C0\u01C1\x056\x1C\x02" +
		"\u01C1\u04E2\x03\x02\x02\x02\u01C2\u01C3\x07\r\x02\x02\u01C3\u01C4\x05" +
		"&\x14\x02\u01C4\u01C5\x05P)\x02\u01C5\u01C6\x07\u0109\x02\x02\u01C6\u01C7" +
		"\x05\x18\r\x02\u01C7\u04E2\x03\x02\x02\x02\u01C8\u01C9\x07a\x02\x02\u01C9" +
		"\u01CB\x05&\x14\x02\u01CA\u01CC\x05\xC0a\x02\u01CB\u01CA\x03\x02\x02\x02" +
		"\u01CB\u01CC\x03\x02\x02\x02\u01CC\u01CD\x03\x02\x02\x02\u01CD\u01CF\x05" +
		"P)\x02\u01CE\u01D0\t\x03\x02\x02\u01CF\u01CE\x03\x02\x02\x02\u01CF\u01D0" +
		"\x03\x02\x02\x02\u01D0\u04E2\x03\x02\x02\x02\u01D1\u01D2\x07\u010D\x02" +
		"\x02\u01D2\u01D5\x05(\x15\x02\u01D3\u01D4\t\x04\x02\x02\u01D4\u01D6\x05" +
		"\xF6|\x02\u01D5\u01D3\x03\x02\x02\x02\u01D5\u01D6\x03\x02\x02\x02\u01D6" +
		"\u01DB\x03\x02\x02\x02\u01D7\u01D9\x07\xA2\x02\x02\u01D8\u01D7\x03\x02" +
		"\x02\x02\u01D8\u01D9\x03\x02\x02\x02\u01D9\u01DA\x03\x02\x02\x02\u01DA" +
		"\u01DC\x05\u0182\xC2\x02\u01DB\u01D8\x03\x02\x02\x02\u01DB\u01DC\x03\x02" +
		"\x02\x02\u01DC\u04E2\x03\x02\x02\x02\u01DD\u01E2\x05\x10\t\x02\u01DE\u01DF" +
		"\x07\x04\x02\x02\u01DF\u01E0\x05\u0152\xAA\x02\u01E0\u01E1\x07\x05\x02" +
		"\x02\u01E1\u01E3\x03\x02\x02\x02\u01E2\u01DE\x03\x02\x02\x02\u01E2\u01E3" +
		"\x03\x02\x02\x02\u01E3\u01E5\x03\x02\x02\x02\u01E4\u01E6\x052\x1A\x02" +
		"\u01E5\u01E4\x03\x02\x02\x02\u01E5\u01E6\x03\x02\x02\x02\u01E6\u01E7\x03" +
		"\x02\x02\x02\u01E7\u01EC\x054\x1B\x02\u01E8\u01EA\x07\x16\x02\x02\u01E9" +
		"\u01E8\x03\x02\x02\x02\u01E9\u01EA\x03\x02\x02\x02\u01EA\u01EB\x03\x02" +
		"\x02\x02\u01EB\u01ED\x05\x1C\x0F\x02\u01EC\u01E9\x03\x02\x02\x02\u01EC" +
		"\u01ED\x03\x02\x02\x02\u01ED\u04E2\x03\x02\x02\x02\u01EE\u01EF\x07=\x02" +
		"\x02\u01EF\u01F1\x07\u0121\x02\x02\u01F0\u01F2\x05\xBE`\x02\u01F1\u01F0" +
		"\x03\x02\x02\x02\u01F1\u01F2\x03\x02\x02\x02\u01F2\u01F3\x03\x02\x02\x02" +
		"\u01F3\u01F4\x05T+\x02\u01F4\u01F5\x07\xA2\x02\x02\u01F5\u01FE\x05V,\x02" +
		"\u01F6\u01FD\x052\x1A\x02\u01F7\u01FD\x05\xF2z\x02\u01F8\u01FD\x05F$\x02" +
		"\u01F9\u01FD\x05\x18\r\x02\u01FA\u01FB\x07\u0125\x02\x02\u01FB\u01FD\x05" +
		"6\x1C\x02\u01FC\u01F6\x03\x02\x02\x02\u01FC\u01F7\x03\x02\x02\x02\u01FC" +
		"\u01F8\x03\x02\x02\x02\u01FC\u01F9\x03\x02\x02\x02\u01FC\u01FA\x03\x02" +
		"\x02\x02\u01FD\u0200\x03\x02\x02\x02\u01FE\u01FC\x03\x02\x02\x02\u01FE" +
		"\u01FF\x03\x02\x02\x02\u01FF\u04E2\x03\x02\x02\x02\u0200\u01FE\x03\x02" +
		"\x02\x02\u0201\u0206\x05\x12\n\x02\u0202\u0203\x07\x04\x02\x02\u0203\u0204" +
		"\x05\u0152\xAA\x02\u0204\u0205\x07\x05\x02\x02\u0205\u0207\x03\x02\x02" +
		"\x02\u0206\u0202\x03\x02\x02\x02\u0206\u0207\x03\x02\x02\x02\u0207\u0209" +
		"\x03\x02\x02\x02\u0208\u020A\x052\x1A\x02\u0209\u0208\x03\x02\x02\x02" +
		"\u0209\u020A\x03\x02\x02\x02\u020A\u020B\x03\x02\x02\x02\u020B\u0210\x05" +
		"4\x1B\x02\u020C\u020E\x07\x16\x02\x02\u020D\u020C\x03\x02\x02\x02\u020D" +
		"\u020E\x03\x02\x02\x02\u020E\u020F\x03\x02\x02\x02\u020F\u0211\x05\x1C" +
		"\x0F\x02\u0210\u020D\x03\x02\x02\x02\u0210\u0211\x03\x02\x02\x02\u0211" +
		"\u04E2\x03\x02\x02\x02\u0212\u0213\x07\x0F\x02\x02\u0213\u0214\x07\u0121" +
		"\x02\x02\u0214\u0216\x05V,\x02\u0215\u0217\x05\"\x12\x02\u0216\u0215\x03" +
		"\x02\x02\x02\u0216\u0217\x03\x02\x02\x02\u0217\u0218\x03\x02\x02\x02\u0218" +
		"\u0219\x079\x02\x02\u0219\u0221\x07\u0116\x02\x02\u021A\u0222\x07\xC2" +
		"\x02\x02\u021B\u021C\x07w\x02\x02\u021C\u021D\x074\x02\x02\u021D\u0222" +
		"\x05^0\x02\u021E\u021F\x07w\x02\x02\u021F\u0220\x07\f\x02\x02\u0220\u0222" +
		"\x074\x02\x02\u0221\u021A\x03\x02\x02\x02\u0221\u021B\x03\x02\x02\x02" +
		"\u0221\u021E\x03\x02\x02\x02\u0221\u0222\x03\x02\x02\x02\u0222\u04E2\x03" +
		"\x02\x02\x02\u0223\u0224\x07\x0F\x02\x02\u0224\u0227\x07\u0122\x02\x02" +
		"\u0225\u0226\t\x04\x02\x02\u0226\u0228\x05P)\x02\u0227\u0225\x03\x02\x02" +
		"\x02\u0227\u0228\x03\x02\x02\x02\u0228\u0229\x03\x02\x02\x02\u0229\u022A" +
		"\x079\x02\x02\u022A\u022C\x07\u0116\x02\x02\u022B\u022D\x07\xC2\x02\x02" +
		"\u022C\u022B\x03\x02\x02\x02\u022C\u022D\x03\x02\x02\x02\u022D\u04E2\x03" +
		"\x02\x02\x02\u022E\u022F\x07\r\x02\x02\u022F\u0230\x07\u0121\x02\x02\u0230" +
		"\u0231\x05V,\x02\u0231\u0232\x07\n\x02\x02\u0232\u0233\x073\x02\x02\u0233" +
		"\u0234\x05\u0142\xA2\x02\u0234\u04E2\x03\x02\x02\x02\u0235\u0236\x07\r" +
		"\x02\x02\u0236\u0237\x07\u0121\x02\x02\u0237\u0238\x05V,\x02\u0238\u0239" +
		"\x07\n\x02\x02\u0239\u023A\x074\x02\x02\u023A\u023B\x07\x04\x02\x02\u023B" +
		"\u023C\x05\u0140\xA1\x02\u023C\u023D\x07\x05\x02\x02\u023D\u04E2\x03\x02" +
		"\x02\x02\u023E\u023F\x07\r\x02\x02\u023F\u0240\x07\u0121\x02\x02\u0240" +
		"\u0241\x05V,\x02\u0241\u0242\x07\xEE\x02\x02\u0242\u0243\x073\x02\x02" +
		"\u0243\u0244\x05\\/\x02\u0244\u0245\x07\u0131\x02\x02\u0245\u0246\x05" +
		"`1\x02\u0246\u04E2\x03\x02\x02\x02\u0247\u0248\x07\r\x02\x02\u0248\u0249" +
		"\x07\u0121\x02\x02\u0249\u024A\x05V,\x02\u024A\u024B\x07a\x02\x02\u024B" +
		"\u024D\x073\x02\x02\u024C\u024E\x05\xC0a\x02\u024D\u024C\x03\x02\x02\x02" +
		"\u024D\u024E\x03\x02\x02\x02\u024E\u024F\x03\x02\x02\x02\u024F\u0250\x05" +
		"\\/\x02\u0250\u04E2\x03\x02\x02\x02\u0251\u0252\x07\r\x02\x02\u0252\u0253" +
		"\x07\u0121\x02\x02\u0253\u0254\x05V,\x02\u0254\u0255\x07a\x02\x02\u0255" +
		"\u0257\x074\x02\x02\u0256\u0258\x05\xC0a\x02\u0257\u0256\x03\x02\x02\x02" +
		"\u0257\u0258\x03\x02\x02\x02\u0258\u0259\x03\x02\x02\x02\u0259\u025A\x07" +
		"\x04\x02\x02\u025A\u025B\x05^0\x02\u025B\u025C\x07\x05\x02\x02\u025C\u04E2" +
		"\x03\x02\x02\x02\u025D\u0262\x07\r\x02\x02\u025E\u025F\x07\u0121\x02\x02" +
		"\u025F\u0263\x05V,\x02\u0260\u0261\x07\u014E\x02\x02\u0261\u0263\x05Z" +
		".\x02\u0262\u025E\x03\x02\x02\x02\u0262\u0260\x03\x02\x02\x02\u0263\u0264" +
		"\x03\x02\x02\x02\u0264\u0265\x07\xEE\x02\x02\u0265\u0266\x07\u0131\x02" +
		"\x02\u0266\u0267\x05\xF6|\x02\u0267\u04E2\x03\x02\x02\x02\u0268\u026D" +
		"\x07\r\x02\x02\u0269\u026A\x07\u0121\x02\x02\u026A\u026E\x05V,\x02\u026B" +
		"\u026C\x07\u014E\x02\x02\u026C\u026E\x05Z.\x02\u026D\u0269\x03\x02\x02" +
		"\x02\u026D\u026B\x03\x02\x02\x02\u026E\u026F\x03\x02\x02\x02\u026F\u0270" +
		"\x07\u0109\x02\x02\u0270\u0271\x07\u0125\x02\x02\u0271\u0272\x056\x1C" +
		"\x02\u0272\u04E2\x03\x02\x02\x02\u0273\u0278\x07\r\x02\x02\u0274\u0275" +
		"\x07\u0121\x02\x02\u0275\u0279\x05V,\x02\u0276\u0277\x07\u014E\x02\x02" +
		"\u0277\u0279\x05Z.\x02\u0278\u0274\x03\x02\x02\x02\u0278\u0276\x03\x02" +
		"\x02\x02\u0279\u027A\x03\x02\x02\x02\u027A\u027B\x07\u0144\x02\x02\u027B" +
		"\u027D\x07\u0125\x02\x02\u027C\u027E\x05\xC0a\x02\u027D\u027C\x03\x02" +
		"\x02\x02\u027D\u027E\x03\x02\x02\x02\u027E\u027F\x03\x02\x02\x02\u027F" +
		"\u0280\x056\x1C\x02\u0280\u04E2\x03\x02\x02\x02\u0281\u0282\x07\r\x02" +
		"\x02\u0282\u0283\x07\u0121\x02\x02\u0283\u0284\x05V,\x02\u0284\u0286\t" +
		"\x05\x02\x02\u0285\u0287\x073\x02\x02\u0286\u0285\x03\x02\x02\x02\u0286" +
		"\u0287\x03\x02\x02\x02\u0287\u0288\x03\x02\x02\x02\u0288\u028A\x05\\/" +
		"\x02\u0289\u028B\x05\u0180\xC1\x02\u028A\u0289\x03\x02\x02\x02\u028A\u028B" +
		"\x03\x02\x02\x02\u028B\u04E2\x03\x02\x02\x02\u028C\u028D\x07\r\x02\x02" +
		"\u028D\u028E\x07\u0121\x02\x02\u028E\u0290\x05V,\x02\u028F\u0291\x05\"" +
		"\x12\x02\u0290\u028F\x03\x02\x02\x02\u0290\u0291\x03\x02\x02\x02\u0291" +
		"\u0292\x03\x02\x02\x02\u0292\u0294\x07)\x02\x02\u0293\u0295\x073\x02\x02" +
		"\u0294\u0293\x03\x02\x02\x02\u0294\u0295\x03\x02\x02\x02\u0295\u0296\x03" +
		"\x02\x02\x02\u0296\u0297\x05\\/\x02\u0297\u0299\x05\u0150\xA9\x02\u0298" +
		"\u029A\x05\u013A\x9E\x02\u0299\u0298\x03\x02\x02\x02\u0299\u029A\x03\x02" +
		"\x02\x02\u029A\u04E2\x03\x02\x02\x02\u029B\u029C\x07\r\x02\x02\u029C\u029D" +
		"\x07\u0121\x02\x02\u029D\u029F\x05V,\x02\u029E\u02A0\x05\"\x12\x02\u029F" +
		"\u029E\x03\x02\x02\x02\u029F\u02A0\x03\x02\x02\x02\u02A0\u02A1\x03\x02" +
		"\x02\x02\u02A1\u02A2\x07\xF1\x02\x02\u02A2\u02A3\x074\x02\x02\u02A3\u02A4" +
		"\x07\x04\x02\x02\u02A4\u02A5\x05\u0144\xA3\x02\u02A5\u02A6\x07\x05\x02" +
		"\x02\u02A6\u04E2\x03\x02\x02\x02\u02A7\u02A8\x07\r\x02\x02\u02A8\u02A9" +
		"\x07\u0121\x02\x02\u02A9\u02AB\x05V,\x02\u02AA\u02AC\x05\"\x12\x02\u02AB" +
		"\u02AA\x03\x02\x02\x02\u02AB\u02AC\x03\x02\x02\x02\u02AC\u02AD\x03\x02" +
		"\x02\x02\u02AD\u02AE\x07\u0109\x02\x02\u02AE\u02AF\x07\u0106\x02\x02\u02AF" +
		"\u02B3\x05\u0182\xC2\x02\u02B0\u02B1\x07\u0156\x02\x02\u02B1\u02B2\x07" +
		"\u0107\x02\x02\u02B2\u02B4\x056\x1C\x02\u02B3\u02B0\x03\x02\x02\x02\u02B3" +
		"\u02B4\x03\x02\x02\x02\u02B4\u04E2\x03\x02\x02\x02\u02B5\u02B6\x07\r\x02" +
		"\x02\u02B6\u02B7\x07\u0121\x02\x02\u02B7\u02B9\x05V,\x02\u02B8\u02BA\x05" +
		"\"\x12\x02\u02B9\u02B8\x03\x02\x02\x02\u02B9\u02BA\x03\x02\x02\x02\u02BA" +
		"\u02BB\x03\x02\x02\x02\u02BB\u02BC\x07\u0109\x02\x02\u02BC\u02BD\x07\u0107" +
		"\x02\x02\u02BD\u02BE\x056\x1C\x02\u02BE\u04E2\x03\x02\x02\x02\u02BF\u02C4" +
		"\x07\r\x02\x02\u02C0\u02C1\x07\u0121\x02\x02\u02C1\u02C5\x05V,\x02\u02C2" +
		"\u02C3\x07\u014E\x02\x02\u02C3\u02C5\x05Z.\x02\u02C4\u02C0\x03\x02\x02" +
		"\x02\u02C4\u02C2\x03\x02\x02\x02\u02C5\u02C6\x03\x02\x02\x02\u02C6\u02C8" +
		"\x07\n\x02\x02\u02C7\u02C9\x05\xBE`\x02\u02C8\u02C7\x03\x02\x02\x02\u02C8" +
		"\u02C9\x03\x02\x02\x02\u02C9\u02CB\x03\x02\x02\x02\u02CA\u02CC\x05 \x11" +
		"\x02\u02CB\u02CA\x03\x02\x02\x02\u02CC\u02CD\x03\x02\x02\x02\u02CD\u02CB" +
		"\x03\x02\x02\x02\u02CD\u02CE\x03\x02\x02\x02\u02CE\u04E2\x03\x02\x02\x02" +
		"\u02CF\u02D0\x07\r\x02\x02\u02D0\u02D1\x07\u0121\x02\x02\u02D1\u02D2\x05" +
		"V,\x02\u02D2\u02D3\x05\"\x12\x02\u02D3\u02D4\x07\xEE\x02\x02\u02D4\u02D5" +
		"\x07\u0131\x02\x02\u02D5\u02D6\x05\"\x12\x02\u02D6\u04E2\x03\x02\x02\x02" +
		"\u02D7\u02DC\x07\r\x02\x02\u02D8\u02D9\x07\u0121\x02\x02\u02D9\u02DD\x05" +
		"V,\x02\u02DA\u02DB\x07\u014E\x02\x02\u02DB\u02DD\x05Z.\x02\u02DC\u02D8" +
		"\x03\x02\x02\x02\u02DC\u02DA\x03\x02\x02\x02\u02DD\u02DE\x03\x02\x02\x02" +
		"\u02DE\u02E0\x07a\x02\x02\u02DF\u02E1\x05\xC0a\x02\u02E0\u02DF\x03\x02" +
		"\x02\x02\u02E0\u02E1\x03\x02\x02\x02\u02E1\u02E2\x03\x02\x02\x02\u02E2" +
		"\u02E7\x05\"\x12\x02\u02E3\u02E4\x07\x06\x02\x02\u02E4\u02E6\x05\"\x12" +
		"\x02\u02E5\u02E3\x03\x02\x02\x02\u02E6\u02E9\x03\x02\x02\x02\u02E7\u02E5" +
		"\x03\x02\x02\x02\u02E7\u02E8\x03\x02\x02\x02\u02E8\u02EB\x03\x02\x02\x02" +
		"\u02E9\u02E7\x03\x02\x02\x02\u02EA\u02EC\x07\xE3\x02\x02\u02EB\u02EA\x03" +
		"\x02\x02\x02\u02EB\u02EC\x03\x02\x02\x02\u02EC\u04E2\x03\x02\x02\x02\u02ED" +
		"\u02EE\x07\r\x02\x02\u02EE\u02EF\x07\u0121\x02\x02\u02EF\u02F1\x05V,\x02" +
		"\u02F0\u02F2\x05\"\x12\x02\u02F1\u02F0\x03\x02\x02\x02\u02F1\u02F2\x03" +
		"\x02\x02\x02\u02F2\u02F3\x03\x02\x02\x02\u02F3\u02F4\x07\u0109\x02\x02" +
		"\u02F4\u02F5\x05\x18\r\x02\u02F5\u04E2\x03\x02\x02\x02\u02F6\u02F7\x07" +
		"\r\x02\x02\u02F7\u02F8\x07\u0121\x02\x02\u02F8\u02F9\x05V,\x02\u02F9\u02FA" +
		"\x07\xEA\x02\x02\u02FA\u02FB\x07\xD8\x02\x02\u02FB\u04E2\x03\x02\x02\x02" +
		"\u02FC\u02FD\x07a\x02\x02\u02FD\u02FF\x07\u0121\x02\x02\u02FE\u0300\x05" +
		"\xC0a\x02\u02FF\u02FE\x03\x02\x02\x02\u02FF\u0300\x03\x02\x02\x02\u0300" +
		"\u0301\x03\x02\x02\x02\u0301\u0303\x05V,\x02\u0302\u0304\x07\xE3\x02\x02" +
		"\u0303\u0302\x03\x02\x02\x02\u0303\u0304\x03\x02\x02\x02\u0304\u04E2\x03" +
		"\x02\x02\x02\u0305\u0306\x07a\x02\x02\u0306\u0308\x07\u014E\x02\x02\u0307" +
		"\u0309\x05\xC0a\x02\u0308\u0307\x03\x02\x02\x02\u0308\u0309\x03\x02\x02" +
		"\x02\u0309\u030A\x03\x02\x02\x02\u030A\u04E2\x05Z.\x02\u030B\u030E\x07" +
		"=\x02\x02\u030C\u030D\x07\xCD\x02\x02\u030D\u030F\x07\xF1\x02\x02\u030E" +
		"\u030C\x03\x02\x02\x02\u030E\u030F\x03\x02\x02\x02\u030F\u0314\x03\x02" +
		"\x02\x02\u0310\u0312\x07\x80\x02\x02\u0311\u0310\x03\x02\x02\x02\u0311" +
		"\u0312\x03\x02\x02\x02\u0312\u0313\x03\x02\x02\x02\u0313\u0315\x07\u0126" +
		"\x02\x02\u0314\u0311\x03\x02\x02\x02\u0314\u0315\x03\x02\x02\x02\u0315" +
		"\u0316\x03\x02\x02\x02\u0316\u0318\x07\u014E\x02\x02\u0317\u0319\x05\xBE" +
		"`\x02\u0318\u0317\x03\x02\x02\x02\u0318\u0319\x03\x02\x02\x02\u0319\u031A" +
		"\x03\x02\x02\x02\u031A\u031C\x05X-\x02\u031B\u031D\x05\xDCo\x02\u031C" +
		"\u031B\x03\x02\x02\x02\u031C\u031D\x03\x02\x02\x02\u031D\u0326\x03\x02" +
		"\x02\x02\u031E\u0325\x05\x1A\x0E\x02\u031F\u0320\x07\xD7\x02\x02\u0320" +
		"\u0321\x07\xC9\x02\x02\u0321\u0325\x05\xD4k\x02\u0322\u0323\x07\u0125" +
		"\x02\x02\u0323\u0325\x056\x1C\x02\u0324\u031E\x03\x02\x02\x02\u0324\u031F" +
		"\x03\x02\x02\x02\u0324\u0322\x03\x02\x02\x02\u0325\u0328\x03\x02\x02\x02" +
		"\u0326\u0324\x03\x02\x02\x02\u0326\u0327\x03\x02\x02\x02\u0327\u0329\x03" +
		"\x02\x02\x02\u0328\u0326\x03\x02\x02\x02\u0329\u032A\x07\x16\x02\x02\u032A" +
		"\u032B\x05\x1C\x0F\x02\u032B\u04E2\x03\x02\x02\x02\u032C\u032F\x07=\x02" +
		"\x02\u032D\u032E\x07\xCD\x02\x02\u032E\u0330\x07\xF1\x02\x02\u032F\u032D" +
		"\x03\x02\x02\x02\u032F\u0330\x03\x02\x02\x02\u0330\u0332\x03\x02\x02\x02" +
		"\u0331\u0333\x07\x80\x02\x02\u0332\u0331\x03\x02\x02\x02\u0332\u0333\x03" +
		"\x02\x02\x02\u0333\u0334\x03\x02\x02\x02\u0334\u0335\x07\u0126\x02\x02" +
		"\u0335\u0336\x07\u014E\x02\x02\u0336\u033B\x05X-\x02\u0337\u0338\x07\x04" +
		"\x02\x02\u0338\u0339\x05\u014E\xA8\x02\u0339\u033A\x07\x05\x02\x02\u033A" +
		"\u033C\x03\x02\x02\x02\u033B\u0337\x03\x02\x02\x02\u033B\u033C\x03\x02" +
		"\x02\x02\u033C\u033D\x03\x02\x02\x02\u033D\u0340\x052\x1A\x02\u033E\u033F" +
		"\x07\xCC\x02\x02\u033F\u0341\x056\x1C\x02\u0340\u033E\x03\x02\x02\x02" +
		"\u0340\u0341\x03\x02\x02\x02\u0341\u04E2\x03\x02\x02\x02\u0342\u0343\x07" +
		"\r\x02\x02\u0343\u0344\x07\u014E\x02\x02\u0344\u0346\x05Z.\x02\u0345\u0347" +
		"\x07\x16\x02\x02\u0346\u0345\x03\x02\x02\x02\u0346\u0347\x03\x02\x02\x02" +
		"\u0347\u0348\x03\x02\x02\x02\u0348\u0349\x05\x1C\x0F\x02\u0349\u04E2\x03" +
		"\x02\x02\x02\u034A\u034D\x07=\x02\x02\u034B\u034C\x07\xCD\x02\x02\u034C" +
		"\u034E\x07\xF1\x02\x02\u034D\u034B\x03\x02\x02\x02\u034D\u034E\x03\x02" +
		"\x02\x02\u034E\u0350\x03\x02\x02\x02\u034F\u0351\x07\u0126\x02\x02\u0350" +
		"\u034F\x03\x02\x02\x02\u0350\u0351\x03\x02\x02\x02\u0351\u0352\x03\x02" +
		"\x02\x02\u0352\u0354\x07}\x02\x02\u0353\u0355\x05\xBE`\x02\u0354\u0353" +
		"\x03\x02\x02\x02\u0354\u0355\x03\x02\x02\x02\u0355\u0356\x03\x02\x02\x02" +
		"\u0356\u0357\x05\u016E\xB8\x02\u0357\u0358\x07\x16\x02\x02\u0358\u0362" +
		"\x05\u0182\xC2\x02\u0359\u035A\x07\u0148\x02\x02\u035A\u035F\x05L\'\x02" +
		"\u035B\u035C\x07\x06\x02\x02\u035C\u035E\x05L\'\x02\u035D\u035B\x03\x02" +
		"\x02\x02\u035E\u0361\x03\x02\x02\x02\u035F\u035D\x03\x02\x02\x02\u035F" +
		"\u0360\x03\x02\x02\x02\u0360\u0363\x03\x02\x02\x02\u0361\u035F\x03\x02" +
		"\x02\x02\u0362\u0359\x03\x02\x02\x02\u0362\u0363\x03\x02\x02\x02\u0363" +
		"\u04E2\x03\x02\x02\x02\u0364\u0366\x07a\x02\x02\u0365\u0367\x07\u0126" +
		"\x02\x02\u0366\u0365\x03\x02\x02\x02\u0366\u0367\x03\x02\x02\x02\u0367" +
		"\u0368\x03\x02\x02\x02\u0368\u036A\x07}\x02\x02\u0369\u036B\x05\xC0a\x02" +
		"\u036A\u0369\x03\x02\x02\x02\u036A\u036B\x03\x02\x02\x02\u036B\u036C\x03" +
		"\x02\x02\x02\u036C\u04E2\x05\u016C\xB7\x02\u036D\u0370\x07S\x02\x02\u036E" +
		"\u036F\x07\xCD\x02\x02\u036F\u0371\x07\xF1\x02\x02\u0370\u036E\x03\x02" +
		"\x02\x02\u0370\u0371\x03\x02\x02\x02\u0371\u0373\x03\x02\x02\x02\u0372" +
		"\u0374\x07\u014C\x02\x02\u0373\u0372\x03\x02\x02\x02\u0373\u0374\x03\x02" +
		"\x02\x02\u0374\u0375\x03\x02\x02\x02\u0375\u0377\x05\u016C\xB7\x02\u0376" +
		"\u0378\x05\u013E\xA0\x02\u0377\u0376\x03\x02\x02\x02\u0377\u0378\x03\x02" +
		"\x02\x02\u0378\u037A\x03\x02\x02\x02\u0379\u037B\x05\u014C\xA7\x02\u037A" +
		"\u0379\x03\x02\x02\x02\u037A\u037B\x03\x02\x02\x02\u037B\u04E2\x03\x02" +
		"\x02\x02\u037C\u037D\x07a\x02\x02\u037D\u037E\x07\u0126\x02\x02\u037E" +
		"\u0380\x07\u014C\x02\x02\u037F\u0381\x05\xC0a\x02\u0380\u037F\x03\x02" +
		"\x02\x02\u0380\u0381\x03\x02\x02\x02\u0381\u0385\x03\x02\x02\x02\u0382" +
		"\u0386\x05V,\x02\u0383\u0386\x05Z.\x02\u0384\u0386\x05\u016C\xB7\x02\u0385" +
		"\u0382\x03\x02\x02\x02\u0385\u0383\x03\x02\x02\x02\u0385\u0384\x03\x02" +
		"\x02\x02\u0386\u04E2\x03\x02\x02\x02\u0387\u0389\x07j\x02\x02\u0388\u038A" +
		"\t\x06\x02\x02\u0389\u0388\x03\x02\x02\x02\u0389\u038A\x03\x02\x02\x02" +
		"\u038A\u038B\x03\x02\x02\x02\u038B\u04E2\x05\x06\x04\x02\u038C\u038D\x07" +
		"\u010D\x02\x02\u038D\u0390\x07\u0122\x02\x02\u038E\u038F\t\x04\x02\x02" +
		"\u038F\u0391\x05P)\x02\u0390\u038E\x03\x02\x02\x02\u0390\u0391\x03\x02" +
		"\x02\x02\u0391\u0396\x03\x02\x02\x02\u0392\u0394\x07\xA2\x02\x02\u0393" +
		"\u0392\x03\x02\x02\x02\u0393\u0394\x03\x02\x02\x02\u0394\u0395\x03\x02" +
		"\x02\x02\u0395\u0397\x05\u0182\xC2\x02\u0396\u0393\x03\x02\x02\x02\u0396" +
		"\u0397\x03\x02\x02\x02\u0397\u04E2\x03\x02\x02\x02\u0398\u0399\x07\u010D" +
		"\x02\x02\u0399\u039A\x07\u0121\x02\x02\u039A\u039D\x07l\x02\x02\u039B" +
		"\u039C\t\x04\x02\x02\u039C\u039E\x05P)\x02\u039D\u039B\x03\x02\x02\x02" +
		"\u039D\u039E\x03\x02\x02\x02\u039E\u039F\x03\x02\x02\x02\u039F\u03A0\x07" +
		"\xA2\x02\x02\u03A0\u03A2\x05\u0182\xC2\x02\u03A1\u03A3\x05\"\x12\x02\u03A2" +
		"\u03A1\x03\x02\x02\x02\u03A2\u03A3\x03\x02\x02\x02\u03A3\u04E2\x03\x02" +
		"\x02\x02\u03A4\u03A5\x07\u010D\x02\x02\u03A5\u03A6\x07\u0125\x02\x02\u03A6" +
		"\u03AB\x05V,\x02\u03A7\u03A8\x07\x04\x02\x02\u03A8\u03A9\x05:\x1E\x02" +
		"\u03A9\u03AA\x07\x05\x02\x02\u03AA\u03AC\x03\x02\x02\x02\u03AB\u03A7\x03" +
		"\x02\x02\x02\u03AB\u03AC\x03\x02\x02\x02\u03AC\u04E2\x03\x02\x02\x02\u03AD" +
		"\u03AE\x07\u010D\x02\x02\u03AE\u03AF\x074\x02\x02\u03AF\u03B0\t\x04\x02" +
		"\x02\u03B0\u03B3\x05V,\x02\u03B1\u03B2\t\x04\x02\x02\u03B2\u03B4\x05P" +
		")\x02\u03B3\u03B1\x03\x02\x02\x02\u03B3\u03B4\x03\x02\x02\x02\u03B4\u04E2" +
		"\x03\x02\x02\x02\u03B5\u03B6\x07\u010D\x02\x02\u03B6\u03B9\x07\u014F\x02" +
		"\x02\u03B7\u03B8\t\x04\x02\x02\u03B8\u03BA\x05P)\x02\u03B9\u03B7\x03\x02" +
		"\x02\x02\u03B9\u03BA\x03\x02\x02\x02\u03BA\u03BF\x03\x02\x02\x02\u03BB" +
		"\u03BD\x07\xA2\x02\x02\u03BC\u03BB\x03\x02\x02\x02\u03BC\u03BD\x03\x02" +
		"\x02\x02\u03BD\u03BE\x03\x02\x02\x02\u03BE\u03C0\x05\u0182\xC2\x02\u03BF" +
		"\u03BC\x03\x02\x02\x02\u03BF\u03C0\x03\x02\x02\x02\u03C0\u04E2\x03\x02" +
		"\x02\x02\u03C1\u03C2\x07\u010D\x02\x02\u03C2\u03C3\x07\xD8\x02\x02\u03C3" +
		"\u03C5\x05V,\x02\u03C4\u03C6\x05\"\x12\x02\u03C5\u03C4\x03\x02\x02\x02" +
		"\u03C5\u03C6\x03\x02\x02\x02\u03C6\u04E2\x03\x02\x02\x02\u03C7\u03C9\x07" +
		"\u010D\x02\x02\u03C8\u03CA\x05\x94K\x02\u03C9\u03C8\x03\x02\x02\x02\u03C9" +
		"\u03CA\x03\x02\x02\x02\u03CA\u03CB\x03\x02\x02\x02\u03CB\u03CE\x07~\x02" +
		"\x02\u03CC\u03CD\t\x04\x02\x02\u03CD\u03CF\x05P)\x02\u03CE\u03CC\x03\x02" +
		"\x02\x02\u03CE\u03CF\x03\x02\x02\x02\u03CF\u03D7\x03\x02\x02\x02\u03D0" +
		"\u03D2\x07\xA2\x02\x02\u03D1\u03D0\x03\x02\x02\x02\u03D1\u03D2\x03\x02" +
		"\x02\x02\u03D2\u03D5\x03\x02\x02\x02\u03D3\u03D6\x05\xF6|\x02\u03D4\u03D6" +
		"\x05\u0182\xC2\x02\u03D5\u03D3\x03\x02\x02\x02\u03D5\u03D4\x03\x02\x02" +
		"\x02\u03D6\u03D8\x03\x02\x02\x02\u03D7\u03D1\x03\x02\x02\x02\u03D7\u03D8" +
		"\x03\x02\x02\x02\u03D8\u04E2\x03\x02\x02\x02\u03D9\u03DA\x07\u010D\x02" +
		"\x02\u03DA\u03DB\x07=\x02\x02\u03DB\u03DC\x07\u0121\x02\x02\u03DC\u03DF" +
		"\x05V,\x02\u03DD\u03DE\x07\x16\x02\x02\u03DE\u03E0\x07\u0106\x02\x02\u03DF" +
		"\u03DD\x03\x02\x02\x02\u03DF\u03E0\x03\x02\x02\x02\u03E0\u04E2\x03\x02" +
		"\x02\x02\u03E1\u03E2\x07\u010D\x02\x02\u03E2\u03E3\x07@\x02\x02\u03E3" +
		"\u04E2\x05&\x14\x02\u03E4\u03E5\x07\u010D\x02\x02\u03E5\u03EA\x07(\x02" +
		"\x02\u03E6\u03E8\x07\xA2\x02\x02\u03E7\u03E6\x03\x02\x02\x02\u03E7\u03E8" +
		"\x03\x02\x02\x02\u03E8\u03E9\x03\x02\x02\x02\u03E9\u03EB\x05\u0182\xC2" +
		"\x02\u03EA\u03E7\x03\x02\x02\x02\u03EA\u03EB\x03\x02\x02\x02\u03EB\u04E2" +
		"\x03\x02\x02\x02\u03EC\u03ED\t\x07\x02\x02\u03ED\u03EF\x07}\x02\x02\u03EE" +
		"\u03F0\x07l\x02\x02\u03EF\u03EE\x03\x02\x02\x02\u03EF\u03F0\x03\x02\x02" +
		"\x02\u03F0\u03F1\x03\x02\x02\x02\u03F1\u04E2\x05*\x16\x02\u03F2\u03F3" +
		"\t\x07\x02\x02\u03F3\u03F5\x07J\x02\x02\u03F4\u03F6\x07l\x02\x02\u03F5" +
		"\u03F4\x03\x02\x02\x02\u03F5\u03F6\x03\x02\x02\x02\u03F6\u03F7\x03\x02" +
		"\x02\x02\u03F7\u04E2\x05P)\x02\u03F8\u03FA\t\x07\x02\x02\u03F9\u03FB\x07" +
		"\u0121\x02\x02\u03FA\u03F9\x03\x02\x02\x02\u03FA\u03FB\x03\x02\x02\x02" +
		"\u03FB\u03FD\x03\x02\x02\x02\u03FC\u03FE\t\b\x02\x02\u03FD\u03FC\x03\x02" +
		"\x02\x02\u03FD\u03FE\x03\x02\x02\x02\u03FE\u03FF\x03\x02\x02\x02\u03FF" +
		"\u0401\x05V,\x02\u0400\u0402\x05\"\x12\x02\u0401\u0400\x03\x02\x02\x02" +
		"\u0401\u0402\x03\x02\x02\x02\u0402\u0404\x03\x02\x02\x02\u0403\u0405\x05" +
		",\x17\x02\u0404\u0403\x03\x02\x02\x02\u0404\u0405\x03";
	private static readonly _serializedATNSegment3: string =
		"\x02\x02\x02\u0405\u04E2\x03\x02\x02\x02\u0406\u0408\t\x07\x02\x02\u0407" +
		"\u0409\x07\xE5\x02\x02\u0408\u0407\x03\x02\x02\x02\u0408\u0409\x03\x02" +
		"\x02\x02\u0409\u040A\x03\x02\x02\x02\u040A\u04E2\x05\x1C\x0F\x02\u040B" +
		"\u040C\x075\x02\x02\u040C\u040D\x07\xC9\x02\x02\u040D\u040E\x05&\x14\x02" +
		"\u040E\u040F\x05P)\x02\u040F\u0410\x07\x99\x02\x02\u0410\u0411\x05\u0184" +
		"\xC3\x02\u0411\u04E2\x03\x02\x02\x02\u0412\u0413\x075\x02\x02\u0413\u0414" +
		"\x07\xC9\x02\x02\u0414\u0415\x07\u0121\x02\x02\u0415\u0416\x05V,\x02\u0416" +
		"\u0417\x07\x99\x02\x02\u0417\u0418\x05\u0184\xC3\x02\u0418\u04E2\x03\x02" +
		"\x02\x02\u0419\u041A\x07\xED\x02\x02\u041A\u041B\x07\u0121\x02\x02\u041B" +
		"\u04E2\x05V,\x02\u041C\u041D\x07\xED\x02\x02\u041D\u041E\x07}\x02\x02" +
		"\u041E\u04E2\x05\u016C\xB7\x02\u041F\u0427\x07\xED\x02\x02\u0420\u0428" +
		"\x05\u0182\xC2\x02\u0421\u0423\v\x02\x02\x02\u0422\u0421\x03\x02\x02\x02" +
		"\u0423\u0426\x03\x02\x02\x02\u0424\u0425\x03\x02\x02\x02\u0424\u0422\x03" +
		"\x02\x02\x02\u0425\u0428\x03\x02\x02\x02\u0426\u0424\x03\x02\x02\x02\u0427" +
		"\u0420\x03\x02\x02\x02\u0427\u0424\x03\x02\x02\x02\u0428\u04E2\x03\x02" +
		"\x02\x02\u0429\u042B\x07#\x02\x02\u042A\u042C\x07\x9F\x02\x02\u042B\u042A" +
		"\x03\x02\x02\x02\u042B\u042C\x03\x02\x02\x02\u042C\u042D\x03\x02\x02\x02" +
		"\u042D\u042E\x07\u0121\x02\x02\u042E\u0431\x05V,\x02\u042F\u0430\x07\xCC" +
		"\x02\x02\u0430\u0432\x056\x1C\x02\u0431\u042F\x03\x02\x02\x02\u0431\u0432" +
		"\x03\x02\x02\x02\u0432\u0437\x03\x02\x02\x02\u0433\u0435\x07\x16\x02\x02" +
		"\u0434\u0433\x03\x02\x02\x02\u0434\u0435\x03\x02\x02\x02\u0435\u0436\x03" +
		"\x02\x02\x02\u0436\u0438\x05\x1C\x0F\x02\u0437\u0434\x03\x02\x02\x02\u0437" +
		"\u0438\x03\x02\x02\x02\u0438\u04E2\x03\x02\x02\x02\u0439\u043A\x07\u013E" +
		"\x02\x02\u043A\u043C\x07\u0121\x02\x02\u043B\u043D\x05\xC0a\x02\u043C" +
		"\u043B\x03\x02\x02\x02\u043C\u043D\x03\x02\x02\x02\u043D\u043E\x03\x02" +
		"\x02\x02\u043E\u04E2\x05V,\x02\u043F\u0440\x07-\x02\x02\u0440\u04E2\x07" +
		"#\x02\x02\u0441\u0442\x07\xA7\x02\x02\u0442\u0444\x07H\x02\x02\u0443\u0445" +
		"\x07\xA8\x02\x02\u0444\u0443\x03\x02\x02\x02\u0444\u0445\x03\x02\x02\x02" +
		"\u0445\u0446\x03\x02\x02\x02\u0446\u0447\x07\x91\x02\x02\u0447\u0449\x05" +
		"\u0182\xC2\x02\u0448\u044A\x07\xD5\x02\x02\u0449\u0448\x03\x02\x02\x02" +
		"\u0449\u044A\x03\x02\x02\x02\u044A\u044B\x03\x02\x02\x02\u044B\u044C\x07" +
		"\x98\x02\x02\u044C\u044D\x07\u0121\x02\x02\u044D\u044F\x05V,\x02\u044E" +
		"\u0450\x05\"\x12\x02\u044F\u044E\x03\x02\x02\x02\u044F\u0450\x03\x02\x02" +
		"\x02\u0450\u04E2\x03\x02\x02\x02\u0451\u0452\x07\u0139\x02\x02\u0452\u0453" +
		"\x07\u0121\x02\x02\u0453\u0455\x05V,\x02\u0454\u0456\x05\"\x12\x02\u0455" +
		"\u0454\x03\x02\x02\x02\u0455\u0456\x03\x02\x02\x02\u0456\u04E2\x03\x02" +
		"\x02\x02\u0457\u0459\x07\xBA\x02\x02\u0458\u0457\x03\x02\x02\x02\u0458" +
		"\u0459\x03\x02\x02\x02\u0459\u045A\x03\x02\x02\x02\u045A\u045B\x07\xEF" +
		"\x02\x02\u045B\u045C\x07\u0121\x02\x02\u045C\u045F\x05V,\x02\u045D\u045E" +
		"\t\t\x02\x02\u045E\u0460\x07\xD8\x02\x02\u045F\u045D\x03\x02\x02\x02\u045F" +
		"\u0460\x03\x02\x02\x02\u0460\u04E2\x03\x02\x02\x02\u0461\u0462\t\n\x02" +
		"\x02\u0462\u0466\x05\u0176\xBC\x02\u0463\u0465\v\x02\x02\x02\u0464\u0463" +
		"\x03\x02\x02\x02\u0465\u0468\x03\x02\x02\x02\u0466\u0467\x03\x02\x02\x02" +
		"\u0466\u0464\x03\x02\x02\x02\u0467\u04E2\x03\x02\x02\x02\u0468\u0466\x03" +
		"\x02\x02\x02\u0469\u046A\x07\u0109\x02\x02\u046A\u046E\x07\xF9\x02\x02" +
		"\u046B\u046D\v\x02\x02\x02\u046C\u046B\x03\x02\x02\x02\u046D\u0470\x03" +
		"\x02\x02\x02\u046E\u046F\x03\x02\x02\x02\u046E\u046C\x03\x02\x02\x02\u046F" +
		"\u04E2\x03\x02\x02\x02\u0470\u046E\x03\x02\x02\x02\u0471\u0472\x07\u0109" +
		"\x02\x02\u0472\u0473\x07\u0129\x02\x02\u0473\u0474\x07\u015A\x02\x02\u0474" +
		"\u04E2\x05\u012A\x96\x02\u0475\u0476\x07\u0109\x02\x02\u0476\u0477\x07" +
		"\u0129\x02\x02\u0477\u0478\x07\u015A\x02\x02\u0478\u04E2\x05\b\x05\x02" +
		"\u0479\u047A\x07\u0109\x02\x02\u047A\u047B\x07\u0129\x02\x02\u047B\u047F" +
		"\x07\u015A\x02\x02\u047C\u047E\v\x02\x02\x02\u047D\u047C\x03\x02\x02\x02" +
		"\u047E\u0481\x03\x02\x02\x02\u047F\u0480\x03\x02\x02\x02\u047F\u047D\x03" +
		"\x02\x02\x02\u0480\u04E2\x03\x02\x02\x02\u0481\u047F\x03\x02\x02\x02\u0482" +
		"\u0483\x07\u0109\x02\x02\u0483\u0484\t\v\x02\x02\u0484\u04E2\x05\x86D" +
		"\x02\u0485\u0486\x07\u0109\x02\x02\u0486\u0487\t\v\x02\x02\u0487\u0488" +
		"\x07\x04\x02\x02\u0488\u0489\x05\xF4{\x02\u0489\u048A\x07\x05\x02\x02" +
		"\u048A\u048B\x07\u015B\x02\x02\u048B\u048C\x07\x04\x02\x02\u048C\u048D" +
		"\x05\x1C\x0F\x02\u048D\u048E\x07\x05\x02\x02\u048E\u04E2\x03\x02\x02\x02" +
		"\u048F\u0490\x07\u0109\x02\x02\u0490\u0491\x05\n\x06\x02\u0491\u0492\x07" +
		"\u015B\x02\x02\u0492\u0493\x05\f\x07\x02\u0493\u04E2\x03\x02\x02\x02\u0494" +
		"\u0495\x07\u0109\x02\x02\u0495\u049D\x05\n\x06\x02\u0496\u049A\x07\u015B" +
		"\x02\x02\u0497\u0499\v\x02\x02\x02\u0498\u0497\x03\x02\x02\x02\u0499\u049C" +
		"\x03\x02\x02\x02\u049A\u049B\x03\x02\x02\x02\u049A\u0498\x03\x02\x02\x02" +
		"\u049B\u049E\x03\x02\x02\x02\u049C\u049A\x03\x02\x02\x02\u049D\u0496\x03" +
		"\x02\x02\x02\u049D\u049E\x03\x02\x02\x02\u049E\u04E2\x03\x02\x02\x02\u049F" +
		"\u04A3\x07\u0109\x02\x02\u04A0\u04A2\v\x02\x02\x02\u04A1\u04A0\x03\x02" +
		"\x02\x02\u04A2\u04A5\x03\x02\x02\x02\u04A3\u04A4\x03\x02\x02\x02\u04A3" +
		"\u04A1\x03\x02\x02\x02\u04A4\u04A6\x03\x02\x02\x02\u04A5\u04A3\x03\x02" +
		"\x02\x02\u04A6\u04A7\x07\u015B\x02\x02\u04A7\u04E2\x05\f\x07\x02\u04A8" +
		"\u04AC\x07\u0109\x02\x02\u04A9\u04AB\v\x02\x02\x02\u04AA\u04A9\x03\x02" +
		"\x02\x02\u04AB\u04AE\x03\x02\x02\x02\u04AC\u04AD\x03\x02\x02\x02\u04AC" +
		"\u04AA\x03\x02\x02\x02\u04AD\u04E2\x03\x02\x02\x02\u04AE\u04AC\x03\x02" +
		"\x02\x02\u04AF\u04B0\x07\xF2\x02\x02\u04B0\u04E2\x05\n\x06\x02\u04B1\u04B5" +
		"\x07\xF2\x02\x02\u04B2\u04B4\v\x02\x02\x02\u04B3\u04B2\x03\x02\x02\x02" +
		"\u04B4\u04B7\x03\x02\x02\x02\u04B5\u04B6\x03\x02\x02\x02\u04B5\u04B3\x03" +
		"\x02\x02\x02\u04B6\u04E2\x03\x02\x02\x02\u04B7\u04B5\x03\x02\x02\x02\u04B8" +
		"\u04B9\x07=\x02\x02\u04B9\u04BB\x07\x8E\x02\x02\u04BA\u04BC\x05\xBE`\x02" +
		"\u04BB\u04BA\x03\x02\x02\x02\u04BB\u04BC\x03\x02\x02\x02\u04BC\u04BD\x03" +
		"\x02\x02\x02\u04BD\u04BE\x05\u0176\xBC\x02\u04BE\u04C0\x07\xC9\x02\x02" +
		"\u04BF\u04C1\x07\u0121\x02\x02\u04C0\u04BF\x03\x02\x02\x02\u04C0\u04C1" +
		"\x03\x02\x02\x02\u04C1\u04C2\x03\x02\x02\x02\u04C2\u04C5\x05V,\x02\u04C3" +
		"\u04C4\x07\u0148\x02\x02\u04C4\u04C6\x05\u0176\xBC\x02\u04C5\u04C3\x03" +
		"\x02\x02\x02\u04C5\u04C6\x03\x02\x02\x02\u04C6\u04C7\x03\x02\x02\x02\u04C7" +
		"\u04C8\x07\x04\x02\x02\u04C8\u04C9\x05\xF8}\x02\u04C9\u04CC\x07\x05\x02" +
		"\x02\u04CA\u04CB\x07\xCC\x02\x02\u04CB\u04CD\x056\x1C\x02\u04CC\u04CA" +
		"\x03\x02\x02\x02\u04CC\u04CD\x03\x02\x02\x02\u04CD\u04E2\x03\x02\x02\x02" +
		"\u04CE\u04CF\x07a\x02\x02\u04CF\u04D1\x07\x8E\x02\x02\u04D0\u04D2\x05" +
		"\xC0a\x02\u04D1\u04D0\x03\x02\x02\x02\u04D1\u04D2\x03\x02\x02\x02\u04D2" +
		"\u04D3\x03\x02\x02\x02\u04D3\u04D4\x05\u0176\xBC\x02\u04D4\u04D6\x07\xC9" +
		"\x02\x02\u04D5\u04D7\x07\u0121\x02\x02\u04D6\u04D5\x03\x02\x02\x02\u04D6" +
		"\u04D7\x03\x02\x02\x02\u04D7\u04D8\x03\x02\x02\x02\u04D8\u04D9\x05V,\x02" +
		"\u04D9\u04E2\x03\x02\x02\x02\u04DA\u04DE\x05\x0E\b\x02\u04DB\u04DD\v\x02" +
		"\x02\x02\u04DC\u04DB\x03\x02\x02\x02\u04DD\u04E0\x03\x02\x02\x02\u04DE" +
		"\u04DF\x03\x02\x02\x02\u04DE\u04DC\x03\x02\x02\x02\u04DF\u04E2\x03\x02" +
		"\x02\x02\u04E0\u04DE\x03\x02\x02\x02\u04E1\u019A\x03\x02\x02\x02\u04E1" +
		"\u019C\x03\x02\x02\x02\u04E1\u019F\x03\x02\x02\x02\u04E1\u01A1\x03\x02" +
		"\x02\x02\u04E1\u01A5\x03\x02\x02\x02\u04E1\u01AB\x03\x02\x02\x02\u04E1" +
		"\u01BB\x03\x02\x02\x02\u04E1\u01C2\x03\x02\x02\x02\u04E1\u01C8\x03\x02" +
		"\x02\x02\u04E1\u01D1\x03\x02\x02\x02\u04E1\u01DD\x03\x02\x02\x02\u04E1" +
		"\u01EE\x03\x02\x02\x02\u04E1\u0201\x03\x02\x02\x02\u04E1\u0212\x03\x02" +
		"\x02\x02\u04E1\u0223\x03\x02\x02\x02\u04E1\u022E\x03\x02\x02\x02\u04E1" +
		"\u0235\x03\x02\x02\x02\u04E1\u023E\x03\x02\x02\x02\u04E1\u0247\x03\x02" +
		"\x02\x02\u04E1\u0251\x03\x02\x02\x02\u04E1\u025D\x03\x02\x02\x02\u04E1" +
		"\u0268\x03\x02\x02\x02\u04E1\u0273\x03\x02\x02\x02\u04E1\u0281\x03\x02" +
		"\x02\x02\u04E1\u028C\x03\x02\x02\x02\u04E1\u029B\x03\x02\x02\x02\u04E1" +
		"\u02A7\x03\x02\x02\x02\u04E1\u02B5\x03\x02\x02\x02\u04E1\u02BF\x03\x02" +
		"\x02\x02\u04E1\u02CF\x03\x02\x02\x02\u04E1\u02D7\x03\x02\x02\x02\u04E1" +
		"\u02ED\x03\x02\x02\x02\u04E1\u02F6\x03\x02\x02\x02\u04E1\u02FC\x03\x02" +
		"\x02\x02\u04E1\u0305\x03\x02\x02\x02\u04E1\u030B\x03\x02\x02\x02\u04E1" +
		"\u032C\x03\x02\x02\x02\u04E1\u0342\x03\x02\x02\x02\u04E1\u034A\x03\x02" +
		"\x02\x02\u04E1\u0364\x03\x02\x02\x02\u04E1\u036D\x03\x02\x02\x02\u04E1" +
		"\u037C\x03\x02\x02\x02\u04E1\u0387\x03\x02\x02\x02\u04E1\u038C\x03\x02" +
		"\x02\x02\u04E1\u0398\x03\x02\x02\x02\u04E1\u03A4\x03\x02\x02\x02\u04E1" +
		"\u03AD\x03\x02\x02\x02\u04E1\u03B5\x03\x02\x02\x02\u04E1\u03C1\x03\x02" +
		"\x02\x02\u04E1\u03C7\x03\x02\x02\x02\u04E1\u03D9\x03\x02\x02\x02\u04E1" +
		"\u03E1\x03\x02\x02\x02\u04E1\u03E4\x03\x02\x02\x02\u04E1\u03EC\x03\x02" +
		"\x02\x02\u04E1\u03F2\x03\x02\x02\x02\u04E1\u03F8\x03\x02\x02\x02\u04E1" +
		"\u0406\x03\x02\x02\x02\u04E1\u040B\x03\x02\x02\x02\u04E1\u0412\x03\x02" +
		"\x02\x02\u04E1\u0419\x03\x02\x02\x02\u04E1\u041C\x03\x02\x02\x02\u04E1" +
		"\u041F\x03\x02\x02\x02\u04E1\u0429\x03\x02\x02\x02\u04E1\u0439\x03\x02" +
		"\x02\x02\u04E1\u043F\x03\x02\x02\x02\u04E1\u0441\x03\x02\x02\x02\u04E1" +
		"\u0451\x03\x02\x02\x02\u04E1\u0458\x03\x02\x02\x02\u04E1\u0461\x03\x02" +
		"\x02\x02\u04E1\u0469\x03\x02\x02\x02\u04E1\u0471\x03\x02\x02\x02\u04E1" +
		"\u0475\x03\x02\x02\x02\u04E1\u0479\x03\x02\x02\x02\u04E1\u0482\x03\x02" +
		"\x02\x02\u04E1\u0485\x03\x02\x02\x02\u04E1\u048F\x03\x02\x02\x02\u04E1" +
		"\u0494\x03\x02\x02\x02\u04E1\u049F\x03\x02\x02\x02\u04E1\u04A8\x03\x02" +
		"\x02\x02\u04E1\u04AF\x03\x02\x02\x02\u04E1\u04B1\x03\x02\x02\x02\u04E1" +
		"\u04B8\x03\x02\x02\x02\u04E1\u04CE\x03\x02\x02\x02\u04E1\u04DA\x03\x02" +
		"\x02\x02\u04E2\x07\x03\x02\x02\x02\u04E3\u04E6\x05\u0182\xC2\x02\u04E4" +
		"\u04E6\x07\xA8\x02\x02\u04E5\u04E3\x03\x02\x02\x02\u04E5\u04E4\x03\x02" +
		"\x02\x02\u04E6\t\x03\x02\x02\x02\u04E7\u04E8\x05\u017A\xBE\x02\u04E8\v" +
		"\x03\x02\x02\x02\u04E9\u04EA\x05\u017C\xBF\x02\u04EA\r\x03\x02\x02\x02" +
		"\u04EB\u04EC\x07=\x02\x02\u04EC\u0594\x07\xF9\x02\x02\u04ED\u04EE\x07" +
		"a\x02\x02\u04EE\u0594\x07\xF9\x02\x02\u04EF\u04F1\x07\x81\x02\x02\u04F0" +
		"\u04F2\x07\xF9\x02\x02\u04F1\u04F0\x03\x02\x02\x02\u04F1\u04F2\x03\x02" +
		"\x02\x02\u04F2\u0594\x03\x02\x02\x02\u04F3\u04F5\x07\xF5\x02\x02\u04F4" +
		"\u04F6\x07\xF9\x02\x02\u04F5\u04F4\x03\x02\x02\x02\u04F5\u04F6\x03\x02" +
		"\x02\x02\u04F6\u0594\x03\x02\x02\x02\u04F7\u04F8\x07\u010D\x02\x02\u04F8" +
		"\u0594\x07\x81\x02\x02\u04F9\u04FA\x07\u010D\x02\x02\u04FA\u04FC\x07\xF9" +
		"\x02\x02\u04FB\u04FD\x07\x81\x02\x02\u04FC\u04FB\x03\x02\x02\x02\u04FC" +
		"\u04FD\x03\x02\x02\x02\u04FD\u0594\x03\x02\x02\x02\u04FE\u04FF\x07\u010D" +
		"\x02\x02\u04FF\u0594\x07\xE1\x02\x02\u0500\u0501\x07\u010D\x02\x02\u0501" +
		"\u0594\x07\xFA\x02\x02\u0502\u0503\x07\u010D\x02\x02\u0503\u0504\x07@" +
		"\x02\x02\u0504\u0594\x07\xFA\x02\x02\u0505\u0506\x07k\x02\x02\u0506\u0594" +
		"\x07\u0121\x02\x02\u0507\u0508\x07\x8B\x02\x02\u0508\u0594\x07\u0121\x02" +
		"\x02\u0509\u050A\x07\u010D\x02\x02\u050A\u0594\x078\x02\x02\u050B\u050C" +
		"\x07\u010D\x02\x02\u050C\u050D\x07=\x02\x02\u050D\u0594\x07\u0121\x02" +
		"\x02\u050E\u050F\x07\u010D\x02\x02\u050F\u0594\x07\u0135\x02\x02\u0510" +
		"\u0511\x07\u010D\x02\x02\u0511\u0594\x07\x8F\x02\x02\u0512\u0513\x07\u010D" +
		"\x02\x02\u0513\u0594\x07\xAB\x02\x02\u0514\u0515\x07=\x02\x02\u0515\u0594" +
		"\x07\x8E\x02\x02\u0516\u0517\x07a\x02\x02\u0517\u0594\x07\x8E\x02\x02" +
		"\u0518\u0519\x07\r\x02\x02\u0519\u0594\x07\x8E\x02\x02\u051A\u051B\x07" +
		"\xAA\x02\x02\u051B\u0594\x07\u0121\x02\x02\u051C\u051D\x07\xAA\x02\x02" +
		"\u051D\u0594\x07J\x02\x02\u051E\u051F\x07\u0142\x02\x02\u051F\u0594\x07" +
		"\u0121\x02\x02\u0520\u0521\x07\u0142\x02\x02\u0521\u0594\x07J\x02\x02" +
		"\u0522\u0523\x07=\x02\x02\u0523\u0524\x07\u0126\x02\x02\u0524\u0594\x07" +
		"\xAE\x02\x02\u0525\u0526\x07a\x02\x02\u0526\u0527\x07\u0126\x02\x02\u0527" +
		"\u0594\x07\xAE\x02\x02\u0528\u0529\x07\r\x02\x02\u0529\u052A\x07\u0121" +
		"\x02\x02\u052A\u052B\x05V,\x02\u052B\u052C\x07\xC3\x02\x02\u052C\u052D" +
		"\x07/\x02\x02\u052D\u0594\x03\x02\x02\x02\u052E\u052F\x07\r\x02\x02\u052F" +
		"\u0530\x07\u0121\x02\x02\u0530\u0531\x05V,\x02\u0531\u0532\x07/\x02\x02" +
		"\u0532\u0533\x07!\x02\x02\u0533\u0594\x03\x02\x02\x02\u0534\u0535\x07" +
		"\r\x02\x02\u0535\u0536\x07\u0121\x02\x02\u0536\u0537\x05V,\x02\u0537\u0538" +
		"\x07\xC3\x02\x02\u0538\u0539\x07\u0113\x02\x02\u0539\u0594\x03\x02\x02" +
		"\x02\u053A\u053B\x07\r\x02\x02\u053B\u053C\x07\u0121\x02\x02\u053C\u053D" +
		"\x05V,\x02\u053D\u053E\x07\u010F\x02\x02\u053E\u053F\x07!\x02\x02\u053F" +
		"\u0594\x03\x02\x02\x02\u0540\u0541\x07\r\x02\x02\u0541\u0542\x07\u0121" +
		"\x02\x02\u0542\u0543\x05V,\x02\u0543\u0544\x07\xC3\x02\x02\u0544\u0545" +
		"\x07\u010F\x02\x02\u0545\u0594\x03\x02\x02\x02\u0546\u0547\x07\r\x02\x02" +
		"\u0547\u0548\x07\u0121\x02\x02\u0548\u0549\x05V,\x02\u0549\u054A\x07\xC3" +
		"\x02\x02\u054A\u054B\x07\u0117\x02\x02\u054B\u054C\x07\x16\x02\x02\u054C" +
		"\u054D\x07[\x02\x02\u054D\u0594\x03\x02\x02\x02\u054E\u054F\x07\r\x02" +
		"\x02\u054F\u0550\x07\u0121\x02\x02\u0550\u0551\x05V,\x02\u0551\u0552\x07" +
		"\u0109\x02\x02\u0552\u0553\x07\u010F\x02\x02\u0553\u0554\x07\xA9\x02\x02" +
		"\u0554\u0594\x03\x02\x02\x02\u0555\u0556\x07\r\x02\x02\u0556\u0557\x07" +
		"\u0121\x02\x02\u0557\u0558\x05V,\x02\u0558\u0559\x07g\x02\x02\u0559\u055A" +
		"\x07\xD6\x02\x02\u055A\u0594\x03\x02\x02\x02\u055B\u055C\x07\r\x02\x02" +
		"\u055C\u055D\x07\u0121\x02\x02\u055D\u055E\x05V,\x02\u055E\u055F\x07\x14" +
		"\x02\x02\u055F\u0560\x07\xD6\x02\x02\u0560\u0594\x03\x02\x02\x02\u0561" +
		"\u0562\x07\r\x02\x02\u0562\u0563\x07\u0121\x02\x02\u0563\u0564\x05V,\x02" +
		"\u0564\u0565\x07\u013C\x02\x02\u0565\u0566\x07\xD6\x02\x02\u0566\u0594" +
		"\x03\x02\x02\x02\u0567\u0568\x07\r\x02\x02\u0568\u0569\x07\u0121\x02\x02" +
		"\u0569\u056A\x05V,\x02\u056A\u056B\x07\u0132\x02\x02\u056B\u0594\x03\x02" +
		"\x02\x02\u056C\u056D\x07\r\x02\x02\u056D\u056E\x07\u0121\x02\x02\u056E" +
		"\u0570\x05V,\x02\u056F\u0571\x05\"\x12\x02\u0570\u056F\x03\x02\x02\x02" +
		"\u0570\u0571\x03\x02\x02\x02\u0571\u0572\x03\x02\x02\x02\u0572\u0573\x07" +
		"7\x02\x02\u0573\u0594\x03\x02\x02\x02\u0574\u0575\x07\r\x02\x02\u0575" +
		"\u0576\x07\u0121\x02\x02\u0576\u0578\x05V,\x02\u0577\u0579\x05\"\x12\x02" +
		"\u0578\u0577\x03\x02\x02\x02\u0578\u0579\x03\x02\x02\x02\u0579\u057A\x03" +
		"\x02\x02\x02\u057A\u057B\x07:\x02\x02\u057B\u0594\x03\x02\x02\x02\u057C" +
		"\u057D\x07\r\x02\x02\u057D\u057E\x07\u0121\x02\x02\u057E\u0580\x05V,\x02" +
		"\u057F\u0581\x05\"\x12\x02\u0580\u057F\x03\x02\x02\x02\u0580\u0581\x03" +
		"\x02\x02\x02\u0581\u0582\x03\x02\x02\x02\u0582\u0583\x07\u0109\x02\x02" +
		"\u0583\u0584\x07s\x02\x02\u0584\u0594\x03\x02\x02\x02\u0585\u0586\x07" +
		"\r\x02\x02\u0586\u0587\x07\u0121\x02\x02\u0587\u0589\x05V,\x02\u0588\u058A" +
		"\x05\"\x12\x02\u0589\u0588\x03\x02\x02\x02\u0589\u058A\x03\x02\x02\x02" +
		"\u058A\u058B\x03\x02\x02\x02\u058B\u058C\x07\xF1\x02\x02\u058C\u058D\x07" +
		"4\x02\x02\u058D\u0594\x03\x02\x02\x02\u058E\u058F\x07\u0115\x02\x02\u058F" +
		"\u0594\x07\u0134\x02\x02\u0590\u0594\x076\x02\x02\u0591\u0594\x07\xFB" +
		"\x02\x02\u0592\u0594\x07Z\x02\x02\u0593\u04EB\x03\x02\x02\x02\u0593\u04ED" +
		"\x03\x02\x02\x02\u0593\u04EF\x03\x02\x02\x02\u0593\u04F3\x03\x02\x02\x02" +
		"\u0593\u04F7\x03\x02\x02\x02\u0593\u04F9\x03\x02\x02\x02\u0593\u04FE\x03" +
		"\x02\x02\x02\u0593\u0500\x03\x02\x02\x02\u0593\u0502\x03\x02\x02\x02\u0593" +
		"\u0505\x03\x02\x02\x02\u0593\u0507\x03\x02\x02\x02\u0593\u0509\x03\x02" +
		"\x02\x02\u0593\u050B\x03\x02\x02\x02\u0593\u050E\x03\x02\x02\x02\u0593" +
		"\u0510\x03\x02\x02\x02\u0593\u0512\x03\x02\x02\x02\u0593\u0514\x03\x02" +
		"\x02\x02\u0593\u0516\x03\x02\x02\x02\u0593\u0518\x03\x02\x02\x02\u0593" +
		"\u051A\x03\x02\x02\x02\u0593\u051C\x03\x02\x02\x02\u0593\u051E\x03\x02" +
		"\x02\x02\u0593\u0520\x03\x02\x02\x02\u0593\u0522\x03\x02\x02\x02\u0593" +
		"\u0525\x03\x02\x02\x02\u0593\u0528\x03\x02\x02\x02\u0593\u052E\x03\x02" +
		"\x02\x02\u0593\u0534\x03\x02\x02\x02\u0593\u053A\x03\x02\x02\x02\u0593" +
		"\u0540\x03\x02\x02\x02\u0593\u0546\x03\x02\x02\x02\u0593\u054E\x03\x02" +
		"\x02\x02\u0593\u0555\x03\x02\x02\x02\u0593\u055B\x03\x02\x02\x02\u0593" +
		"\u0561\x03\x02\x02\x02\u0593\u0567\x03\x02\x02\x02\u0593\u056C\x03\x02" +
		"\x02\x02\u0593\u0574\x03\x02\x02\x02\u0593\u057C\x03\x02\x02\x02\u0593" +
		"\u0585\x03\x02\x02\x02\u0593\u058E\x03\x02\x02\x02\u0593\u0590\x03\x02" +
		"\x02\x02\u0593\u0591\x03\x02\x02\x02\u0593\u0592\x03\x02\x02\x02\u0594" +
		"\x0F\x03\x02\x02\x02\u0595\u0597\x07=\x02\x02\u0596\u0598\x07\u0126\x02" +
		"\x02\u0597\u0596\x03\x02\x02\x02\u0597\u0598\x03\x02\x02\x02\u0598\u059A" +
		"\x03\x02\x02\x02\u0599\u059B\x07m\x02\x02\u059A\u0599\x03\x02\x02\x02" +
		"\u059A\u059B\x03\x02\x02\x02\u059B\u059C\x03\x02\x02\x02\u059C\u059E\x07" +
		"\u0121\x02\x02\u059D\u059F\x05\xBE`\x02\u059E\u059D\x03\x02\x02\x02\u059E" +
		"\u059F\x03\x02\x02\x02\u059F\u05A0\x03\x02\x02\x02\u05A0\u05A1\x05T+\x02" +
		"\u05A1\x11\x03\x02\x02\x02\u05A2\u05A3\x07=\x02\x02\u05A3\u05A5\x07\xCD" +
		"\x02\x02\u05A4\u05A2\x03\x02\x02\x02\u05A4\u05A5\x03\x02\x02\x02\u05A5" +
		"\u05A6\x03\x02\x02\x02\u05A6\u05A7\x07\xF1\x02\x02\u05A7\u05A8\x07\u0121" +
		"\x02\x02\u05A8\u05A9\x05T+\x02\u05A9\x13\x03\x02\x02\x02\u05AA\u05AB\x07" +
		"/\x02\x02\u05AB\u05AC\x07!\x02\x02\u05AC\u05B0\x05\xD4k\x02\u05AD\u05AE" +
		"\x07\u0113\x02\x02\u05AE\u05AF\x07!\x02\x02\u05AF\u05B1\x05\xD8m\x02\u05B0" +
		"\u05AD\x03\x02\x02\x02\u05B0\u05B1\x03\x02\x02\x02\u05B1\u05B2\x03\x02" +
		"\x02\x02\u05B2\u05B3\x07\x98\x02\x02\u05B3\u05B4\x07\u0179\x02\x02\u05B4" +
		"\u05B5\x07 \x02\x02\u05B5\x15\x03\x02\x02\x02\u05B6\u05B7\x07\u010F\x02" +
		"\x02\u05B7\u05B8\x07!\x02\x02\u05B8\u05B9\x05\xD4k\x02\u05B9\u05BC\x07" +
		"\xC9\x02\x02\u05BA\u05BD\x05B\"\x02\u05BB\u05BD\x05D#\x02\u05BC\u05BA" +
		"\x03\x02\x02\x02\u05BC\u05BB\x03\x02\x02\x02\u05BD\u05C1\x03\x02\x02\x02" +
		"\u05BE\u05BF\x07\u0117\x02\x02\u05BF\u05C0\x07\x16\x02\x02\u05C0\u05C2" +
		"\x07[\x02\x02\u05C1\u05BE\x03\x02\x02\x02\u05C1\u05C2\x03\x02\x02\x02" +
		"\u05C2\x17\x03\x02\x02\x02\u05C3\u05C4\x07\xA9\x02\x02\u05C4\u05C5\x05" +
		"\u0182\xC2\x02\u05C5\x19\x03\x02\x02\x02\u05C6\u05C7\x075\x02\x02\u05C7" +
		"\u05C8\x05\u0182\xC2\x02\u05C8\x1B\x03\x02\x02\x02\u05C9\u05CB\x05.\x18" +
		"\x02\u05CA\u05C9\x03\x02\x02\x02\u05CA\u05CB\x03\x02\x02\x02\u05CB\u05CC" +
		"\x03\x02\x02\x02\u05CC\u05CD\x05h5\x02\u05CD\u05CE\x05d3\x02\u05CE\x1D" +
		"\x03\x02\x02\x02\u05CF\u05D0\x07\x93\x02\x02\u05D0\u05D2\x07\xD5\x02\x02" +
		"\u05D1\u05D3\x07\u0121\x02\x02\u05D2\u05D1\x03\x02\x02\x02\u05D2\u05D3" +
		"\x03\x02\x02\x02\u05D3\u05D4\x03\x02\x02\x02\u05D4\u05D9\x05V,\x02\u05D5" +
		"\u05D7\x05\"\x12\x02\u05D6\u05D8\x05\xBE`\x02\u05D7\u05D6\x03\x02\x02" +
		"\x02\u05D7\u05D8\x03\x02\x02\x02\u05D8\u05DA\x03\x02\x02\x02\u05D9\u05D5" +
		"\x03\x02\x02\x02\u05D9\u05DA\x03\x02\x02\x02\u05DA\u05E1\x03\x02\x02\x02" +
		"\u05DB\u05DC\x07!\x02\x02\u05DC\u05E2\x07\xBB\x02\x02\u05DD\u05DE\x07" +
		"\x04\x02\x02\u05DE\u05DF\x05^0\x02\u05DF\u05E0\x07\x05\x02\x02\u05E0\u05E2" +
		"\x03\x02\x02\x02\u05E1\u05DB\x03\x02\x02\x02\u05E1\u05DD\x03\x02\x02\x02" +
		"\u05E1\u05E2\x03\x02\x02\x02\u05E2\u061C\x03\x02\x02\x02\u05E3\u05E4\x07" +
		"\x93\x02\x02\u05E4\u05E6\x07\x98\x02\x02\u05E5\u05E7\x07\u0121\x02\x02" +
		"\u05E6\u05E5\x03\x02\x02\x02\u05E6\u05E7\x03\x02\x02\x02\u05E7\u05E8\x03" +
		"\x02\x02\x02\u05E8\u05EA\x05V,\x02\u05E9\u05EB\x05\"\x12\x02\u05EA\u05E9" +
		"\x03\x02\x02\x02\u05EA\u05EB\x03\x02\x02\x02\u05EB\u05ED\x03\x02\x02\x02" +
		"\u05EC\u05EE\x05\xBE`\x02\u05ED\u05EC\x03\x02\x02\x02\u05ED\u05EE\x03" +
		"\x02\x02\x02\u05EE\u05F5\x03\x02\x02\x02\u05EF\u05F0\x07!\x02\x02\u05F0" +
		"\u05F6\x07\xBB\x02\x02\u05F1\u05F2\x07\x04\x02\x02\u05F2\u05F3\x05^0\x02" +
		"\u05F3\u05F4\x07\x05\x02\x02\u05F4\u05F6\x03\x02\x02\x02\u05F5\u05EF\x03" +
		"\x02\x02\x02\u05F5\u05F1\x03\x02\x02\x02\u05F5\u05F6\x03\x02\x02\x02\u05F6" +
		"\u061C\x03\x02\x02\x02\u05F7\u05F8\x07\x93\x02\x02\u05F8\u05FA\x07\x98" +
		"\x02\x02\u05F9\u05FB\x07\u0121\x02\x02\u05FA\u05F9\x03\x02\x02\x02\u05FA" +
		"\u05FB\x03\x02\x02\x02\u05FB\u05FC\x03\x02\x02\x02\u05FC\u05FD\x05V,\x02" +
		"\u05FD\u05FE\x07\xF1\x02\x02\u05FE\u05FF\x05\x8AF\x02\u05FF\u061C\x03" +
		"\x02\x02\x02\u0600\u0601\x07\x93\x02\x02\u0601\u0603\x07\xD5\x02\x02\u0602" +
		"\u0604\x07\xA8\x02\x02\u0603\u0602\x03\x02\x02\x02\u0603\u0604\x03\x02" +
		"\x02\x02\u0604\u0605\x03\x02\x02\x02\u0605\u0606\x07\\\x02\x02\u0606\u0608" +
		"\x05\u0182\xC2\x02\u0607\u0609\x05\xF2z\x02\u0608\u0607\x03\x02\x02\x02" +
		"\u0608\u0609\x03\x02\x02\x02\u0609\u060B\x03\x02\x02\x02\u060A\u060C\x05" +
		"F$\x02\u060B\u060A\x03\x02\x02\x02\u060B\u060C\x03\x02\x02\x02\u060C\u061C" +
		"\x03\x02\x02\x02\u060D\u060E\x07\x93\x02\x02\u060E\u0610\x07\xD5\x02\x02" +
		"\u060F\u0611\x07\xA8\x02\x02\u0610\u060F\x03\x02\x02\x02\u0610\u0611\x03" +
		"\x02\x02\x02\u0611\u0612\x03\x02\x02\x02\u0612\u0614\x07\\\x02\x02\u0613" +
		"\u0615\x05\u0182\xC2\x02\u0614\u0613\x03\x02\x02\x02\u0614\u0615\x03\x02" +
		"\x02\x02\u0615\u0616\x03\x02\x02\x02\u0616\u0619\x052\x1A\x02\u0617\u0618" +
		"\x07\xCC\x02\x02\u0618\u061A\x056\x1C\x02\u0619\u0617\x03\x02\x02\x02" +
		"\u0619\u061A\x03\x02\x02\x02\u061A\u061C\x03\x02\x02\x02\u061B\u05CF\x03" +
		"\x02\x02\x02\u061B\u05E3\x03\x02\x02\x02\u061B\u05F7\x03\x02\x02\x02\u061B" +
		"\u0600\x03\x02\x02\x02\u061B\u060D\x03\x02\x02\x02\u061C\x1F\x03\x02\x02" +
		"\x02\u061D\u061F\x05\"\x12\x02\u061E\u0620\x05\x18\r\x02\u061F\u061E\x03" +
		"\x02\x02\x02\u061F\u0620\x03\x02\x02\x02\u0620!\x03\x02\x02\x02\u0621" +
		"\u0622\x07\xD6\x02\x02\u0622\u0623\x07\x04\x02\x02\u0623\u0628\x05$\x13" +
		"\x02\u0624\u0625\x07\x06\x02\x02\u0625\u0627\x05$\x13\x02\u0626\u0624" +
		"\x03\x02\x02\x02\u0627\u062A\x03\x02\x02\x02\u0628\u0626\x03\x02\x02\x02" +
		"\u0628\u0629\x03\x02\x02\x02\u0629\u062B\x03\x02\x02\x02\u062A\u0628\x03" +
		"\x02\x02\x02\u062B\u062C\x07\x05\x02\x02\u062C#\x03\x02\x02\x02\u062D" +
		"\u0630\x05\u0176\xBC\x02\u062E\u062F\x07\u015B\x02\x02\u062F\u0631\x05" +
		"\u0120\x91\x02\u0630\u062E\x03\x02\x02\x02\u0630\u0631\x03\x02\x02\x02" +
		"\u0631\u0637\x03\x02\x02\x02\u0632\u0633\x05\u0176\xBC\x02\u0633\u0634" +
		"\x07\u015B\x02\x02\u0634\u0635\x07T\x02\x02\u0635\u0637\x03\x02\x02\x02" +
		"\u0636\u062D\x03\x02\x02\x02\u0636\u0632\x03\x02\x02\x02\u0637%\x03\x02" +
		"\x02\x02\u0638\u0639\t\f\x02\x02\u0639\'\x03\x02\x02\x02\u063A\u063B\t" +
		"\r\x02\x02\u063B)\x03\x02\x02\x02\u063C\u0642\x05b2\x02\u063D\u0642\x05" +
		"\u0182\xC2\x02\u063E\u0642\x05\u0122\x92\x02\u063F\u0642\x05\u0124\x93" +
		"\x02\u0640\u0642\x05\u0126\x94\x02\u0641\u063C\x03\x02\x02\x02\u0641\u063D" +
		"\x03\x02\x02\x02\u0641\u063E\x03\x02\x02\x02\u0641\u063F\x03\x02\x02\x02" +
		"\u0641\u0640\x03\x02\x02\x02\u0642+\x03\x02\x02\x02\u0643\u0648\x05\u0176" +
		"\xBC\x02\u0644\u0645\x07\x07\x02\x02\u0645\u0647\x05\u0176\xBC\x02\u0646" +
		"\u0644\x03\x02\x02\x02\u0647\u064A\x03\x02\x02\x02\u0648\u0646\x03\x02" +
		"\x02\x02\u0648\u0649\x03\x02\x02\x02\u0649-\x03\x02\x02\x02\u064A\u0648" +
		"\x03\x02\x02\x02\u064B\u064C\x07\u0156\x02\x02\u064C\u0651\x050\x19\x02" +
		"\u064D\u064E\x07\x06\x02\x02\u064E\u0650\x050\x19\x02\u064F\u064D\x03" +
		"\x02\x02\x02\u0650\u0653\x03\x02\x02\x02\u0651\u064F\x03\x02\x02\x02\u0651" +
		"\u0652\x03\x02\x02\x02\u0652/\x03\x02\x02\x02\u0653\u0651\x03\x02\x02" +
		"\x02\u0654\u0656\x05\u0172\xBA\x02\u0655\u0657\x05\xD4k\x02\u0656\u0655" +
		"\x03\x02\x02\x02\u0656\u0657\x03\x02\x02\x02\u0657\u0659\x03\x02\x02\x02" +
		"\u0658\u065A\x07\x16\x02\x02\u0659\u0658\x03\x02\x02\x02\u0659\u065A\x03" +
		"\x02\x02\x02\u065A\u065B\x03\x02\x02\x02\u065B\u065C\x07\x04\x02\x02\u065C" +
		"\u065D\x05\x1C\x0F\x02\u065D\u065E\x07\x05\x02\x02\u065E1\x03\x02\x02" +
		"\x02\u065F\u0660\x07\u0148\x02\x02\u0660\u0661\x05\xF6|\x02\u06613\x03" +
		"\x02\x02\x02\u0662\u0663\x07\xCC\x02\x02\u0663\u0670\x05> \x02\u0664\u0665" +
		"\x07\xD7\x02\x02\u0665\u0666\x07!\x02\x02\u0666\u0670\x05\u0104\x83\x02" +
		"\u0667\u0670\x05\x16\f\x02\u0668\u0670\x05\x14\v\x02\u0669\u0670\x05\xF2" +
		"z\x02\u066A\u0670\x05F$\x02\u066B\u0670\x05\x18\r\x02\u066C\u0670\x05" +
		"\x1A\x0E\x02\u066D\u066E\x07\u0125\x02\x02\u066E\u0670\x056\x1C\x02\u066F" +
		"\u0662\x03\x02\x02\x02\u066F\u0664\x03\x02\x02\x02\u066F\u0667\x03\x02" +
		"\x02\x02\u066F\u0668\x03\x02\x02\x02\u066F\u0669\x03\x02\x02\x02\u066F" +
		"\u066A\x03\x02\x02\x02\u066F\u066B\x03\x02\x02\x02\u066F\u066C\x03\x02" +
		"\x02\x02\u066F\u066D\x03\x02\x02\x02\u0670\u0673\x03\x02\x02\x02\u0671" +
		"\u066F\x03\x02\x02";
	private static readonly _serializedATNSegment4: string =
		"\x02\u0671\u0672\x03\x02\x02\x02\u06725\x03\x02\x02\x02\u0673\u0671\x03" +
		"\x02\x02\x02\u0674\u0675\x07\x04\x02\x02\u0675\u067A\x058\x1D\x02\u0676" +
		"\u0677\x07\x06\x02\x02\u0677\u0679\x058\x1D\x02\u0678\u0676\x03\x02\x02" +
		"\x02\u0679\u067C\x03\x02\x02\x02\u067A\u0678\x03\x02\x02\x02\u067A\u067B" +
		"\x03\x02\x02\x02\u067B\u067D\x03\x02\x02\x02\u067C\u067A\x03\x02\x02\x02" +
		"\u067D\u067E\x07\x05\x02\x02\u067E7\x03\x02\x02\x02\u067F\u0684\x05:\x1E" +
		"\x02\u0680\u0682\x07\u015B\x02\x02\u0681\u0680\x03\x02\x02\x02\u0681\u0682" +
		"\x03\x02\x02\x02\u0682\u0683\x03\x02\x02\x02\u0683\u0685\x05<\x1F\x02" +
		"\u0684\u0681\x03\x02\x02\x02\u0684\u0685\x03\x02\x02\x02\u06859\x03\x02" +
		"\x02\x02\u0686\u068B\x05\u0176\xBC\x02\u0687\u0688\x07\x07\x02\x02\u0688" +
		"\u068A\x05\u0176\xBC\x02\u0689\u0687\x03\x02\x02\x02\u068A\u068D\x03\x02" +
		"\x02\x02\u068B\u0689\x03\x02\x02\x02\u068B\u068C\x03\x02\x02\x02\u068C" +
		"\u0690\x03\x02\x02\x02\u068D\u068B\x03\x02\x02\x02\u068E\u0690\x05\u0182" +
		"\xC2\x02\u068F\u0686\x03\x02\x02\x02\u068F\u068E\x03\x02\x02\x02\u0690" +
		";\x03\x02\x02\x02\u0691\u0696\x07\u0179\x02\x02\u0692\u0696\x07\u017B" +
		"\x02\x02\u0693\u0696\x05\u0128\x95\x02\u0694\u0696\x05\u0182\xC2\x02\u0695" +
		"\u0691\x03\x02\x02\x02\u0695\u0692\x03\x02\x02\x02\u0695\u0693\x03\x02" +
		"\x02\x02\u0695\u0694\x03\x02\x02\x02\u0696=\x03\x02\x02\x02\u0697\u0698" +
		"\x07\x04\x02\x02\u0698\u069D\x05@!\x02\u0699\u069A\x07\x06\x02\x02\u069A" +
		"\u069C\x05@!\x02\u069B\u0699\x03\x02\x02\x02\u069C\u069F\x03\x02\x02\x02" +
		"\u069D\u069B\x03\x02\x02\x02\u069D\u069E\x03\x02\x02\x02\u069E\u06A0\x03" +
		"\x02\x02\x02\u069F\u069D\x03\x02\x02\x02\u06A0\u06A1\x07\x05\x02\x02\u06A1" +
		"?\x03\x02\x02\x02\u06A2\u06A7\x05:\x1E\x02\u06A3\u06A5\x07\u015B\x02\x02" +
		"\u06A4\u06A3\x03\x02\x02\x02\u06A4\u06A5\x03\x02\x02\x02\u06A5\u06A6\x03" +
		"\x02\x02\x02\u06A6\u06A8\x05\u010C\x87\x02\u06A7\u06A4\x03\x02\x02\x02" +
		"\u06A7\u06A8\x03\x02\x02\x02\u06A8A\x03\x02\x02\x02\u06A9\u06AA\x07\x04" +
		"\x02\x02\u06AA\u06AF\x05\u0120\x91\x02\u06AB\u06AC\x07\x06\x02\x02\u06AC" +
		"\u06AE\x05\u0120\x91\x02\u06AD\u06AB\x03\x02\x02\x02\u06AE\u06B1\x03\x02" +
		"\x02\x02\u06AF\u06AD\x03\x02\x02\x02\u06AF\u06B0\x03\x02\x02\x02\u06B0" +
		"\u06B2\x03\x02\x02\x02\u06B1\u06AF\x03\x02\x02\x02\u06B2\u06B3\x07\x05" +
		"\x02\x02\u06B3C\x03\x02\x02\x02\u06B4\u06B5\x07\x04\x02\x02\u06B5\u06BA" +
		"\x05B\"\x02\u06B6\u06B7\x07\x06\x02\x02\u06B7\u06B9\x05B\"\x02\u06B8\u06B6" +
		"\x03\x02\x02\x02\u06B9\u06BC\x03\x02\x02\x02\u06BA\u06B8\x03\x02\x02\x02" +
		"\u06BA\u06BB\x03\x02\x02\x02\u06BB\u06BD\x03\x02\x02\x02\u06BC\u06BA\x03" +
		"\x02\x02\x02\u06BD\u06BE\x07\x05\x02\x02\u06BEE\x03\x02\x02\x02\u06BF" +
		"\u06C0\x07\u0117\x02\x02\u06C0\u06C1\x07\x16\x02\x02\u06C1\u06C6\x05H" +
		"%\x02\u06C2\u06C3\x07\u0117\x02\x02\u06C3\u06C4\x07!\x02\x02\u06C4\u06C6" +
		"\x05J&\x02\u06C5\u06BF\x03\x02\x02\x02\u06C5\u06C2\x03\x02\x02\x02\u06C6" +
		"G\x03\x02\x02\x02\u06C7\u06C8\x07\x92\x02\x02\u06C8\u06C9\x05\u0182\xC2" +
		"\x02\u06C9\u06CA\x07\xD1\x02\x02\u06CA\u06CB\x05\u0182\xC2\x02\u06CB\u06CE" +
		"\x03\x02\x02\x02\u06CC\u06CE\x05\u0176\xBC\x02\u06CD\u06C7\x03\x02\x02" +
		"\x02\u06CD\u06CC\x03\x02\x02\x02\u06CEI\x03\x02\x02\x02\u06CF\u06D3\x05" +
		"\u0182\xC2\x02\u06D0\u06D1\x07\u0156\x02\x02\u06D1\u06D2\x07\u0107\x02" +
		"\x02\u06D2\u06D4\x056\x1C\x02\u06D3\u06D0\x03\x02\x02\x02\u06D3\u06D4" +
		"\x03\x02\x02\x02\u06D4K\x03\x02\x02\x02\u06D5\u06D6\x05\u0176\xBC\x02" +
		"\u06D6\u06D7\x05\u0182\xC2\x02\u06D7M\x03\x02\x02\x02\u06D8\u06D9\x05" +
		"\x1E\x10\x02\u06D9\u06DA\x05\x1C\x0F\x02\u06DA\u0711\x03\x02\x02\x02\u06DB" +
		"\u06DD\x05\x92J\x02\u06DC\u06DE\x05f4\x02\u06DD\u06DC\x03\x02\x02\x02" +
		"\u06DE\u06DF\x03\x02\x02\x02\u06DF\u06DD\x03\x02\x02\x02\u06DF\u06E0\x03" +
		"\x02\x02\x02\u06E0\u0711\x03\x02\x02\x02\u06E1\u06E2\x07V\x02\x02\u06E2" +
		"\u06E3\x07{\x02\x02\u06E3\u06E4\x05V,\x02\u06E4\u06E6\x05\xF0y\x02\u06E5" +
		"\u06E7\x05\x8AF\x02\u06E6\u06E5\x03\x02\x02\x02\u06E6\u06E7\x03\x02\x02" +
		"\x02\u06E7\u0711\x03\x02\x02\x02\u06E8\u06E9\x07\u0145\x02\x02\u06E9\u06EA" +
		"\x05V,\x02\u06EA\u06EB\x05\xF0y\x02\u06EB\u06ED\x05x=\x02\u06EC\u06EE" +
		"\x05\x8AF\x02\u06ED\u06EC\x03\x02\x02\x02\u06ED\u06EE\x03\x02\x02\x02" +
		"\u06EE\u0711\x03\x02\x02\x02\u06EF\u06F0\x07\xB1\x02\x02\u06F0\u06F1\x07" +
		"\x98\x02\x02\u06F1\u06F2\x05V,\x02\u06F2\u06F3\x05\xF0y\x02\u06F3\u06F9" +
		"\x07\u0148\x02\x02\u06F4\u06FA\x05b2\x02\u06F5\u06F6\x07\x04\x02\x02\u06F6" +
		"\u06F7\x05\x1C\x0F\x02\u06F7\u06F8\x07\x05\x02\x02\u06F8\u06FA\x03\x02" +
		"\x02\x02\u06F9\u06F4\x03\x02\x02\x02\u06F9\u06F5\x03\x02\x02\x02\u06FA" +
		"\u06FB\x03\x02\x02\x02\u06FB\u06FC\x05\xF0y\x02\u06FC\u06FD\x07\xC9\x02" +
		"\x02\u06FD\u0701\x05\u0114\x8B\x02\u06FE\u0700\x05z>\x02\u06FF\u06FE\x03" +
		"\x02\x02\x02\u0700\u0703\x03\x02\x02\x02\u0701\u06FF\x03\x02\x02\x02\u0701" +
		"\u0702\x03\x02\x02\x02\u0702\u0707\x03\x02\x02\x02\u0703\u0701\x03\x02" +
		"\x02\x02\u0704\u0706\x05|?\x02\u0705\u0704\x03\x02\x02\x02\u0706\u0709" +
		"\x03\x02\x02\x02\u0707\u0705\x03\x02\x02\x02\u0707\u0708\x03\x02\x02\x02" +
		"\u0708\u070D\x03\x02\x02\x02\u0709\u0707\x03\x02\x02\x02\u070A\u070C\x05" +
		"~@\x02\u070B\u070A\x03\x02\x02\x02\u070C\u070F\x03\x02\x02\x02\u070D\u070B" +
		"\x03\x02\x02\x02\u070D\u070E\x03\x02\x02\x02\u070E\u0711\x03\x02\x02\x02" +
		"\u070F\u070D\x03\x02\x02\x02\u0710\u06D8\x03\x02\x02\x02\u0710\u06DB\x03" +
		"\x02\x02\x02\u0710\u06E1\x03\x02\x02\x02\u0710\u06E8\x03\x02\x02\x02\u0710" +
		"\u06EF\x03\x02\x02\x02\u0711O\x03\x02\x02\x02\u0712\u0713\x05b2\x02\u0713" +
		"Q\x03\x02\x02\x02\u0714\u0715\x05b2\x02\u0715S\x03\x02\x02\x02\u0716\u0717" +
		"\x05\xFC\x7F\x02\u0717U\x03\x02\x02\x02\u0718\u0719\x05\xFC\x7F\x02\u0719" +
		"W\x03\x02\x02\x02\u071A\u071B\x05\xFE\x80\x02\u071BY\x03\x02\x02\x02\u071C" +
		"\u071D\x05\xFE\x80\x02\u071D[\x03\x02\x02\x02\u071E\u071F\x05\xF6|\x02" +
		"\u071F]\x03\x02\x02\x02\u0720\u0725\x05\\/\x02\u0721\u0722\x07\x06\x02" +
		"\x02\u0722\u0724\x05\\/\x02\u0723\u0721\x03\x02\x02\x02\u0724\u0727\x03" +
		"\x02\x02\x02\u0725\u0723\x03\x02\x02\x02\u0725\u0726\x03\x02\x02\x02\u0726" +
		"_\x03\x02\x02\x02\u0727\u0725\x03\x02\x02\x02\u0728\u0729\x05\u0172\xBA" +
		"\x02\u0729a\x03\x02\x02\x02\u072A\u072B\x07\x88\x02\x02\u072B\u072C\x07" +
		"\x04\x02\x02\u072C\u072D\x05\u010C\x87\x02\u072D\u072E\x07\x05\x02\x02" +
		"\u072E\u0731\x03\x02\x02\x02\u072F\u0731\x05\xF6|\x02\u0730\u072A\x03" +
		"\x02\x02\x02\u0730\u072F\x03\x02\x02\x02\u0731c\x03\x02\x02\x02\u0732" +
		"\u0733\x07\xCE\x02\x02\u0733\u0734\x07!\x02\x02\u0734\u0739\x05l7\x02" +
		"\u0735\u0736\x07\x06\x02\x02\u0736\u0738\x05l7\x02\u0737\u0735\x03\x02" +
		"\x02\x02\u0738\u073B\x03\x02\x02\x02\u0739\u0737\x03\x02\x02\x02\u0739" +
		"\u073A\x03\x02\x02\x02\u073A\u073D\x03\x02\x02\x02\u073B\u0739\x03\x02" +
		"\x02\x02\u073C\u0732\x03\x02\x02\x02\u073C\u073D\x03\x02\x02\x02\u073D" +
		"\u0748\x03\x02\x02\x02\u073E\u073F\x07.\x02\x02\u073F\u0740\x07!\x02\x02" +
		"\u0740\u0745\x05\u010C\x87\x02\u0741\u0742\x07\x06\x02\x02\u0742\u0744" +
		"\x05\u010C\x87\x02\u0743\u0741\x03\x02\x02\x02\u0744\u0747\x03\x02\x02" +
		"\x02\u0745\u0743\x03\x02\x02\x02\u0745\u0746\x03\x02\x02\x02\u0746\u0749" +
		"\x03\x02\x02\x02\u0747\u0745\x03\x02\x02\x02\u0748\u073E\x03\x02\x02\x02" +
		"\u0748\u0749\x03\x02\x02\x02\u0749\u0754\x03\x02\x02\x02\u074A\u074B\x07" +
		"^\x02\x02\u074B\u074C\x07!\x02\x02\u074C\u0751\x05\u010C\x87\x02\u074D" +
		"\u074E\x07\x06\x02\x02\u074E\u0750\x05\u010C\x87\x02\u074F\u074D\x03\x02" +
		"\x02\x02\u0750\u0753\x03\x02\x02\x02\u0751\u074F\x03\x02\x02\x02\u0751" +
		"\u0752\x03\x02\x02\x02\u0752\u0755\x03\x02\x02\x02\u0753\u0751\x03\x02" +
		"\x02\x02\u0754\u074A\x03\x02\x02\x02\u0754\u0755\x03\x02\x02\x02\u0755" +
		"\u0760\x03\x02\x02\x02\u0756\u0757\x07\u0112\x02\x02\u0757\u0758\x07!" +
		"\x02\x02\u0758\u075D\x05l7\x02\u0759\u075A\x07\x06\x02\x02\u075A\u075C" +
		"\x05l7\x02\u075B\u0759\x03\x02\x02\x02\u075C\u075F\x03\x02\x02\x02\u075D" +
		"\u075B\x03\x02\x02\x02\u075D\u075E\x03\x02\x02\x02\u075E\u0761\x03\x02" +
		"\x02\x02\u075F\u075D\x03\x02\x02\x02\u0760\u0756\x03\x02\x02\x02\u0760" +
		"\u0761\x03\x02\x02\x02\u0761\u0763\x03\x02\x02\x02\u0762\u0764\x05\u0160" +
		"\xB1\x02\u0763\u0762\x03\x02\x02\x02\u0763\u0764\x03\x02\x02\x02\u0764" +
		"\u076A\x03\x02\x02\x02\u0765\u0768\x07\xA4\x02\x02\u0766\u0769\x07\f\x02" +
		"\x02\u0767\u0769\x05\u010C\x87\x02\u0768\u0766\x03\x02\x02\x02\u0768\u0767" +
		"\x03\x02\x02\x02\u0769\u076B\x03\x02\x02\x02\u076A\u0765\x03\x02\x02\x02" +
		"\u076A\u076B\x03\x02\x02\x02\u076B\u076E\x03\x02\x02\x02\u076C\u076D\x07" +
		"\xC8\x02\x02\u076D\u076F\x05\u010C\x87\x02\u076E\u076C\x03\x02\x02\x02" +
		"\u076E\u076F\x03\x02\x02\x02\u076Fe\x03\x02\x02\x02\u0770\u0771\x05\x1E" +
		"\x10\x02\u0771\u0772\x05p9\x02\u0772g\x03\x02\x02\x02\u0773\u0774\b5\x01" +
		"\x02\u0774\u0775\x05j6\x02\u0775\u078A\x03\x02\x02\x02\u0776\u0777\f\x05" +
		"\x02\x02\u0777\u0779\t\x0E\x02\x02\u0778\u077A\x05\xC4c\x02\u0779\u0778" +
		"\x03\x02\x02\x02\u0779\u077A\x03\x02\x02\x02\u077A\u077B\x03\x02\x02\x02" +
		"\u077B\u0789\x05h5\x06\u077C\u077D\f\x04\x02\x02\u077D\u077F\x07\x94\x02" +
		"\x02\u077E\u0780\x05\xC4c\x02\u077F\u077E\x03\x02\x02\x02\u077F\u0780" +
		"\x03\x02\x02\x02\u0780\u0781\x03\x02\x02\x02\u0781\u0789\x05h5\x05\u0782" +
		"\u0783\f\x03\x02\x02\u0783\u0785\t\x0F\x02\x02\u0784\u0786\x05\xC4c\x02" +
		"\u0785\u0784\x03\x02\x02\x02\u0785\u0786\x03\x02\x02\x02\u0786\u0787\x03" +
		"\x02\x02\x02\u0787\u0789\x05h5\x04\u0788\u0776\x03\x02\x02\x02\u0788\u077C" +
		"\x03\x02\x02\x02\u0788\u0782\x03\x02\x02\x02\u0789\u078C\x03\x02\x02\x02" +
		"\u078A\u0788\x03\x02\x02\x02\u078A\u078B\x03\x02\x02\x02\u078Bi\x03\x02" +
		"\x02\x02\u078C\u078A\x03\x02\x02\x02\u078D\u0797\x05r:\x02\u078E\u0797" +
		"\x05n8\x02\u078F\u0790\x07\u0121\x02\x02\u0790\u0797\x05V,\x02\u0791\u0797" +
		"\x05\xE2r\x02\u0792\u0793\x07\x04\x02\x02\u0793\u0794\x05\x1C\x0F\x02" +
		"\u0794\u0795\x07\x05\x02\x02\u0795\u0797\x03\x02\x02\x02\u0796\u078D\x03" +
		"\x02\x02\x02\u0796\u078E\x03\x02\x02\x02\u0796\u078F\x03\x02\x02\x02\u0796" +
		"\u0791\x03\x02\x02\x02\u0796\u0792\x03\x02\x02\x02\u0797k\x03\x02\x02" +
		"\x02\u0798\u079B\x05\\/\x02\u0799\u079B\x05\u010C\x87\x02\u079A\u0798" +
		"\x03\x02\x02\x02\u079A\u0799\x03\x02\x02\x02\u079B\u079D\x03\x02\x02\x02" +
		"\u079C\u079E\t\x10\x02\x02\u079D\u079C\x03\x02\x02\x02\u079D\u079E\x03" +
		"\x02\x02\x02\u079E\u07A1\x03\x02\x02\x02\u079F\u07A0\x07\xC5\x02\x02\u07A0" +
		"\u07A2\t\x11\x02\x02\u07A1\u079F\x03\x02\x02\x02\u07A1\u07A2\x03\x02\x02" +
		"\x02\u07A2m\x03\x02\x02\x02\u07A3\u07A5\x05\x92J\x02\u07A4\u07A6\x05p" +
		"9\x02\u07A5\u07A4\x03\x02\x02\x02\u07A6\u07A7\x03\x02\x02\x02\u07A7\u07A5" +
		"\x03\x02\x02\x02\u07A7\u07A8\x03\x02\x02\x02\u07A8o\x03\x02\x02\x02\u07A9" +
		"\u07AB\x05t;\x02\u07AA\u07AC\x05\x8AF\x02\u07AB\u07AA\x03\x02\x02\x02" +
		"\u07AB\u07AC\x03\x02\x02\x02\u07AC\u07AD\x03\x02\x02\x02\u07AD\u07AE\x05" +
		"d3\x02\u07AE\u07C5\x03\x02\x02\x02\u07AF\u07B3\x05v<\x02\u07B0\u07B2\x05" +
		"\xC2b\x02\u07B1\u07B0\x03\x02\x02\x02\u07B2\u07B5\x03\x02\x02\x02\u07B3" +
		"\u07B1\x03\x02\x02\x02\u07B3\u07B4\x03\x02\x02\x02\u07B4\u07B7\x03\x02" +
		"\x02\x02\u07B5\u07B3\x03\x02\x02\x02\u07B6\u07B8\x05\x8AF\x02\u07B7\u07B6" +
		"\x03\x02\x02\x02\u07B7\u07B8\x03\x02\x02\x02\u07B8\u07BA\x03\x02\x02\x02" +
		"\u07B9\u07BB\x05\x98M\x02\u07BA\u07B9\x03\x02\x02\x02\u07BA\u07BB\x03" +
		"\x02\x02\x02\u07BB\u07BD\x03\x02\x02\x02\u07BC\u07BE\x05\x8CG\x02\u07BD" +
		"\u07BC\x03\x02\x02\x02\u07BD\u07BE\x03\x02\x02\x02\u07BE\u07C0\x03\x02" +
		"\x02\x02\u07BF\u07C1\x05\u0160\xB1\x02\u07C0\u07BF\x03\x02\x02\x02\u07C0" +
		"\u07C1\x03\x02\x02\x02\u07C1\u07C2\x03\x02\x02\x02\u07C2\u07C3\x05d3\x02" +
		"\u07C3\u07C5\x03\x02\x02\x02\u07C4\u07A9\x03\x02\x02\x02\u07C4\u07AF\x03" +
		"\x02\x02\x02\u07C5q\x03\x02\x02\x02\u07C6\u07C8\x05t;\x02\u07C7\u07C9" +
		"\x05\x92J\x02\u07C8\u07C7\x03\x02\x02\x02\u07C8\u07C9\x03\x02\x02\x02" +
		"\u07C9\u07CD\x03\x02\x02\x02\u07CA\u07CC\x05\xC2b\x02\u07CB\u07CA\x03" +
		"\x02\x02\x02\u07CC\u07CF\x03\x02\x02\x02\u07CD\u07CB\x03\x02\x02\x02\u07CD" +
		"\u07CE\x03\x02\x02\x02\u07CE\u07D1\x03\x02\x02\x02\u07CF\u07CD\x03\x02" +
		"\x02\x02\u07D0\u07D2\x05\x8AF\x02\u07D1\u07D0\x03\x02\x02\x02\u07D1\u07D2" +
		"\x03\x02\x02\x02\u07D2\u07D4\x03\x02\x02\x02\u07D3\u07D5\x05\x98M\x02" +
		"\u07D4\u07D3\x03\x02\x02\x02\u07D4\u07D5\x03\x02\x02\x02\u07D5\u07D7\x03" +
		"\x02\x02\x02\u07D6\u07D8\x05\x8CG\x02\u07D7\u07D6\x03\x02\x02\x02\u07D7" +
		"\u07D8\x03\x02\x02\x02\u07D8\u07DA\x03\x02\x02\x02\u07D9\u07DB\x05\u0160" +
		"\xB1\x02\u07DA\u07D9\x03\x02\x02\x02\u07DA\u07DB\x03\x02\x02\x02\u07DB" +
		"\u07F3\x03\x02\x02\x02\u07DC\u07DE\x05v<\x02\u07DD\u07DF\x05\x92J\x02" +
		"\u07DE\u07DD\x03\x02\x02\x02\u07DE\u07DF\x03\x02\x02\x02\u07DF\u07E3\x03" +
		"\x02\x02\x02\u07E0\u07E2\x05\xC2b\x02\u07E1\u07E0\x03\x02\x02\x02\u07E2" +
		"\u07E5\x03\x02\x02\x02\u07E3\u07E1\x03\x02\x02\x02\u07E3\u07E4\x03\x02" +
		"\x02\x02\u07E4\u07E7\x03\x02\x02\x02\u07E5\u07E3\x03\x02\x02\x02\u07E6" +
		"\u07E8\x05\x8AF\x02\u07E7\u07E6\x03\x02\x02\x02\u07E7\u07E8\x03\x02\x02" +
		"\x02\u07E8\u07EA\x03\x02\x02\x02\u07E9\u07EB\x05\x98M\x02\u07EA\u07E9" +
		"\x03\x02\x02\x02\u07EA\u07EB\x03\x02\x02\x02\u07EB\u07ED\x03\x02\x02\x02" +
		"\u07EC\u07EE\x05\x8CG\x02\u07ED\u07EC\x03\x02\x02\x02\u07ED\u07EE\x03" +
		"\x02\x02\x02\u07EE\u07F0\x03\x02\x02\x02\u07EF\u07F1\x05\u0160\xB1\x02" +
		"\u07F0\u07EF\x03\x02\x02\x02\u07F0\u07F1\x03\x02\x02\x02\u07F1\u07F3\x03" +
		"\x02\x02\x02\u07F2\u07C6\x03\x02\x02\x02\u07F2\u07DC\x03\x02\x02\x02\u07F3" +
		"s\x03\x02\x02\x02\u07F4\u07F5\x07\u0103\x02\x02\u07F5\u07F6\x07\u0136" +
		"\x02\x02\u07F6\u07F8\x07\x04\x02\x02\u07F7\u07F9\x05\xC4c\x02\u07F8\u07F7" +
		"\x03\x02\x02\x02\u07F8\u07F9\x03\x02\x02\x02\u07F9\u07FA\x03\x02\x02\x02" +
		"\u07FA\u07FB\x05\u0112\x8A\x02\u07FB\u07FC\x07\x05\x02\x02\u07FC\u0808" +
		"\x03\x02\x02\x02\u07FD\u07FF\x07\xAF\x02\x02\u07FE\u0800\x05\xC4c\x02" +
		"\u07FF\u07FE\x03\x02\x02\x02\u07FF\u0800\x03\x02\x02\x02\u0800\u0801\x03" +
		"\x02\x02\x02\u0801\u0808\x05\u0112\x8A\x02\u0802\u0804\x07\xEB\x02\x02" +
		"\u0803\u0805\x05\xC4c\x02\u0804\u0803\x03\x02\x02\x02\u0804\u0805\x03" +
		"\x02\x02\x02\u0805\u0806\x03\x02\x02\x02\u0806\u0808\x05\u0112\x8A\x02" +
		"\u0807\u07F4\x03\x02\x02\x02\u0807\u07FD\x03\x02\x02\x02\u0807\u0802\x03" +
		"\x02\x02\x02\u0808\u080A\x03\x02\x02\x02\u0809\u080B\x05\xF2z\x02\u080A" +
		"\u0809\x03\x02\x02\x02\u080A\u080B\x03\x02\x02\x02\u080B\u080E\x03\x02" +
		"\x02\x02\u080C\u080D\x07\xE9\x02\x02\u080D\u080F\x05\u0182\xC2\x02\u080E" +
		"\u080C\x03\x02\x02\x02\u080E\u080F\x03\x02\x02\x02\u080F\u0810\x03\x02" +
		"\x02\x02\u0810\u0811\x07\u0148\x02\x02\u0811\u081E\x05\u0182\xC2\x02\u0812" +
		"\u081C\x07\x16\x02\x02\u0813\u081D\x05\xD6l\x02\u0814\u081D\x05\u014E" +
		"\xA8\x02\u0815\u0818\x07\x04\x02\x02\u0816\u0819\x05\xD6l\x02\u0817\u0819" +
		"\x05\u014E\xA8\x02\u0818\u0816\x03\x02\x02\x02\u0818\u0817\x03\x02\x02" +
		"\x02\u0819\u081A\x03\x02\x02\x02\u081A\u081B\x07\x05\x02\x02\u081B\u081D" +
		"\x03\x02\x02\x02\u081C\u0813\x03\x02\x02\x02\u081C\u0814\x03\x02\x02\x02" +
		"\u081C\u0815\x03\x02\x02\x02\u081D\u081F\x03\x02\x02\x02\u081E\u0812\x03" +
		"\x02\x02\x02\u081E\u081F\x03\x02\x02\x02\u081F\u0821\x03\x02\x02\x02\u0820" +
		"\u0822\x05\xF2z\x02\u0821\u0820\x03\x02\x02\x02\u0821\u0822\x03\x02\x02" +
		"\x02\u0822\u0825\x03\x02\x02\x02\u0823\u0824\x07\xE8\x02\x02\u0824\u0826" +
		"\x05\u0182\xC2\x02\u0825\u0823\x03\x02\x02\x02\u0825\u0826\x03\x02\x02" +
		"\x02\u0826u\x03\x02\x02\x02\u0827\u082B\x07\u0103\x02\x02\u0828\u082A" +
		"\x05\x8EH\x02\u0829\u0828\x03\x02\x02\x02\u082A\u082D\x03\x02\x02\x02" +
		"\u082B\u0829\x03\x02\x02\x02\u082B\u082C\x03\x02\x02\x02\u082C\u082F\x03" +
		"\x02\x02\x02\u082D\u082B\x03\x02\x02\x02\u082E\u0830\x05\xC4c\x02\u082F" +
		"\u082E\x03\x02\x02\x02\u082F\u0830\x03\x02\x02\x02\u0830\u0831\x03\x02" +
		"\x02\x02\u0831\u0832\x05\u0102\x82\x02\u0832w\x03\x02\x02\x02\u0833\u0834" +
		"\x07\u0109\x02\x02\u0834\u0835\x05\x86D\x02\u0835y\x03\x02\x02\x02\u0836" +
		"\u0837\x07\u0153\x02\x02\u0837\u083A\x07\xB0\x02\x02\u0838\u0839\x07\x10" +
		"\x02\x02\u0839\u083B\x05\u0114\x8B\x02\u083A\u0838\x03\x02\x02\x02\u083A" +
		"\u083B\x03\x02\x02\x02\u083B\u083C\x03\x02\x02\x02\u083C\u083D\x07\u0128" +
		"\x02\x02\u083D\u083E\x05\x80A\x02\u083E{\x03\x02\x02\x02\u083F\u0840\x07" +
		"\u0153\x02\x02\u0840\u0841\x07\xC3\x02\x02\u0841\u0844\x07\xB0\x02\x02" +
		"\u0842\u0843\x07!\x02\x02\u0843\u0845\x07\u0124\x02\x02\u0844\u0842\x03" +
		"\x02\x02\x02\u0844\u0845\x03\x02\x02\x02\u0845\u0848\x03\x02\x02\x02\u0846" +
		"\u0847\x07\x10\x02\x02\u0847\u0849\x05\u0114\x8B\x02\u0848\u0846\x03\x02" +
		"\x02\x02\u0848\u0849\x03\x02\x02\x02\u0849\u084A\x03\x02\x02\x02\u084A" +
		"\u084B\x07\u0128\x02\x02\u084B\u084C\x05\x82B\x02\u084C}\x03\x02\x02\x02" +
		"\u084D\u084E\x07\u0153\x02\x02\u084E\u084F\x07\xC3\x02\x02\u084F\u0850" +
		"\x07\xB0\x02\x02\u0850\u0851\x07!\x02\x02\u0851\u0854\x07\u0114\x02\x02" +
		"\u0852\u0853\x07\x10\x02\x02\u0853\u0855\x05\u0114\x8B\x02\u0854\u0852" +
		"\x03\x02\x02\x02\u0854\u0855\x03\x02\x02\x02\u0855\u0856\x03\x02\x02\x02" +
		"\u0856\u0857\x07\u0128\x02\x02\u0857\u0858\x05\x84C\x02\u0858\x7F\x03" +
		"\x02\x02\x02\u0859\u0861\x07V\x02\x02\u085A\u085B\x07\u0145\x02\x02\u085B" +
		"\u085C\x07\u0109\x02\x02\u085C\u0861\x07\u0166\x02\x02\u085D\u085E\x07" +
		"\u0145\x02\x02\u085E\u085F\x07\u0109\x02\x02\u085F\u0861\x05\x86D\x02" +
		"\u0860\u0859\x03\x02\x02\x02\u0860\u085A\x03\x02\x02\x02\u0860\u085D\x03" +
		"\x02\x02\x02\u0861\x81\x03\x02\x02\x02\u0862\u0863\x07\x93\x02\x02\u0863" +
		"\u0875\x07\u0166\x02\x02\u0864\u0865\x07\x93\x02\x02\u0865\u0866\x07\x04" +
		"\x02\x02\u0866\u0867\x05\xF4{\x02\u0867\u0868\x07\x05\x02\x02\u0868\u0869" +
		"\x07\u0149\x02\x02\u0869\u086A\x07\x04\x02\x02\u086A\u086F\x05\u010C\x87" +
		"\x02\u086B\u086C\x07\x06\x02\x02\u086C\u086E\x05\u010C\x87\x02\u086D\u086B" +
		"\x03\x02\x02\x02\u086E\u0871\x03\x02\x02\x02\u086F\u086D\x03\x02\x02\x02" +
		"\u086F\u0870\x03\x02\x02\x02\u0870\u0872\x03\x02\x02\x02\u0871\u086F\x03" +
		"\x02\x02\x02\u0872\u0873\x07\x05\x02\x02\u0873\u0875\x03\x02\x02\x02\u0874" +
		"\u0862\x03\x02\x02\x02\u0874\u0864\x03\x02\x02\x02\u0875\x83\x03\x02\x02" +
		"\x02\u0876\u087B\x07V\x02\x02\u0877\u0878\x07\u0145\x02\x02\u0878\u0879" +
		"\x07\u0109\x02\x02\u0879\u087B\x05\x86D\x02\u087A\u0876\x03\x02\x02\x02" +
		"\u087A\u0877\x03\x02\x02\x02\u087B\x85\x03\x02\x02\x02\u087C\u0881\x05" +
		"\x88E\x02\u087D\u087E\x07\x06\x02\x02\u087E\u0880\x05\x88E\x02\u087F\u087D" +
		"\x03\x02\x02\x02\u0880\u0883\x03\x02\x02\x02\u0881\u087F\x03\x02\x02\x02" +
		"\u0881\u0882\x03\x02\x02\x02\u0882\x87\x03\x02\x02\x02\u0883\u0881\x03" +
		"\x02\x02\x02\u0884\u0885\x05\xF6|\x02\u0885\u0886\x07\u015B\x02\x02\u0886" +
		"\u0887\x05\u010C\x87\x02\u0887\x89\x03\x02\x02\x02\u0888\u0889\x07\u0154" +
		"\x02\x02\u0889\u088A\x05\u0114\x8B\x02\u088A\x8B\x03\x02\x02\x02\u088B" +
		"\u088C\x07\x84\x02\x02\u088C\u088D\x05\u0114\x8B\x02\u088D\x8D\x03\x02" +
		"\x02\x02\u088E\u088F\x07\u0171\x02\x02\u088F\u0896\x05\x90I\x02\u0890" +
		"\u0892\x07\x06\x02\x02\u0891\u0890\x03\x02\x02\x02\u0891\u0892\x03\x02" +
		"\x02\x02\u0892\u0893\x03\x02\x02\x02\u0893\u0895\x05\x90I\x02\u0894\u0891" +
		"\x03\x02\x02\x02\u0895\u0898\x03\x02\x02\x02\u0896\u0894\x03\x02\x02\x02" +
		"\u0896\u0897\x03\x02\x02\x02\u0897\u0899\x03\x02\x02\x02\u0898\u0896\x03" +
		"\x02\x02\x02\u0899\u089A\x07\u0172\x02\x02\u089A\x8F\x03\x02\x02\x02\u089B" +
		"\u08A9\x05\u0176\xBC\x02\u089C\u089D\x05\u0176\xBC\x02\u089D\u089E\x07" +
		"\x04\x02\x02\u089E\u08A3\x05\u011C\x8F\x02\u089F\u08A0\x07\x06\x02\x02" +
		"\u08A0\u08A2\x05\u011C\x8F\x02\u08A1\u089F\x03\x02\x02\x02\u08A2\u08A5" +
		"\x03\x02\x02\x02\u08A3\u08A1\x03\x02\x02\x02\u08A3\u08A4\x03\x02\x02\x02" +
		"\u08A4\u08A6\x03\x02\x02\x02\u08A5\u08A3\x03\x02\x02\x02\u08A6\u08A7\x07" +
		"\x05\x02\x02\u08A7\u08A9\x03\x02\x02\x02\u08A8\u089B\x03\x02\x02\x02\u08A8" +
		"\u089C\x03\x02\x02\x02\u08A9\x91\x03\x02\x02\x02\u08AA\u08AB\x07{\x02" +
		"\x02\u08AB\u08B0\x05\xC6d\x02\u08AC\u08AD\x07\x06\x02\x02\u08AD\u08AF" +
		"\x05\xC6d\x02\u08AE\u08AC\x03\x02\x02\x02\u08AF\u08B2\x03\x02\x02\x02" +
		"\u08B0\u08AE\x03\x02\x02\x02\u08B0\u08B1\x03\x02\x02\x02\u08B1\u08B6\x03" +
		"\x02\x02\x02\u08B2\u08B0\x03\x02\x02\x02\u08B3\u08B5\x05\xC2b\x02\u08B4" +
		"\u08B3\x03\x02\x02\x02\u08B5\u08B8\x03\x02\x02\x02\u08B6\u08B4\x03\x02" +
		"\x02\x02\u08B6\u08B7\x03\x02\x02\x02\u08B7\u08BA\x03\x02\x02\x02\u08B8" +
		"\u08B6\x03\x02\x02\x02\u08B9\u08BB\x05\xA2R\x02\u08BA\u08B9\x03\x02\x02" +
		"\x02\u08BA\u08BB\x03\x02\x02\x02\u08BB\u08BD\x03\x02\x02\x02\u08BC\u08BE" +
		"\x05\xA8U\x02\u08BD\u08BC\x03\x02\x02\x02\u08BD\u08BE\x03\x02\x02\x02" +
		"\u08BE\x93\x03\x02\x02\x02\u08BF\u08C0\t\x12\x02\x02\u08C0\x95\x03\x02" +
		"\x02\x02\u08C1\u08C3\x07w\x02\x02\u08C2\u08C1\x03\x02\x02\x02\u08C2\u08C3" +
		"\x03\x02\x02\x02\u08C3\u08C4\x03\x02\x02\x02\u08C4\u08C5\t\x13\x02\x02" +
		"\u08C5\u08C6\x07\x16\x02\x02\u08C6\u08C7\x07\xC7\x02\x02\u08C7\u08D0\x05" +
		"\u0186\xC4\x02\u08C8\u08CA\x07w\x02\x02\u08C9\u08C8\x03\x02\x02\x02\u08C9" +
		"\u08CA\x03\x02\x02\x02\u08CA\u08CB\x03\x02\x02\x02\u08CB\u08CC\t\x14\x02" +
		"\x02\u08CC\u08CD\x07\x16\x02\x02\u08CD\u08CE\x07\xC7\x02\x02\u08CE\u08D0" +
		"\x05\u0118\x8D\x02\u08CF\u08C2\x03\x02\x02\x02\u08CF\u08C9\x03\x02\x02" +
		"\x02\u08D0\x97\x03\x02\x02\x02\u08D1\u08D2\x07\x82\x02\x02\u08D2\u08D3" +
		"\x07!\x02\x02\u08D3\u08D8\x05\x9AN\x02\u08D4\u08D5\x07\x06\x02\x02\u08D5" +
		"\u08D7\x05\x9AN\x02\u08D6\u08D4\x03\x02\x02\x02\u08D7\u08DA\x03\x02\x02" +
		"\x02\u08D8\u08D6\x03\x02\x02\x02\u08D8\u08D9\x03\x02\x02\x02\u08D9\u08F9" +
		"\x03\x02\x02\x02\u08DA\u08D8\x03\x02\x02\x02\u08DB\u08DC\x07\x82\x02\x02" +
		"\u08DC\u08DD\x07!\x02\x02\u08DD\u08E2\x05\u010C\x87\x02\u08DE\u08DF\x07" +
		"\x06\x02\x02\u08DF\u08E1\x05\u010C\x87\x02\u08E0\u08DE\x03\x02\x02\x02" +
		"\u08E1\u08E4\x03\x02\x02\x02\u08E2\u08E0\x03\x02\x02\x02\u08E2\u08E3\x03" +
		"\x02\x02\x02\u08E3\u08F6\x03\x02\x02\x02\u08E4\u08E2\x03\x02\x02\x02\u08E5" +
		"\u08E6\x07\u0156\x02\x02\u08E6\u08F7\x07\xFC\x02\x02\u08E7\u08E8\x07\u0156" +
		"\x02\x02\u08E8\u08F7\x07?\x02\x02\u08E9\u08EA\x07\x83\x02\x02\u08EA\u08EB" +
		"\x07\u010B\x02\x02\u08EB\u08EC\x07\x04\x02\x02\u08EC\u08F1\x05\xA0Q\x02" +
		"\u08ED\u08EE\x07\x06\x02\x02\u08EE\u08F0\x05\xA0Q\x02\u08EF\u08ED\x03" +
		"\x02\x02\x02\u08F0\u08F3\x03\x02\x02\x02\u08F1\u08EF\x03\x02\x02\x02\u08F1" +
		"\u08F2\x03\x02\x02\x02\u08F2\u08F4\x03\x02\x02\x02\u08F3\u08F1\x03\x02" +
		"\x02\x02\u08F4\u08F5\x07\x05\x02\x02\u08F5\u08F7\x03\x02\x02\x02\u08F6" +
		"\u08E5\x03\x02\x02\x02\u08F6\u08E7\x03\x02\x02\x02\u08F6\u08E9\x03\x02" +
		"\x02\x02\u08F6\u08F7\x03\x02\x02\x02\u08F7\u08F9\x03\x02\x02\x02\u08F8" +
		"\u08D1\x03\x02\x02\x02\u08F8\u08DB\x03\x02\x02\x02\u08F9\x99\x03\x02\x02" +
		"\x02\u08FA\u08FE\x05\\/\x02\u08FB\u08FE\x05\x9CO\x02\u08FC\u08FE\x05\u010C" +
		"\x87\x02\u08FD\u08FA\x03\x02\x02\x02\u08FD\u08FB\x03\x02\x02\x02\u08FD" +
		"\u08FC\x03\x02\x02\x02\u08FE\x9B\x03\x02\x02\x02\u08FF\u0900\t\x15\x02" +
		"\x02\u0900\u0901\x07\x04\x02\x02\u0901\u0906\x05\xA0Q\x02\u0902\u0903" +
		"\x07\x06\x02\x02\u0903\u0905\x05\xA0Q\x02\u0904\u0902\x03\x02\x02\x02" +
		"\u0905\u0908\x03\x02\x02\x02\u0906\u0904\x03\x02\x02\x02\u0906\u0907\x03" +
		"\x02\x02\x02\u0907\u0909\x03\x02\x02\x02\u0908\u0906\x03\x02\x02\x02\u0909" +
		"\u090A\x07\x05\x02\x02\u090A\u0919\x03\x02\x02\x02\u090B\u090C\x07\x83" +
		"\x02\x02\u090C\u090D\x07\u010B\x02\x02\u090D\u090E\x07\x04\x02\x02\u090E" +
		"\u0913\x05\x9EP\x02\u090F\u0910\x07\x06\x02\x02\u0910\u0912\x05\x9EP\x02" +
		"\u0911\u090F\x03\x02\x02\x02\u0912\u0915\x03\x02\x02\x02\u0913\u0911\x03" +
		"\x02\x02\x02\u0913\u0914\x03\x02\x02\x02\u0914\u0916\x03\x02\x02\x02\u0915" +
		"\u0913\x03\x02\x02\x02\u0916\u0917\x07\x05\x02\x02\u0917\u0919\x03\x02" +
		"\x02\x02\u0918\u08FF\x03\x02\x02\x02\u0918\u090B\x03\x02\x02\x02\u0919" +
		"\x9D\x03\x02\x02\x02\u091A\u091D\x05\x9CO\x02\u091B\u091D\x05\xA0Q\x02" +
		"\u091C\u091A\x03\x02\x02\x02\u091C\u091B\x03\x02\x02\x02\u091D\x9F\x03" +
		"\x02\x02\x02\u091E\u0933\x05\\/\x02\u091F\u0933\x05\u010C\x87\x02\u0920" +
		"\u092F\x07\x04\x02\x02\u0921\u0924\x05\\/\x02\u0922\u0924\x05\u010C\x87" +
		"\x02\u0923\u0921\x03\x02\x02\x02\u0923\u0922\x03\x02\x02\x02\u0924\u092C" +
		"\x03\x02\x02\x02\u0925\u0928\x07\x06\x02\x02\u0926\u0929\x05\\/\x02\u0927" +
		"\u0929\x05\u010C\x87\x02\u0928\u0926\x03\x02\x02\x02\u0928\u0927\x03\x02" +
		"\x02\x02\u0929\u092B\x03\x02\x02\x02\u092A\u0925\x03\x02\x02\x02\u092B" +
		"\u092E\x03\x02\x02\x02\u092C\u092A\x03\x02\x02\x02\u092C\u092D\x03\x02" +
		"\x02\x02\u092D\u0930\x03\x02\x02\x02\u092E\u092C\x03\x02\x02\x02\u092F" +
		"\u0923\x03\x02\x02\x02\u092F\u0930\x03\x02\x02\x02\u0930\u0931\x03\x02" +
		"\x02\x02\u0931\u0933\x07\x05\x02\x02\u0932";
	private static readonly _serializedATNSegment5: string =
		"\u091E\x03\x02\x02\x02\u0932\u091F\x03\x02\x02\x02\u0932\u0920\x03\x02" +
		"\x02\x02\u0933\xA1\x03\x02\x02\x02\u0934\u0935\x07\xDC\x02\x02\u0935\u0936" +
		"\x07\x04\x02\x02\u0936\u0937\x05\u0102\x82\x02\u0937\u0938\x07w\x02\x02" +
		"\u0938\u0939\x05\xA4S\x02\u0939\u093A\x07\x8C\x02\x02\u093A\u093B\x07" +
		"\x04\x02\x02\u093B\u0940\x05\xA6T\x02\u093C\u093D\x07\x06\x02\x02\u093D" +
		"\u093F\x05\xA6T\x02\u093E\u093C\x03\x02\x02\x02\u093F\u0942\x03\x02\x02" +
		"\x02\u0940\u093E\x03\x02\x02\x02\u0940\u0941\x03\x02\x02\x02\u0941\u0943" +
		"\x03\x02\x02\x02\u0942\u0940\x03\x02\x02\x02\u0943\u0944\x07\x05\x02\x02" +
		"\u0944\u0945\x07\x05\x02\x02\u0945\xA3\x03\x02\x02\x02\u0946\u0953\x05" +
		"\u0176\xBC\x02\u0947\u0948\x07\x04\x02\x02\u0948\u094D\x05\u0176\xBC\x02" +
		"\u0949\u094A\x07\x06\x02\x02\u094A\u094C\x05\u0176\xBC\x02\u094B\u0949" +
		"\x03\x02\x02\x02\u094C\u094F\x03\x02\x02\x02\u094D\u094B\x03\x02\x02\x02" +
		"\u094D\u094E\x03\x02\x02\x02\u094E\u0950\x03\x02\x02\x02\u094F\u094D\x03" +
		"\x02\x02\x02\u0950\u0951\x07\x05\x02\x02\u0951\u0953\x03\x02\x02\x02\u0952" +
		"\u0946\x03\x02\x02\x02\u0952\u0947\x03\x02\x02\x02\u0953\xA5\x03\x02\x02" +
		"\x02\u0954\u0959\x05\u010C\x87\x02\u0955\u0957\x07\x16\x02\x02\u0956\u0955" +
		"\x03\x02\x02\x02\u0956\u0957\x03\x02\x02\x02\u0957\u0958\x03\x02\x02\x02" +
		"\u0958\u095A\x05\u0176\xBC\x02\u0959\u0956\x03\x02\x02\x02\u0959\u095A" +
		"\x03\x02\x02\x02\u095A\xA7\x03\x02\x02\x02\u095B\u095D\x07\u0143\x02\x02" +
		"\u095C\u095E\x05\xAAV\x02\u095D\u095C\x03\x02\x02\x02\u095D\u095E\x03" +
		"\x02\x02\x02\u095E\u095F\x03\x02\x02\x02\u095F\u0960\x07\x04\x02\x02\u0960" +
		"\u0961\x05\xACW\x02\u0961\u0966\x07\x05\x02\x02\u0962\u0964\x07\x16\x02" +
		"\x02\u0963\u0962\x03\x02\x02\x02\u0963\u0964\x03\x02\x02\x02\u0964\u0965" +
		"\x03\x02\x02\x02\u0965\u0967\x05\u0176\xBC\x02\u0966\u0963\x03\x02\x02" +
		"\x02\u0966\u0967\x03\x02\x02\x02\u0967\xA9\x03\x02\x02\x02\u0968\u0969" +
		"\t\x16\x02\x02\u0969\u096A\x07\xC5\x02\x02\u096A\xAB\x03\x02\x02\x02\u096B" +
		"\u096E\x05\xAEX\x02\u096C\u096E\x05\xB0Y\x02\u096D\u096B\x03\x02\x02\x02" +
		"\u096D\u096C\x03\x02\x02\x02\u096E\xAD\x03\x02\x02\x02\u096F\u0970\x05" +
		"\xB4[\x02\u0970\u0971\x07w\x02\x02\u0971\u0972\x05\xB6\\\x02\u0972\u0973" +
		"\x07\x8C\x02\x02\u0973\u0974\x07\x04\x02\x02\u0974\u0979\x05\xB8]\x02" +
		"\u0975\u0976\x07\x06\x02\x02\u0976\u0978\x05\xB8]\x02\u0977\u0975\x03" +
		"\x02\x02\x02\u0978\u097B\x03\x02\x02\x02\u0979\u0977\x03\x02\x02\x02\u0979" +
		"\u097A\x03\x02\x02\x02\u097A\u097C\x03\x02\x02\x02\u097B\u0979\x03\x02" +
		"\x02\x02\u097C\u097D\x07\x05\x02\x02\u097D\xAF\x03\x02\x02\x02\u097E\u097F" +
		"\x07\x04\x02\x02\u097F\u0984\x05\xB4[\x02\u0980\u0981\x07\x06\x02\x02" +
		"\u0981\u0983\x05\xB4[\x02\u0982\u0980\x03\x02\x02\x02\u0983\u0986\x03" +
		"\x02\x02\x02\u0984\u0982\x03\x02\x02\x02\u0984\u0985\x03\x02\x02\x02\u0985" +
		"\u0987\x03\x02\x02\x02\u0986\u0984\x03\x02\x02\x02\u0987\u0988\x07\x05" +
		"\x02\x02\u0988\u0989\x07w\x02\x02\u0989\u098A\x05\xB6\\\x02\u098A\u098B" +
		"\x07\x8C\x02\x02\u098B\u098C\x07\x04\x02\x02\u098C\u0991\x05\xB2Z\x02" +
		"\u098D\u098E\x07\x06\x02\x02\u098E\u0990\x05\xB2Z\x02\u098F\u098D\x03" +
		"\x02\x02\x02\u0990\u0993\x03\x02\x02\x02\u0991\u098F\x03\x02\x02\x02\u0991" +
		"\u0992\x03\x02\x02\x02\u0992\u0994\x03\x02\x02\x02\u0993\u0991\x03\x02" +
		"\x02\x02\u0994\u0995\x07\x05\x02\x02\u0995\xB1\x03\x02\x02\x02\u0996\u0997" +
		"\x07\x04\x02\x02\u0997\u099C\x05\xBA^\x02\u0998\u0999\x07\x06\x02\x02" +
		"\u0999\u099B\x05\xBA^\x02\u099A\u0998\x03\x02\x02\x02\u099B\u099E\x03" +
		"\x02\x02\x02\u099C\u099A\x03\x02\x02\x02\u099C\u099D\x03\x02\x02\x02\u099D" +
		"\u099F\x03\x02\x02\x02\u099E\u099C\x03\x02\x02\x02\u099F\u09A1\x07\x05" +
		"\x02\x02\u09A0\u09A2\x05\xBC_\x02\u09A1\u09A0\x03\x02\x02\x02\u09A1\u09A2" +
		"\x03\x02\x02\x02\u09A2\xB3\x03\x02\x02\x02\u09A3\u09A4\x05\u0176\xBC\x02" +
		"\u09A4\xB5\x03\x02\x02\x02\u09A5\u09A6\x05\u0176\xBC\x02\u09A6\xB7\x03" +
		"\x02\x02\x02\u09A7\u09A9\x05\xBA^\x02\u09A8\u09AA\x05\xBC_\x02\u09A9\u09A8" +
		"\x03\x02\x02\x02\u09A9\u09AA\x03\x02\x02\x02\u09AA\xB9\x03\x02\x02\x02" +
		"\u09AB\u09AC\x05\xF6|\x02\u09AC\xBB\x03\x02\x02\x02\u09AD\u09AF\x07\x16" +
		"\x02\x02\u09AE\u09AD\x03\x02\x02\x02\u09AE\u09AF\x03\x02\x02\x02\u09AF" +
		"\u09B0\x03\x02\x02\x02\u09B0\u09B1\x05\u0176\xBC\x02\u09B1\xBD\x03\x02" +
		"\x02\x02\u09B2\u09B3\x07\x89\x02\x02\u09B3\u09B4\x07\xC3\x02\x02\u09B4" +
		"\u09B5\x07i\x02\x02\u09B5\xBF\x03\x02\x02\x02\u09B6\u09B7\x07\x89\x02" +
		"\x02\u09B7\u09B8\x07i\x02\x02\u09B8\xC1\x03\x02\x02\x02\u09B9\u09BA\x07" +
		"\x9E\x02\x02\u09BA\u09BC\x07\u014E\x02\x02\u09BB\u09BD\x07\xD0\x02\x02" +
		"\u09BC\u09BB\x03\x02\x02\x02\u09BC\u09BD\x03\x02\x02\x02\u09BD\u09BE\x03" +
		"\x02\x02\x02\u09BE\u09BF\x05Z.\x02\u09BF\u09C8\x07\x04\x02\x02\u09C0\u09C5" +
		"\x05\u010C\x87\x02\u09C1\u09C2\x07\x06\x02\x02\u09C2\u09C4\x05\u010C\x87" +
		"\x02\u09C3\u09C1\x03\x02\x02\x02\u09C4\u09C7\x03\x02\x02\x02\u09C5\u09C3" +
		"\x03\x02\x02\x02\u09C5\u09C6\x03\x02\x02\x02\u09C6\u09C9\x03\x02\x02\x02" +
		"\u09C7\u09C5\x03\x02\x02\x02\u09C8\u09C0\x03\x02\x02\x02\u09C8\u09C9\x03" +
		"\x02\x02\x02\u09C9\u09CA\x03\x02\x02\x02\u09CA\u09CB\x07\x05\x02\x02\u09CB" +
		"\u09D7\x05\xF0y\x02\u09CC\u09CE\x07\x16\x02\x02\u09CD\u09CC\x03\x02\x02" +
		"\x02\u09CD\u09CE\x03\x02\x02\x02\u09CE\u09CF\x03\x02\x02\x02\u09CF\u09D4" +
		"\x05\u0176\xBC\x02\u09D0\u09D1\x07\x06\x02\x02\u09D1\u09D3\x05\u0176\xBC" +
		"\x02\u09D2\u09D0\x03\x02\x02\x02\u09D3\u09D6\x03\x02\x02\x02\u09D4\u09D2" +
		"\x03\x02\x02\x02\u09D4\u09D5\x03\x02\x02\x02\u09D5\u09D8\x03\x02\x02\x02" +
		"\u09D6\u09D4\x03\x02\x02\x02\u09D7\u09CD\x03\x02\x02\x02\u09D7\u09D8\x03" +
		"\x02\x02\x02\u09D8\xC3\x03\x02\x02\x02\u09D9\u09DA\t\x17\x02\x02\u09DA" +
		"\xC5\x03\x02\x02\x02\u09DB\u09DD\x07\x9E\x02\x02\u09DC\u09DB\x03\x02\x02" +
		"\x02\u09DC\u09DD\x03\x02\x02\x02\u09DD\u09DE\x03\x02\x02\x02\u09DE\u09E2" +
		"\x05\xE0q\x02\u09DF\u09E1\x05\xC8e\x02\u09E0\u09DF\x03\x02\x02\x02\u09E1" +
		"\u09E4\x03\x02\x02\x02\u09E2\u09E0\x03\x02\x02\x02\u09E2\u09E3\x03\x02" +
		"\x02\x02\u09E3\u09E7\x03\x02\x02\x02\u09E4\u09E2\x03\x02\x02\x02\u09E5" +
		"\u09E7\x05V,\x02\u09E6\u09DC\x03\x02\x02\x02\u09E6\u09E5\x03\x02\x02\x02" +
		"\u09E7\xC7\x03\x02\x02\x02\u09E8\u09EC\x05\xCAf\x02\u09E9\u09EC\x05\xA2" +
		"R\x02\u09EA\u09EC\x05\xA8U\x02\u09EB\u09E8\x03\x02\x02\x02\u09EB\u09E9" +
		"\x03\x02\x02\x02\u09EB\u09EA\x03\x02\x02\x02\u09EC\xC9\x03\x02\x02\x02" +
		"\u09ED\u09EE\x05\xCCg\x02\u09EE\u09F0\x07\x9B\x02\x02\u09EF\u09F1\x07" +
		"\x9E\x02\x02\u09F0\u09EF\x03\x02\x02\x02\u09F0\u09F1\x03\x02\x02\x02\u09F1" +
		"\u09F2\x03\x02\x02\x02\u09F2\u09F4\x05\xE0q\x02\u09F3\u09F5\x05\xCEh\x02" +
		"\u09F4\u09F3\x03\x02\x02\x02\u09F4\u09F5\x03\x02\x02\x02\u09F5\u09FF\x03" +
		"\x02\x02\x02\u09F6\u09F7\x07\xC0\x02\x02\u09F7\u09F8\x05\xCCg\x02\u09F8" +
		"\u09FA\x07\x9B\x02\x02\u09F9\u09FB\x07\x9E\x02\x02\u09FA\u09F9\x03\x02" +
		"\x02\x02\u09FA\u09FB\x03\x02\x02\x02\u09FB\u09FC\x03\x02\x02\x02\u09FC" +
		"\u09FD\x05\xE0q\x02\u09FD\u09FF\x03\x02\x02\x02\u09FE\u09ED\x03\x02\x02" +
		"\x02\u09FE\u09F6\x03\x02\x02\x02\u09FF\xCB\x03\x02\x02\x02\u0A00\u0A02" +
		"\x07\x90\x02\x02\u0A01\u0A00\x03\x02\x02\x02\u0A01\u0A02\x03\x02\x02\x02" +
		"\u0A02\u0A19\x03\x02\x02\x02\u0A03\u0A19\x07>\x02\x02\u0A04\u0A06\x07" +
		"\xA1\x02\x02\u0A05\u0A07\x07\xD0\x02\x02\u0A06\u0A05\x03\x02\x02\x02\u0A06" +
		"\u0A07\x03\x02\x02\x02\u0A07\u0A19\x03\x02\x02\x02\u0A08\u0A0A\x07\xA1" +
		"\x02\x02\u0A09\u0A08\x03\x02\x02\x02\u0A09\u0A0A\x03\x02\x02\x02\u0A0A" +
		"\u0A0B\x03\x02\x02\x02\u0A0B\u0A19\x07\u0104\x02\x02\u0A0C\u0A0E\x07\xF6" +
		"\x02\x02\u0A0D\u0A0F\x07\xD0\x02\x02\u0A0E\u0A0D\x03\x02\x02\x02\u0A0E" +
		"\u0A0F\x03\x02\x02\x02\u0A0F\u0A19\x03\x02\x02\x02\u0A10\u0A12\x07|\x02" +
		"\x02\u0A11\u0A13\x07\xD0\x02\x02\u0A12\u0A11\x03\x02\x02\x02\u0A12\u0A13" +
		"\x03\x02\x02\x02\u0A13\u0A19\x03\x02\x02\x02\u0A14\u0A16\x07\xA1\x02\x02" +
		"\u0A15\u0A14\x03\x02\x02\x02\u0A15\u0A16\x03\x02\x02\x02\u0A16\u0A17\x03" +
		"\x02\x02\x02\u0A17\u0A19\x07\x11\x02\x02\u0A18\u0A01\x03\x02\x02\x02\u0A18" +
		"\u0A03\x03\x02\x02\x02\u0A18\u0A04\x03\x02\x02\x02\u0A18\u0A09\x03\x02" +
		"\x02\x02\u0A18\u0A0C\x03\x02\x02\x02\u0A18\u0A10\x03\x02\x02\x02\u0A18" +
		"\u0A15\x03\x02\x02\x02\u0A19\xCD\x03\x02\x02\x02\u0A1A\u0A1B\x07\xC9\x02" +
		"\x02\u0A1B\u0A1F\x05\u0114\x8B\x02\u0A1C\u0A1D\x07\u0148\x02\x02\u0A1D" +
		"\u0A1F\x05\xD4k\x02\u0A1E\u0A1A\x03\x02\x02\x02\u0A1E\u0A1C\x03\x02\x02" +
		"\x02\u0A1F\xCF\x03\x02\x02\x02\u0A20\u0A21\x07\u0123\x02\x02\u0A21\u0A23" +
		"\x07\x04\x02\x02\u0A22\u0A24\x05\xD2j\x02\u0A23\u0A22\x03\x02\x02\x02" +
		"\u0A23\u0A24\x03\x02\x02\x02\u0A24\u0A25\x03\x02\x02\x02\u0A25\u0A2A\x07" +
		"\x05\x02\x02\u0A26\u0A27\x07\xF0\x02\x02\u0A27\u0A28\x07\x04\x02\x02\u0A28" +
		"\u0A29\x07\u0179\x02\x02\u0A29\u0A2B\x07\x05\x02\x02\u0A2A\u0A26\x03\x02" +
		"\x02\x02\u0A2A\u0A2B\x03\x02\x02\x02\u0A2B\xD1\x03\x02\x02\x02\u0A2C\u0A2E" +
		"\x07\u0165\x02\x02\u0A2D\u0A2C\x03\x02\x02\x02\u0A2D\u0A2E\x03\x02\x02" +
		"\x02\u0A2E\u0A2F\x03\x02\x02\x02\u0A2F\u0A30\t\x18\x02\x02\u0A30\u0A45" +
		"\x07\xDB\x02\x02\u0A31\u0A32\x05\u010C\x87\x02\u0A32\u0A33\x07\xFE\x02" +
		"\x02\u0A33\u0A45\x03\x02\x02\x02\u0A34\u0A35\x07\x1F\x02\x02\u0A35\u0A36" +
		"\x07\u0179\x02\x02\u0A36\u0A37\x07\xCF\x02\x02\u0A37\u0A38\x07\xC7\x02" +
		"\x02\u0A38\u0A41\x07\u0179\x02\x02\u0A39\u0A3F\x07\xC9\x02\x02\u0A3A\u0A40" +
		"\x05\u0176\xBC\x02\u0A3B\u0A3C\x05\u0170\xB9\x02\u0A3C\u0A3D\x07\x04\x02" +
		"\x02\u0A3D\u0A3E\x07\x05\x02\x02\u0A3E\u0A40\x03\x02\x02\x02\u0A3F\u0A3A" +
		"\x03\x02\x02\x02\u0A3F\u0A3B\x03\x02\x02\x02\u0A40\u0A42\x03\x02\x02\x02" +
		"\u0A41\u0A39\x03\x02\x02\x02\u0A41\u0A42\x03\x02\x02\x02\u0A42\u0A45\x03" +
		"\x02\x02\x02\u0A43\u0A45\x05\u010C\x87\x02\u0A44\u0A2D\x03\x02\x02\x02" +
		"\u0A44\u0A31\x03\x02\x02\x02\u0A44\u0A34\x03\x02\x02\x02\u0A44\u0A43\x03" +
		"\x02\x02\x02\u0A45\xD3\x03\x02\x02\x02\u0A46\u0A47\x07\x04\x02\x02\u0A47" +
		"\u0A48\x05\xD6l\x02\u0A48\u0A49\x07\x05\x02\x02\u0A49\xD5\x03\x02\x02" +
		"\x02\u0A4A\u0A4F\x05\u0172\xBA\x02\u0A4B\u0A4C\x07\x06\x02\x02\u0A4C\u0A4E" +
		"\x05\u0172\xBA\x02\u0A4D\u0A4B\x03\x02\x02\x02\u0A4E\u0A51\x03\x02\x02" +
		"\x02\u0A4F\u0A4D\x03\x02\x02\x02\u0A4F\u0A50\x03\x02\x02\x02\u0A50\xD7" +
		"\x03\x02\x02\x02\u0A51\u0A4F\x03\x02\x02\x02\u0A52\u0A53\x07\x04\x02\x02" +
		"\u0A53\u0A58\x05\xDAn\x02\u0A54\u0A55\x07\x06\x02\x02\u0A55\u0A57\x05" +
		"\xDAn\x02\u0A56\u0A54\x03\x02\x02\x02\u0A57\u0A5A\x03\x02\x02\x02\u0A58" +
		"\u0A56\x03\x02\x02\x02\u0A58\u0A59\x03\x02\x02\x02\u0A59\u0A5B\x03\x02" +
		"\x02\x02\u0A5A\u0A58\x03\x02\x02\x02\u0A5B\u0A5C\x07\x05\x02\x02\u0A5C" +
		"\xD9\x03\x02\x02\x02\u0A5D\u0A5F\x05\u0172\xBA\x02\u0A5E\u0A60\t\x10\x02" +
		"\x02\u0A5F\u0A5E\x03\x02\x02\x02\u0A5F\u0A60\x03\x02\x02\x02\u0A60\xDB" +
		"\x03\x02\x02\x02\u0A61\u0A62\x07\x04\x02\x02\u0A62\u0A67\x05\xDEp\x02" +
		"\u0A63\u0A64\x07\x06\x02\x02\u0A64\u0A66\x05\xDEp\x02\u0A65\u0A63\x03" +
		"\x02\x02\x02\u0A66\u0A69\x03\x02\x02\x02\u0A67\u0A65\x03\x02\x02\x02\u0A67" +
		"\u0A68\x03\x02\x02\x02\u0A68\u0A6A\x03\x02\x02\x02\u0A69\u0A67\x03\x02" +
		"\x02\x02\u0A6A\u0A6B\x07\x05\x02\x02\u0A6B\xDD\x03\x02\x02\x02\u0A6C\u0A6E" +
		"\x05\u0176\xBC\x02\u0A6D\u0A6F\x05\x1A\x0E\x02\u0A6E\u0A6D\x03\x02\x02" +
		"\x02\u0A6E\u0A6F\x03\x02\x02\x02\u0A6F\xDF\x03\x02\x02\x02\u0A70\u0A72" +
		"\x05b2\x02\u0A71\u0A73\x05\x96L\x02\u0A72\u0A71\x03\x02\x02\x02\u0A72" +
		"\u0A73\x03\x02\x02\x02\u0A73\u0A75\x03\x02\x02\x02\u0A74\u0A76\x05\xD0" +
		"i\x02\u0A75\u0A74\x03\x02\x02\x02\u0A75\u0A76\x03\x02\x02\x02\u0A76\u0A77" +
		"\x03\x02\x02\x02\u0A77\u0A78\x05\xF0y\x02\u0A78\u0A8C\x03\x02\x02\x02" +
		"\u0A79\u0A7A\x07\x04\x02\x02\u0A7A\u0A7B\x05\x1C\x0F\x02\u0A7B\u0A7D\x07" +
		"\x05\x02\x02\u0A7C\u0A7E\x05\xD0i\x02\u0A7D\u0A7C\x03\x02\x02\x02\u0A7D" +
		"\u0A7E\x03\x02\x02\x02\u0A7E\u0A7F\x03\x02\x02\x02\u0A7F\u0A80\x05\xF0" +
		"y\x02\u0A80\u0A8C\x03\x02\x02\x02\u0A81\u0A82\x07\x04\x02\x02\u0A82\u0A83" +
		"\x05\xC6d\x02\u0A83\u0A85\x07\x05\x02\x02\u0A84\u0A86\x05\xD0i\x02\u0A85" +
		"\u0A84\x03\x02\x02\x02\u0A85\u0A86\x03\x02\x02\x02\u0A86\u0A87\x03\x02" +
		"\x02\x02\u0A87\u0A88\x05\xF0y\x02\u0A88\u0A8C\x03\x02\x02\x02\u0A89\u0A8C" +
		"\x05\xE2r\x02\u0A8A\u0A8C\x05\xEEx\x02\u0A8B\u0A70\x03\x02\x02\x02\u0A8B" +
		"\u0A79\x03\x02\x02\x02\u0A8B\u0A81\x03\x02\x02\x02\u0A8B\u0A89\x03\x02" +
		"\x02\x02\u0A8B\u0A8A\x03\x02\x02\x02\u0A8C\xE1\x03\x02\x02\x02\u0A8D\u0A8E" +
		"\x07\u0149\x02\x02\u0A8E\u0A93\x05\u010C\x87\x02\u0A8F\u0A90\x07\x06\x02" +
		"\x02\u0A90\u0A92\x05\u010C\x87\x02\u0A91\u0A8F\x03\x02\x02\x02\u0A92\u0A95" +
		"\x03\x02\x02\x02\u0A93\u0A91\x03\x02\x02\x02\u0A93\u0A94\x03\x02\x02\x02" +
		"\u0A94\u0A96\x03\x02\x02\x02\u0A95\u0A93\x03\x02\x02\x02\u0A96\u0A97\x05" +
		"\xF0y\x02\u0A97\xE3\x03\x02\x02\x02\u0A98\u0A99\x07\u0121\x02\x02\u0A99" +
		"\u0A9B\x05V,\x02\u0A9A\u0A9C\x05\xE6t\x02\u0A9B\u0A9A\x03\x02\x02\x02" +
		"\u0A9B\u0A9C\x03\x02\x02\x02\u0A9C\u0AAC\x03\x02\x02\x02\u0A9D\u0A9E\x07" +
		"\u0121\x02\x02\u0A9E\u0A9F\x07\x04\x02\x02\u0A9F\u0AA0\x05V,\x02\u0AA0" +
		"\u0AA2\x07\x05\x02\x02\u0AA1\u0AA3\x05\xE6t\x02\u0AA2\u0AA1\x03\x02\x02" +
		"\x02\u0AA2\u0AA3\x03\x02\x02\x02\u0AA3\u0AAC\x03\x02\x02\x02\u0AA4\u0AA5" +
		"\x07\u0121\x02\x02\u0AA5\u0AA6\x07\x04\x02\x02\u0AA6\u0AA7\x05\x1C\x0F" +
		"\x02\u0AA7\u0AA9\x07\x05\x02\x02\u0AA8\u0AAA\x05\xE6t\x02\u0AA9\u0AA8" +
		"\x03\x02\x02\x02\u0AA9\u0AAA\x03\x02\x02\x02\u0AAA\u0AAC\x03\x02\x02\x02" +
		"\u0AAB\u0A98\x03\x02\x02\x02\u0AAB\u0A9D\x03\x02\x02\x02\u0AAB\u0AA4\x03" +
		"\x02\x02\x02\u0AAC\xE5\x03\x02\x02\x02\u0AAD\u0AAE\x07\u0156\x02\x02\u0AAE" +
		"\u0AAF\x07\u010E\x02\x02\u0AAF\u0AC1\x07\xD6\x02\x02\u0AB0\u0AB1\t\x19" +
		"\x02\x02\u0AB1\u0ABE\x07!\x02\x02\u0AB2\u0AB3\x07\x04\x02\x02\u0AB3\u0AB8" +
		"\x05\u010C\x87\x02\u0AB4\u0AB5\x07\x06\x02\x02\u0AB5\u0AB7\x05\u010C\x87" +
		"\x02\u0AB6\u0AB4\x03\x02\x02\x02\u0AB7\u0ABA\x03\x02\x02\x02\u0AB8\u0AB6" +
		"\x03\x02\x02\x02\u0AB8\u0AB9\x03\x02\x02\x02\u0AB9\u0ABB\x03\x02\x02\x02" +
		"\u0ABA\u0AB8\x03\x02\x02\x02\u0ABB\u0ABC\x07\x05\x02\x02\u0ABC\u0ABF\x03" +
		"\x02\x02\x02\u0ABD\u0ABF\x05\u010C\x87\x02\u0ABE\u0AB2\x03\x02\x02\x02" +
		"\u0ABE\u0ABD\x03\x02\x02\x02\u0ABF\u0AC1\x03\x02\x02\x02\u0AC0\u0AAD\x03" +
		"\x02\x02\x02\u0AC0\u0AB0\x03\x02\x02\x02\u0AC1\u0AD2\x03\x02\x02\x02\u0AC2" +
		"\u0AC3\t\x1A\x02\x02\u0AC3\u0AD0\x07!\x02\x02\u0AC4\u0AC5\x07\x04\x02" +
		"\x02\u0AC5\u0ACA\x05l7\x02\u0AC6\u0AC7\x07\x06\x02\x02\u0AC7\u0AC9\x05" +
		"l7\x02\u0AC8\u0AC6\x03\x02\x02\x02\u0AC9\u0ACC\x03\x02\x02\x02\u0ACA\u0AC8" +
		"\x03\x02\x02\x02\u0ACA\u0ACB\x03\x02\x02\x02\u0ACB\u0ACD\x03\x02\x02\x02" +
		"\u0ACC\u0ACA\x03\x02\x02\x02\u0ACD\u0ACE\x07\x05\x02\x02\u0ACE\u0AD1\x03" +
		"\x02\x02\x02\u0ACF\u0AD1\x05l7\x02\u0AD0\u0AC4\x03\x02\x02\x02\u0AD0\u0ACF" +
		"\x03\x02\x02\x02\u0AD1\u0AD3\x03\x02\x02\x02\u0AD2\u0AC2\x03\x02\x02\x02" +
		"\u0AD2\u0AD3\x03\x02\x02\x02\u0AD3\xE7\x03\x02\x02\x02\u0AD4\u0AD5\x05" +
		"\u0176\xBC\x02\u0AD5\u0AD6\x07\u0170\x02\x02\u0AD6\u0AD7\x05\xE4s\x02" +
		"\u0AD7\xE9\x03\x02\x02\x02\u0AD8\u0ADB\x05\xE4s\x02\u0AD9\u0ADB\x05\xE8" +
		"u\x02\u0ADA\u0AD8\x03\x02\x02\x02\u0ADA\u0AD9\x03\x02\x02\x02\u0ADB\xEB" +
		"\x03\x02\x02\x02\u0ADC\u0ADF\x05\xEAv\x02\u0ADD\u0ADF\x05\u0110\x89\x02" +
		"\u0ADE\u0ADC\x03\x02\x02\x02\u0ADE\u0ADD\x03\x02\x02\x02\u0ADF\xED\x03" +
		"\x02\x02\x02\u0AE0\u0AE1\x05\u016C\xB7\x02\u0AE1\u0AEA\x07\x04\x02\x02" +
		"\u0AE2\u0AE7\x05\xECw\x02\u0AE3\u0AE4\x07\x06\x02\x02\u0AE4\u0AE6\x05" +
		"\xECw\x02\u0AE5\u0AE3\x03\x02\x02\x02\u0AE6\u0AE9\x03\x02\x02\x02\u0AE7" +
		"\u0AE5\x03\x02\x02\x02\u0AE7\u0AE8\x03\x02\x02\x02\u0AE8\u0AEB\x03\x02" +
		"\x02\x02\u0AE9\u0AE7\x03\x02\x02\x02\u0AEA\u0AE2\x03\x02\x02\x02\u0AEA" +
		"\u0AEB\x03\x02\x02\x02\u0AEB\u0AEC\x03\x02\x02\x02\u0AEC\u0AED\x07\x05" +
		"\x02\x02\u0AED\u0AEE\x05\xF0y\x02\u0AEE\xEF\x03\x02\x02\x02\u0AEF\u0AF1" +
		"\x07\x16\x02\x02\u0AF0\u0AEF\x03\x02\x02\x02\u0AF0\u0AF1\x03\x02\x02\x02" +
		"\u0AF1\u0AF2\x03\x02\x02\x02\u0AF2\u0AF4\x05\u0178\xBD\x02\u0AF3\u0AF5" +
		"\x05\xD4k\x02\u0AF4\u0AF3\x03\x02\x02\x02\u0AF4\u0AF5\x03\x02\x02\x02" +
		"\u0AF5\u0AF7\x03\x02\x02\x02\u0AF6\u0AF0\x03\x02\x02\x02\u0AF6\u0AF7\x03" +
		"\x02\x02\x02\u0AF7\xF1\x03\x02\x02\x02\u0AF8\u0AF9\x07\xFD\x02\x02\u0AF9" +
		"\u0AFA\x07y\x02\x02\u0AFA\u0AFB\x07\u0106\x02\x02\u0AFB\u0AFF\x05\u0182" +
		"\xC2\x02\u0AFC\u0AFD\x07\u0156\x02\x02\u0AFD\u0AFE\x07\u0107\x02\x02\u0AFE" +
		"\u0B00\x056\x1C\x02\u0AFF\u0AFC\x03\x02\x02\x02\u0AFF\u0B00\x03\x02\x02" +
		"\x02\u0B00\u0B2A\x03\x02\x02\x02\u0B01\u0B02\x07\xFD\x02\x02\u0B02\u0B03" +
		"\x07y\x02\x02\u0B03\u0B0D\x07W\x02\x02\u0B04\u0B05\x07q\x02\x02\u0B05" +
		"\u0B06\x07\u0127\x02\x02\u0B06\u0B07\x07!\x02\x02\u0B07\u0B0B\x05\u0182" +
		"\xC2\x02\u0B08\u0B09\x07e\x02\x02\u0B09\u0B0A\x07!\x02\x02\u0B0A\u0B0C" +
		"\x05\u0182\xC2\x02\u0B0B\u0B08\x03\x02\x02\x02\u0B0B\u0B0C\x03\x02\x02" +
		"\x02\u0B0C\u0B0E\x03\x02\x02\x02\u0B0D\u0B04\x03\x02\x02\x02\u0B0D\u0B0E" +
		"\x03\x02\x02\x02\u0B0E\u0B14\x03\x02\x02\x02\u0B0F\u0B10\x072\x02\x02" +
		"\u0B10\u0B11\x07\x9A\x02\x02\u0B11\u0B12\x07\u0127\x02\x02\u0B12\u0B13" +
		"\x07!\x02\x02\u0B13\u0B15\x05\u0182\xC2\x02\u0B14\u0B0F\x03\x02\x02\x02" +
		"\u0B14\u0B15\x03\x02\x02\x02\u0B15\u0B1B\x03\x02\x02\x02\u0B16\u0B17\x07" +
		"\xAF\x02\x02\u0B17\u0B18\x07\x9C\x02\x02\u0B18\u0B19\x07\u0127\x02\x02" +
		"\u0B19\u0B1A\x07!\x02\x02\u0B1A\u0B1C\x05\u0182\xC2\x02\u0B1B\u0B16\x03" +
		"\x02\x02\x02\u0B1B\u0B1C\x03\x02\x02\x02\u0B1C\u0B21\x03\x02\x02\x02\u0B1D" +
		"\u0B1E\x07\xA5\x02\x02\u0B1E\u0B1F\x07\u0127\x02\x02\u0B1F\u0B20\x07!" +
		"\x02\x02\u0B20\u0B22\x05\u0182\xC2\x02\u0B21\u0B1D\x03\x02\x02\x02\u0B21" +
		"\u0B22\x03\x02\x02\x02\u0B22\u0B27\x03\x02\x02\x02\u0B23\u0B24\x07\xC4" +
		"\x02\x02\u0B24\u0B25\x07U\x02\x02\u0B25\u0B26\x07\x16\x02\x02\u0B26\u0B28" +
		"\x05\u0182\xC2\x02\u0B27\u0B23\x03\x02\x02\x02\u0B27\u0B28\x03\x02\x02" +
		"\x02\u0B28\u0B2A\x03\x02\x02\x02\u0B29\u0AF8\x03\x02\x02\x02\u0B29\u0B01" +
		"\x03\x02\x02\x02\u0B2A\xF3\x03\x02\x02\x02\u0B2B\u0B30\x05\xF6|\x02\u0B2C" +
		"\u0B2D\x07\x06\x02\x02\u0B2D\u0B2F\x05\xF6|\x02\u0B2E\u0B2C\x03\x02\x02" +
		"\x02\u0B2F\u0B32\x03\x02\x02\x02\u0B30\u0B2E\x03\x02\x02\x02\u0B30\u0B31" +
		"\x03\x02\x02\x02\u0B31\xF5\x03\x02\x02\x02\u0B32\u0B30\x03\x02\x02\x02" +
		"\u0B33\u0B38\x05\u0172\xBA\x02\u0B34\u0B35\x07\x07\x02\x02\u0B35\u0B37" +
		"\x05\u0172\xBA\x02\u0B36\u0B34\x03\x02\x02\x02\u0B37\u0B3A\x03\x02\x02" +
		"\x02\u0B38\u0B36\x03\x02\x02\x02\u0B38\u0B39\x03\x02\x02\x02\u0B39\xF7" +
		"\x03\x02\x02\x02\u0B3A\u0B38\x03\x02\x02\x02\u0B3B\u0B40\x05\xFA~\x02" +
		"\u0B3C\u0B3D\x07\x06\x02\x02\u0B3D\u0B3F\x05\xFA~\x02\u0B3E\u0B3C\x03" +
		"\x02\x02\x02\u0B3F\u0B42\x03\x02\x02\x02\u0B40\u0B3E\x03\x02\x02\x02\u0B40" +
		"\u0B41\x03\x02\x02\x02\u0B41\xF9\x03\x02\x02\x02\u0B42\u0B40\x03\x02\x02" +
		"\x02\u0B43\u0B46\x05\xF6|\x02\u0B44\u0B45\x07\xCC\x02\x02\u0B45\u0B47" +
		"\x056\x1C\x02\u0B46\u0B44\x03\x02\x02\x02\u0B46\u0B47\x03\x02\x02\x02" +
		"\u0B47\xFB\x03\x02\x02\x02\u0B48\u0B49\x05\u0172\xBA\x02\u0B49\u0B4A\x07" +
		"\x07\x02\x02\u0B4A\u0B4C\x03\x02\x02\x02\u0B4B\u0B48\x03\x02\x02\x02\u0B4B" +
		"\u0B4C\x03\x02\x02\x02\u0B4C\u0B4D\x03\x02\x02\x02\u0B4D\u0B4E\x05\u0172" +
		"\xBA\x02\u0B4E\xFD\x03\x02\x02\x02\u0B4F\u0B50\x05\u0172\xBA\x02\u0B50" +
		"\u0B51\x07\x07\x02\x02\u0B51\u0B53\x03\x02\x02\x02\u0B52\u0B4F\x03\x02" +
		"\x02\x02\u0B52\u0B53\x03\x02\x02\x02\u0B53\u0B54\x03\x02\x02\x02\u0B54" +
		"\u0B55\x05\u0172\xBA\x02\u0B55\xFF\x03\x02\x02\x02\u0B56\u0B59\x05\\/" +
		"\x02\u0B57\u0B59\x05\u010C\x87\x02\u0B58\u0B56\x03\x02\x02\x02\u0B58\u0B57" +
		"\x03\x02\x02\x02\u0B59\u0B61\x03\x02\x02\x02\u0B5A\u0B5C\x07\x16\x02\x02" +
		"\u0B5B\u0B5A\x03\x02\x02\x02\u0B5B\u0B5C\x03\x02\x02\x02\u0B5C\u0B5F\x03" +
		"\x02\x02\x02\u0B5D\u0B60\x05\u0172\xBA\x02\u0B5E\u0B60\x05\xD4k\x02\u0B5F" +
		"\u0B5D\x03\x02\x02\x02\u0B5F\u0B5E\x03\x02\x02\x02\u0B60\u0B62\x03\x02" +
		"\x02\x02\u0B61\u0B5B\x03\x02\x02\x02\u0B61\u0B62\x03\x02\x02\x02\u0B62" +
		"\u0101\x03\x02\x02\x02\u0B63\u0B68\x05\u0100\x81\x02\u0B64\u0B65\x07\x06" +
		"\x02\x02\u0B65\u0B67\x05\u0100\x81\x02\u0B66\u0B64\x03\x02\x02\x02\u0B67" +
		"\u0B6A\x03\x02\x02\x02\u0B68\u0B66\x03\x02\x02\x02\u0B68\u0B69\x03\x02" +
		"\x02\x02\u0B69\u0103\x03\x02\x02\x02\u0B6A\u0B68\x03\x02\x02\x02\u0B6B" +
		"\u0B6C\x07\x04\x02\x02\u0B6C\u0B71\x05\u0106\x84\x02\u0B6D\u0B6E\x07\x06" +
		"\x02\x02\u0B6E\u0B70\x05\u0106\x84\x02\u0B6F\u0B6D\x03\x02\x02\x02\u0B70" +
		"\u0B73\x03\x02\x02\x02\u0B71\u0B6F\x03\x02\x02\x02\u0B71\u0B72\x03\x02" +
		"\x02\x02\u0B72\u0B74\x03\x02\x02\x02\u0B73\u0B71\x03\x02\x02\x02\u0B74" +
		"\u0B75\x07\x05\x02\x02\u0B75\u0105\x03\x02\x02\x02\u0B76\u0B79\x05\u0108" +
		"\x85\x02\u0B77\u0B79\x05\u0150\xA9\x02\u0B78\u0B76\x03\x02\x02\x02\u0B78" +
		"\u0B77\x03\x02\x02\x02\u0B79\u0107\x03\x02\x02\x02\u0B7A\u0B88\x05\u0170" +
		"\xB9\x02\u0B7B\u0B7C\x05\u0176\xBC\x02\u0B7C\u0B7D\x07\x04\x02\x02\u0B7D" +
		"\u0B82\x05\u010A\x86\x02\u0B7E\u0B7F\x07\x06\x02\x02\u0B7F\u0B81\x05\u010A" +
		"\x86\x02\u0B80\u0B7E\x03\x02\x02\x02\u0B81\u0B84\x03\x02\x02\x02\u0B82" +
		"\u0B80\x03\x02\x02\x02\u0B82\u0B83\x03\x02\x02\x02\u0B83\u0B85\x03\x02" +
		"\x02\x02\u0B84\u0B82\x03\x02\x02\x02\u0B85\u0B86\x07\x05\x02\x02\u0B86" +
		"\u0B88\x03\x02\x02\x02\u0B87\u0B7A\x03\x02\x02\x02\u0B87\u0B7B\x03\x02" +
		"\x02\x02\u0B88\u0109\x03\x02\x02\x02\u0B89\u0B8C\x05\u0170\xB9\x02\u0B8A" +
		"\u0B8C\x05\u0120\x91\x02\u0B8B\u0B89\x03\x02\x02\x02\u0B8B\u0B8A\x03\x02" +
		"\x02\x02\u0B8C\u010B\x03\x02\x02\x02\u0B8D\u0B8E\x05\u0114\x8B\x02\u0B8E" +
		"\u010D\x03\x02\x02\x02\u0B8F\u0B90\x05\u0176\xBC\x02\u0B90\u0B91\x07\u0170" +
		"\x02\x02\u0B91\u0B92\x05\u010C\x87\x02\u0B92\u010F\x03\x02\x02\x02\u0B93" +
		"\u0B96\x05\u010C\x87\x02\u0B94\u0B96\x05\u010E\x88\x02\u0B95\u0B93\x03" +
		"\x02\x02\x02\u0B95\u0B94\x03\x02\x02\x02\u0B96\u0111\x03\x02\x02\x02\u0B97" +
		"\u0B9C\x05\u010C\x87\x02\u0B98\u0B99\x07\x06\x02\x02\u0B99\u0B9B\x05\u010C" +
		"\x87\x02\u0B9A\u0B98\x03\x02\x02\x02\u0B9B\u0B9E\x03\x02\x02\x02\u0B9C" +
		"\u0B9A\x03\x02\x02\x02\u0B9C\u0B9D\x03\x02\x02\x02\u0B9D\u0113\x03\x02" +
		"\x02\x02\u0B9E\u0B9C\x03\x02\x02\x02\u0B9F\u0BA0\b\x8B\x01\x02\u0BA0\u0BA1" +
		"\t\x1B\x02\x02\u0BA1\u0BAC\x05\u0114\x8B\x07\u0BA2\u0BA3\x07i\x02\x02" +
		"\u0BA3\u0BA4\x07\x04\x02\x02\u0BA4\u0BA5\x05\x1C\x0F\x02\u0BA5\u0BA6\x07" +
		"\x05\x02\x02\u0BA6\u0BAC\x03\x02\x02\x02\u0BA7\u0BA9\x05\u0118\x8D\x02" +
		"\u0BA8\u0BAA\x05\u0116\x8C\x02\u0BA9\u0BA8\x03\x02\x02\x02\u0BA9\u0BAA" +
		"\x03\x02\x02\x02\u0BAA\u0BAC\x03\x02\x02\x02\u0BAB\u0B9F\x03\x02\x02\x02" +
		"\u0BAB\u0BA2\x03\x02\x02\x02\u0BAB\u0BA7\x03\x02\x02\x02\u0BAC\u0BB5\x03" +
		"\x02\x02\x02\u0BAD\u0BAE\f\x04\x02\x02\u0BAE\u0BAF\x07\x10\x02\x02\u0BAF" +
		"\u0BB4\x05\u0114\x8B\x05\u0BB0\u0BB1\f\x03\x02\x02\u0BB1\u0BB2\x07\xCD" +
		"\x02\x02\u0BB2\u0BB4\x05\u0114\x8B\x04\u0BB3\u0BAD\x03\x02\x02\x02\u0BB3" +
		"\u0BB0\x03\x02\x02\x02\u0BB4\u0BB7\x03\x02\x02\x02\u0BB5\u0BB3\x03\x02" +
		"\x02\x02\u0BB5\u0BB6\x03\x02\x02\x02\u0BB6\u0115\x03\x02\x02\x02\u0BB7" +
		"\u0BB5\x03\x02\x02\x02\u0BB8\u0BBA\x07\xC3\x02\x02\u0BB9\u0BB8\x03\x02" +
		"\x02\x02\u0BB9\u0BBA\x03\x02\x02\x02\u0BBA\u0BBB\x03\x02\x02\x02\u0BBB" +
		"\u0BBC\x07\x1A\x02\x02\u0BBC\u0BBD\x05\u0118\x8D\x02\u0BBD\u0BBE\x07\x10" +
		"\x02\x02\u0BBE\u0BBF\x05\u0118\x8D\x02\u0BBF\u0C0B\x03\x02\x02\x02\u0BC0" +
		"\u0BC2\x07\xC3\x02\x02\u0BC1\u0BC0\x03\x02\x02\x02\u0BC1\u0BC2\x03\x02" +
		"\x02\x02\u0BC2\u0BC3\x03\x02\x02\x02\u0BC3\u0BC4\x07\x8C\x02\x02\u0BC4" +
		"\u0BC5\x07\x04\x02\x02\u0BC5\u0BCA\x05\u010C\x87\x02\u0BC6\u0BC7\x07\x06" +
		"\x02\x02\u0BC7\u0BC9\x05\u010C\x87\x02\u0BC8\u0BC6\x03\x02\x02\x02\u0BC9" +
		"\u0BCC\x03\x02\x02\x02\u0BCA\u0BC8\x03\x02\x02\x02\u0BCA\u0BCB\x03\x02" +
		"\x02\x02\u0BCB\u0BCD\x03\x02\x02\x02\u0BCC\u0BCA\x03\x02\x02\x02\u0BCD" +
		"\u0BCE\x07\x05\x02\x02\u0BCE\u0C0B\x03\x02\x02\x02\u0BCF\u0BD1\x07\xC3" +
		"\x02\x02\u0BD0\u0BCF\x03\x02\x02\x02\u0BD0\u0BD1\x03\x02\x02\x02\u0BD1" +
		"\u0BD2\x03\x02\x02\x02\u0BD2\u0BD3\x07\x8C\x02\x02\u0BD3\u0BD4\x07\x04" +
		"\x02\x02\u0BD4\u0BD5\x05\x1C\x0F\x02\u0BD5\u0BD6\x07\x05\x02\x02\u0BD6" +
		"\u0C0B\x03\x02\x02\x02\u0BD7\u0BD9\x07\xC3\x02\x02\u0BD8\u0BD7\x03\x02" +
		"\x02\x02\u0BD8\u0BD9\x03\x02\x02\x02\u0BD9\u0BDA\x03\x02\x02\x02\u0BDA" +
		"\u0BDB\t\x1C\x02\x02\u0BDB\u0C0B\x05\u0118\x8D\x02\u0BDC\u0BDE\x07\xC3" +
		"\x02\x02\u0BDD\u0BDC\x03\x02\x02\x02\u0BDD\u0BDE\x03\x02\x02\x02\u0BDE" +
		"\u0BDF\x03\x02\x02\x02\u0BDF\u0BE0\t\x1D\x02\x02\u0BE0\u0BEE\t\x1E\x02" +
		"\x02\u0BE1\u0BE2\x07\x04\x02\x02\u0BE2\u0BEF\x07\x05\x02\x02\u0BE3\u0BE4" +
		"\x07\x04\x02\x02\u0BE4\u0BE9\x05\u010C\x87\x02\u0BE5\u0BE6\x07\x06\x02" +
		"\x02\u0BE6\u0BE8\x05\u010C\x87\x02\u0BE7\u0BE5\x03\x02\x02\x02\u0BE8\u0BEB" +
		"\x03\x02\x02\x02\u0BE9\u0BE7\x03\x02\x02\x02\u0BE9\u0BEA\x03\x02\x02\x02" +
		"\u0BEA\u0BEC\x03\x02\x02\x02\u0BEB\u0BE9\x03\x02\x02\x02\u0BEC\u0BED\x07" +
		"\x05\x02\x02\u0BED\u0BEF\x03\x02\x02\x02\u0BEE\u0BE1\x03\x02\x02\x02\u0BEE" +
		"\u0BE3\x03\x02\x02\x02\u0BEF\u0C0B\x03\x02\x02\x02\u0BF0\u0BF2\x07\xC3" +
		"\x02\x02\u0BF1\u0BF0\x03\x02\x02\x02\u0BF1\u0BF2\x03\x02\x02\x02\u0BF2" +
		"\u0BF3\x03\x02\x02\x02\u0BF3\u0BF4\t\x1D\x02\x02\u0BF4\u0BF7\x05\u0118" +
		"\x8D\x02\u0BF5\u0BF6\x07";
	private static readonly _serializedATNSegment6: string =
		"d\x02\x02\u0BF6\u0BF8\x05\u0182\xC2\x02\u0BF7\u0BF5\x03\x02\x02\x02\u0BF7" +
		"\u0BF8\x03\x02\x02\x02\u0BF8\u0C0B\x03\x02\x02\x02\u0BF9\u0BFB\x07\x99" +
		"\x02\x02\u0BFA\u0BFC\x07\xC3\x02\x02\u0BFB\u0BFA\x03\x02\x02\x02\u0BFB" +
		"\u0BFC\x03\x02\x02\x02\u0BFC\u0BFD\x03\x02\x02\x02\u0BFD\u0C0B\x07\xC4" +
		"\x02\x02\u0BFE\u0C00\x07\x99\x02\x02\u0BFF\u0C01\x07\xC3\x02\x02\u0C00" +
		"\u0BFF\x03\x02\x02\x02\u0C00\u0C01\x03\x02\x02\x02\u0C01\u0C02\x03\x02" +
		"\x02\x02\u0C02\u0C0B\t\x1F\x02\x02\u0C03\u0C05\x07\x99\x02\x02\u0C04\u0C06" +
		"\x07\xC3\x02\x02\u0C05\u0C04\x03\x02\x02\x02\u0C05\u0C06\x03\x02\x02\x02" +
		"\u0C06\u0C07\x03\x02\x02\x02\u0C07\u0C08\x07]\x02\x02\u0C08\u0C09\x07" +
		"{\x02\x02\u0C09\u0C0B\x05\u0118\x8D\x02\u0C0A\u0BB9\x03\x02\x02\x02\u0C0A" +
		"\u0BC1\x03\x02\x02\x02\u0C0A\u0BD0\x03\x02\x02\x02\u0C0A\u0BD8\x03\x02" +
		"\x02\x02\u0C0A\u0BDD\x03\x02\x02\x02\u0C0A\u0BF1\x03\x02\x02\x02\u0C0A" +
		"\u0BF9\x03\x02\x02\x02\u0C0A\u0BFE\x03\x02\x02\x02\u0C0A\u0C03\x03\x02" +
		"\x02\x02\u0C0B\u0117\x03\x02\x02\x02\u0C0C\u0C0D\b\x8D\x01\x02\u0C0D\u0C11" +
		"\x05\u011C\x8F\x02\u0C0E\u0C0F\t \x02\x02\u0C0F\u0C11\x05\u0118\x8D\t" +
		"\u0C10\u0C0C\x03\x02\x02\x02\u0C10\u0C0E\x03\x02\x02\x02\u0C11\u0C27\x03" +
		"\x02\x02\x02\u0C12\u0C13\f\b\x02\x02\u0C13\u0C14\t!\x02\x02\u0C14\u0C26" +
		"\x05\u0118\x8D\t\u0C15\u0C16\f\x07\x02\x02\u0C16\u0C17\t\"\x02\x02\u0C17" +
		"\u0C26\x05\u0118\x8D\b\u0C18\u0C19\f\x06\x02\x02\u0C19\u0C1A\x07\u016A" +
		"\x02\x02\u0C1A\u0C26\x05\u0118\x8D\x07\u0C1B\u0C1C\f\x05\x02\x02\u0C1C" +
		"\u0C1D\x07\u016D\x02\x02\u0C1D\u0C26\x05\u0118\x8D\x06\u0C1E\u0C1F\f\x04" +
		"\x02\x02\u0C1F\u0C20\x07\u016B\x02\x02\u0C20\u0C26\x05\u0118\x8D\x05\u0C21" +
		"\u0C22\f\x03\x02\x02\u0C22\u0C23\x05\u0122\x92\x02\u0C23\u0C24\x05\u0118" +
		"\x8D\x04\u0C24\u0C26\x03\x02\x02\x02\u0C25\u0C12\x03\x02\x02\x02\u0C25" +
		"\u0C15\x03\x02\x02\x02\u0C25\u0C18\x03\x02\x02\x02\u0C25\u0C1B\x03\x02" +
		"\x02\x02\u0C25\u0C1E\x03\x02\x02\x02\u0C25\u0C21\x03\x02\x02\x02\u0C26" +
		"\u0C29\x03\x02\x02\x02\u0C27\u0C25\x03\x02\x02\x02\u0C27\u0C28\x03\x02" +
		"\x02\x02\u0C28\u0119\x03\x02\x02\x02\u0C29\u0C27\x03\x02\x02\x02\u0C2A" +
		"\u0C2B\t#\x02\x02\u0C2B\u011B\x03\x02\x02\x02\u0C2C\u0C2D\b\x8F\x01\x02" +
		"\u0C2D\u0D26\t$\x02\x02\u0C2E\u0C2F\t%\x02\x02\u0C2F\u0C32\x07\x04\x02" +
		"\x02\u0C30\u0C33\x05\u011A\x8E\x02\u0C31\u0C33\x05\u0182\xC2\x02\u0C32" +
		"\u0C30\x03\x02\x02\x02\u0C32\u0C31\x03\x02\x02\x02\u0C33\u0C34\x03\x02" +
		"\x02\x02\u0C34\u0C35\x07\x06\x02\x02\u0C35\u0C36\x05\u0118\x8D\x02\u0C36" +
		"\u0C37\x07\x06\x02\x02\u0C37\u0C38\x05\u0118\x8D\x02\u0C38\u0C39\x07\x05" +
		"\x02\x02\u0C39\u0D26\x03\x02\x02\x02\u0C3A\u0C3B\t&\x02\x02\u0C3B\u0C3E" +
		"\x07\x04\x02\x02\u0C3C\u0C3F\x05\u011A\x8E\x02\u0C3D\u0C3F\x05\u0182\xC2" +
		"\x02\u0C3E\u0C3C\x03\x02\x02\x02\u0C3E\u0C3D\x03\x02\x02\x02\u0C3F\u0C40" +
		"\x03\x02\x02\x02\u0C40\u0C41\x07\x06\x02\x02\u0C41\u0C42\x05\u0118\x8D" +
		"\x02\u0C42\u0C43\x07\x06\x02\x02\u0C43\u0C44\x05\u0118\x8D\x02\u0C44\u0C45" +
		"\x07\x05\x02\x02\u0C45\u0D26\x03\x02\x02\x02\u0C46\u0C48\x07%\x02\x02" +
		"\u0C47\u0C49\x05\u015E\xB0\x02\u0C48\u0C47\x03\x02\x02\x02\u0C49\u0C4A" +
		"\x03\x02\x02\x02\u0C4A\u0C48\x03\x02\x02\x02\u0C4A\u0C4B\x03\x02\x02\x02" +
		"\u0C4B\u0C4E\x03\x02\x02\x02\u0C4C\u0C4D\x07b\x02\x02\u0C4D\u0C4F\x05" +
		"\u010C\x87\x02\u0C4E\u0C4C\x03\x02\x02\x02\u0C4E\u0C4F\x03\x02\x02\x02" +
		"\u0C4F\u0C50\x03\x02\x02\x02\u0C50\u0C51\x07c\x02\x02\u0C51\u0D26\x03" +
		"\x02\x02\x02\u0C52\u0C53\x07%\x02\x02\u0C53\u0C55\x05\u010C\x87\x02\u0C54" +
		"\u0C56\x05\u015E\xB0\x02\u0C55\u0C54\x03\x02\x02\x02\u0C56\u0C57\x03\x02" +
		"\x02\x02\u0C57\u0C55\x03\x02\x02\x02\u0C57\u0C58\x03\x02\x02\x02\u0C58" +
		"\u0C5B\x03\x02\x02\x02\u0C59\u0C5A\x07b\x02\x02\u0C5A\u0C5C\x05\u010C" +
		"\x87\x02\u0C5B\u0C59\x03\x02\x02\x02\u0C5B\u0C5C\x03\x02\x02\x02\u0C5C" +
		"\u0C5D\x03\x02\x02\x02\u0C5D\u0C5E\x07c\x02\x02\u0C5E\u0D26\x03\x02\x02" +
		"\x02\u0C5F\u0C60\t\'\x02\x02\u0C60\u0C61\x07\x04\x02\x02\u0C61\u0C62\x05" +
		"\u010C\x87\x02\u0C62\u0C63\x07\x16\x02\x02\u0C63\u0C64\x05\u013E\xA0\x02" +
		"\u0C64\u0C65\x07\x05\x02\x02\u0C65\u0D26\x03\x02\x02\x02\u0C66\u0C67\x07" +
		"\u011A\x02\x02\u0C67\u0C70\x07\x04\x02\x02\u0C68\u0C6D\x05\u0100\x81\x02" +
		"\u0C69\u0C6A\x07\x06\x02\x02\u0C6A\u0C6C\x05\u0100\x81\x02\u0C6B\u0C69" +
		"\x03\x02\x02\x02\u0C6C\u0C6F\x03\x02\x02\x02\u0C6D\u0C6B\x03\x02\x02\x02" +
		"\u0C6D\u0C6E\x03\x02\x02\x02\u0C6E\u0C71\x03\x02\x02\x02\u0C6F\u0C6D\x03" +
		"\x02\x02\x02\u0C70\u0C68\x03\x02\x02\x02\u0C70\u0C71\x03\x02\x02\x02\u0C71" +
		"\u0C72\x03\x02\x02\x02\u0C72\u0D26\x07\x05\x02\x02\u0C73\u0C74\x07t\x02" +
		"\x02\u0C74\u0C75\x07\x04\x02\x02\u0C75\u0C78\x05\u010C\x87\x02\u0C76\u0C77" +
		"\x07\x8A\x02\x02\u0C77\u0C79\x07\xC5\x02\x02\u0C78\u0C76\x03\x02\x02\x02" +
		"\u0C78\u0C79\x03\x02\x02\x02\u0C79\u0C7A\x03\x02\x02\x02\u0C7A\u0C7B\x07" +
		"\x05\x02\x02\u0C7B\u0D26\x03\x02\x02\x02\u0C7C\u0C7D\x07\x13\x02\x02\u0C7D" +
		"\u0C7E\x07\x04\x02\x02\u0C7E\u0C81\x05\u010C\x87\x02\u0C7F\u0C80\x07\x8A" +
		"\x02\x02\u0C80\u0C82\x07\xC5\x02\x02\u0C81\u0C7F\x03\x02\x02\x02\u0C81" +
		"\u0C82\x03\x02\x02\x02\u0C82\u0C83\x03\x02\x02\x02\u0C83\u0C84\x07\x05" +
		"\x02\x02\u0C84\u0D26\x03\x02\x02\x02\u0C85\u0C86\x07\x9D\x02\x02\u0C86" +
		"\u0C87\x07\x04\x02\x02\u0C87\u0C8A\x05\u010C\x87\x02\u0C88\u0C89\x07\x8A" +
		"\x02\x02\u0C89\u0C8B\x07\xC5\x02\x02\u0C8A\u0C88\x03\x02\x02\x02\u0C8A" +
		"\u0C8B\x03\x02\x02\x02\u0C8B\u0C8C\x03\x02\x02\x02\u0C8C\u0C8D\x07\x05" +
		"\x02\x02\u0C8D\u0D26\x03\x02\x02\x02\u0C8E\u0C8F\x07\xDE\x02\x02\u0C8F" +
		"\u0C90\x07\x04\x02\x02\u0C90\u0C91\x05\u0118\x8D\x02\u0C91\u0C92\x07\x8C" +
		"\x02\x02\u0C92\u0C93\x05\u0118\x8D\x02\u0C93\u0C94\x07\x05\x02\x02\u0C94" +
		"\u0D26\x03\x02\x02\x02\u0C95\u0D26\x05\u0120\x91\x02\u0C96\u0D26\x07\u0166" +
		"\x02\x02\u0C97\u0C98\x05\u0170\xB9\x02\u0C98\u0C99\x07\x07\x02\x02\u0C99" +
		"\u0C9A\x07\u0166\x02\x02\u0C9A\u0D26\x03\x02\x02\x02\u0C9B\u0C9C\x07\x04" +
		"\x02\x02\u0C9C\u0C9F\x05\u0100\x81\x02\u0C9D\u0C9E\x07\x06\x02\x02\u0C9E" +
		"\u0CA0\x05\u0100\x81\x02\u0C9F\u0C9D\x03\x02\x02\x02\u0CA0\u0CA1\x03\x02" +
		"\x02\x02\u0CA1\u0C9F\x03\x02\x02\x02\u0CA1\u0CA2\x03\x02\x02\x02\u0CA2" +
		"\u0CA3\x03\x02\x02\x02\u0CA3\u0CA4\x07\x05\x02\x02\u0CA4\u0D26\x03\x02" +
		"\x02\x02\u0CA5\u0CA6\x07\x04\x02\x02\u0CA6\u0CA7\x05\x1C\x0F\x02\u0CA7" +
		"\u0CA8\x07\x05\x02\x02\u0CA8\u0D26\x03\x02\x02\x02\u0CA9\u0CAA\x07\x88" +
		"\x02\x02\u0CAA\u0CAB\x07\x04\x02\x02\u0CAB\u0CAC\x05\u010C\x87\x02\u0CAC" +
		"\u0CAD\x07\x05\x02\x02\u0CAD\u0D26\x03\x02\x02\x02\u0CAE\u0CAF\x05\u016C" +
		"\xB7\x02\u0CAF\u0CBB\x07\x04\x02\x02\u0CB0\u0CB2\x05\xC4c\x02\u0CB1\u0CB0" +
		"\x03\x02\x02\x02\u0CB1\u0CB2\x03\x02\x02\x02\u0CB2\u0CB3\x03\x02\x02\x02" +
		"\u0CB3\u0CB8\x05\u0110\x89\x02\u0CB4\u0CB5\x07\x06\x02\x02\u0CB5\u0CB7" +
		"\x05\u0110\x89\x02\u0CB6\u0CB4\x03\x02\x02\x02\u0CB7\u0CBA\x03\x02\x02" +
		"\x02\u0CB8\u0CB6\x03\x02\x02\x02\u0CB8\u0CB9\x03\x02\x02\x02\u0CB9\u0CBC" +
		"\x03\x02\x02\x02\u0CBA\u0CB8\x03\x02\x02\x02\u0CBB\u0CB1\x03\x02\x02\x02" +
		"\u0CBB\u0CBC\x03\x02\x02\x02\u0CBC\u0CBD\x03\x02\x02\x02\u0CBD\u0CC4\x07" +
		"\x05\x02\x02\u0CBE\u0CBF\x07r\x02\x02\u0CBF\u0CC0\x07\x04\x02\x02\u0CC0" +
		"\u0CC1\x07\u0154\x02\x02\u0CC1\u0CC2\x05\u0114\x8B\x02\u0CC2\u0CC3\x07" +
		"\x05\x02\x02\u0CC3\u0CC5\x03\x02\x02\x02\u0CC4\u0CBE\x03\x02\x02\x02\u0CC4" +
		"\u0CC5\x03\x02\x02\x02\u0CC5\u0CC8\x03\x02\x02\x02\u0CC6\u0CC7\t(\x02" +
		"\x02\u0CC7\u0CC9\x07\xC5\x02\x02\u0CC8\u0CC6\x03\x02\x02\x02\u0CC8\u0CC9" +
		"\x03\x02\x02\x02\u0CC9\u0CCC\x03\x02\x02\x02\u0CCA\u0CCB\x07\xD2\x02\x02" +
		"\u0CCB\u0CCD\x05\u0164\xB3\x02\u0CCC\u0CCA\x03\x02\x02\x02\u0CCC\u0CCD" +
		"\x03\x02\x02\x02\u0CCD\u0D26\x03\x02\x02\x02\u0CCE\u0CCF\x05\u0176\xBC" +
		"\x02\u0CCF\u0CD0\x07\u016F\x02\x02\u0CD0\u0CD1\x05\u010C\x87\x02\u0CD1" +
		"\u0D26\x03\x02\x02\x02\u0CD2\u0CD3\x07\x04\x02\x02\u0CD3\u0CD6\x05\u0176" +
		"\xBC\x02\u0CD4\u0CD5\x07\x06\x02\x02\u0CD5\u0CD7\x05\u0176\xBC\x02\u0CD6" +
		"\u0CD4\x03\x02\x02\x02\u0CD7\u0CD8\x03\x02\x02\x02\u0CD8\u0CD6\x03\x02" +
		"\x02\x02\u0CD8\u0CD9\x03\x02\x02\x02\u0CD9\u0CDA\x03\x02\x02\x02\u0CDA" +
		"\u0CDB\x07\x05\x02\x02\u0CDB\u0CDC\x07\u016F\x02\x02\u0CDC\u0CDD\x05\u010C" +
		"\x87\x02\u0CDD\u0D26\x03\x02\x02\x02\u0CDE\u0D26\x05\u0176\xBC\x02\u0CDF" +
		"\u0CE0\x07\x04\x02\x02\u0CE0\u0CE1\x05\u010C\x87\x02\u0CE1\u0CE2\x07\x05" +
		"\x02\x02\u0CE2\u0D26\x03\x02\x02\x02\u0CE3\u0CE4\x07n\x02\x02\u0CE4\u0CE5" +
		"\x07\x04\x02\x02\u0CE5\u0CE6\x05\u0176\xBC\x02\u0CE6\u0CE7\x07{\x02\x02" +
		"\u0CE7\u0CE8\x05\u0118\x8D\x02\u0CE8\u0CE9\x07\x05\x02\x02\u0CE9\u0D26" +
		"\x03\x02\x02\x02\u0CEA\u0CEB\t)\x02\x02\u0CEB\u0CEC\x07\x04\x02\x02\u0CEC" +
		"\u0CED\x05\u0118\x8D\x02\u0CED\u0CEE\t*\x02\x02\u0CEE\u0CF1\x05\u0118" +
		"\x8D\x02\u0CEF\u0CF0\t+\x02\x02\u0CF0\u0CF2\x05\u0118\x8D\x02\u0CF1\u0CEF" +
		"\x03\x02\x02\x02\u0CF1\u0CF2\x03\x02\x02\x02\u0CF2\u0CF3\x03\x02\x02\x02" +
		"\u0CF3\u0CF4\x07\x05\x02\x02\u0CF4\u0D26\x03\x02\x02\x02\u0CF5\u0CF6\x07" +
		"\u0137\x02\x02\u0CF6\u0CF8\x07\x04\x02\x02\u0CF7\u0CF9\t,\x02\x02\u0CF8" +
		"\u0CF7\x03\x02\x02\x02\u0CF8\u0CF9\x03\x02\x02\x02\u0CF9\u0CFB\x03\x02" +
		"\x02\x02\u0CFA\u0CFC\x05\u0118\x8D\x02\u0CFB\u0CFA\x03\x02\x02\x02\u0CFB" +
		"\u0CFC\x03\x02\x02\x02\u0CFC\u0CFD\x03\x02\x02\x02\u0CFD\u0CFE\x07{\x02" +
		"\x02\u0CFE\u0CFF\x05\u0118\x8D\x02\u0CFF\u0D00\x07\x05\x02\x02\u0D00\u0D26" +
		"\x03\x02\x02\x02\u0D01\u0D02\x07\xD4\x02\x02\u0D02\u0D03\x07\x04\x02\x02" +
		"\u0D03\u0D04\x05\u0118\x8D\x02\u0D04\u0D05\x07\xDD\x02\x02\u0D05\u0D06" +
		"\x05\u0118\x8D\x02\u0D06\u0D07\x07{\x02\x02\u0D07\u0D0A\x05\u0118\x8D" +
		"\x02\u0D08\u0D09\x07w\x02\x02\u0D09\u0D0B\x05\u0118\x8D\x02\u0D0A\u0D08" +
		"\x03\x02\x02\x02\u0D0A\u0D0B\x03\x02\x02\x02\u0D0B\u0D0C\x03\x02\x02\x02" +
		"\u0D0C\u0D0D\x07\x05\x02\x02\u0D0D\u0D26\x03\x02\x02\x02\u0D0E\u0D0F\t" +
		"-\x02\x02\u0D0F\u0D10\x07\x04\x02\x02\u0D10\u0D11\x05\u0118\x8D\x02\u0D11" +
		"\u0D12\x07\x05\x02\x02\u0D12\u0D13\x07\u0157\x02\x02\u0D13\u0D14\x07\x82" +
		"\x02\x02\u0D14\u0D15\x07\x04\x02\x02\u0D15\u0D16\x07\xCE\x02\x02\u0D16" +
		"\u0D17\x07!\x02\x02\u0D17\u0D18\x05l7\x02\u0D18\u0D1F\x07\x05\x02\x02" +
		"\u0D19\u0D1A\x07r\x02\x02\u0D1A\u0D1B\x07\x04\x02\x02\u0D1B\u0D1C\x07" +
		"\u0154\x02\x02\u0D1C\u0D1D\x05\u0114\x8B\x02\u0D1D\u0D1E\x07\x05\x02\x02" +
		"\u0D1E\u0D20\x03\x02\x02\x02\u0D1F\u0D19\x03\x02\x02\x02\u0D1F\u0D20\x03" +
		"\x02\x02\x02\u0D20\u0D23\x03\x02\x02\x02\u0D21\u0D22\x07\xD2\x02\x02\u0D22" +
		"\u0D24\x05\u0164\xB3\x02\u0D23\u0D21\x03\x02\x02\x02\u0D23\u0D24\x03\x02" +
		"\x02\x02\u0D24\u0D26\x03\x02\x02\x02\u0D25\u0C2C\x03\x02\x02\x02\u0D25" +
		"\u0C2E\x03\x02\x02\x02\u0D25\u0C3A\x03\x02\x02\x02\u0D25\u0C46\x03\x02" +
		"\x02\x02\u0D25\u0C52\x03\x02\x02\x02\u0D25\u0C5F\x03\x02\x02\x02\u0D25" +
		"\u0C66\x03\x02\x02\x02\u0D25\u0C73\x03\x02\x02\x02\u0D25\u0C7C\x03\x02" +
		"\x02\x02\u0D25\u0C85\x03\x02\x02\x02\u0D25\u0C8E\x03\x02\x02\x02\u0D25" +
		"\u0C95\x03\x02\x02\x02\u0D25\u0C96\x03\x02\x02\x02\u0D25\u0C97\x03\x02" +
		"\x02\x02\u0D25\u0C9B\x03\x02\x02\x02\u0D25\u0CA5\x03\x02\x02\x02\u0D25" +
		"\u0CA9\x03\x02\x02\x02\u0D25\u0CAE\x03\x02\x02\x02\u0D25\u0CCE\x03\x02" +
		"\x02\x02\u0D25\u0CD2\x03\x02\x02\x02\u0D25\u0CDE\x03\x02\x02\x02\u0D25" +
		"\u0CDF\x03\x02\x02\x02\u0D25\u0CE3\x03\x02\x02\x02\u0D25\u0CEA\x03\x02" +
		"\x02\x02\u0D25\u0CF5\x03\x02\x02\x02\u0D25\u0D01\x03\x02\x02\x02\u0D25" +
		"\u0D0E\x03\x02\x02\x02\u0D26\u0D31\x03\x02\x02\x02\u0D27\u0D28\f\v\x02" +
		"\x02\u0D28\u0D29\x07\b\x02\x02\u0D29\u0D2A\x05\u0118\x8D\x02\u0D2A\u0D2B" +
		"\x07\t\x02\x02\u0D2B\u0D30\x03\x02\x02\x02\u0D2C\u0D2D\f\t\x02\x02\u0D2D" +
		"\u0D2E\x07\x07\x02\x02\u0D2E\u0D30\x05\u0176\xBC\x02\u0D2F\u0D27\x03\x02" +
		"\x02\x02\u0D2F\u0D2C\x03\x02\x02\x02\u0D30\u0D33\x03\x02\x02\x02\u0D31" +
		"\u0D2F\x03\x02\x02\x02\u0D31\u0D32\x03\x02\x02\x02\u0D32\u011D\x03\x02" +
		"\x02\x02\u0D33\u0D31\x03\x02\x02\x02\u0D34\u0D3C\x07I\x02\x02\u0D35\u0D3C" +
		"\x07\u012B\x02\x02\u0D36\u0D3C\x07\u012C\x02\x02\u0D37\u0D3C\x07\u012D" +
		"\x02\x02\u0D38\u0D3C\x07\x95\x02\x02\u0D39\u0D3C\x07\x85\x02\x02\u0D3A" +
		"\u0D3C\x05\u0176\xBC\x02\u0D3B\u0D34\x03\x02\x02\x02\u0D3B\u0D35\x03\x02" +
		"\x02\x02\u0D3B\u0D36\x03\x02\x02\x02\u0D3B\u0D37\x03\x02\x02\x02\u0D3B" +
		"\u0D38\x03\x02\x02\x02\u0D3B\u0D39\x03\x02\x02\x02\u0D3B\u0D3A\x03\x02" +
		"\x02\x02\u0D3C\u011F\x03\x02\x02\x02\u0D3D\u0D4D\x07\xC4\x02\x02\u0D3E" +
		"\u0D4D\x07\u0173\x02\x02\u0D3F\u0D40\x07\u016E\x02\x02\u0D40\u0D4D\x05" +
		"\u0176\xBC\x02\u0D41\u0D4D\x05\u012A\x96\x02\u0D42\u0D43\x05\u011E\x90" +
		"\x02\u0D43\u0D44\x05\u0182\xC2\x02\u0D44\u0D4D\x03\x02\x02\x02\u0D45\u0D4D" +
		"\x05\u017E\xC0\x02\u0D46\u0D4D\x05\u0128\x95\x02\u0D47\u0D49\x05\u0182" +
		"\xC2\x02\u0D48\u0D47\x03\x02\x02\x02\u0D49\u0D4A\x03\x02\x02\x02\u0D4A" +
		"\u0D48\x03\x02\x02\x02\u0D4A\u0D4B\x03\x02\x02\x02\u0D4B\u0D4D\x03\x02" +
		"\x02\x02\u0D4C\u0D3D\x03\x02\x02\x02\u0D4C\u0D3E\x03\x02\x02\x02\u0D4C" +
		"\u0D3F\x03\x02\x02\x02\u0D4C\u0D41\x03\x02\x02\x02\u0D4C\u0D42\x03\x02" +
		"\x02\x02\u0D4C\u0D45\x03\x02\x02\x02\u0D4C\u0D46\x03\x02\x02\x02\u0D4C" +
		"\u0D48\x03\x02\x02\x02\u0D4D\u0121\x03\x02\x02\x02\u0D4E\u0D4F\t.\x02" +
		"\x02\u0D4F\u0123\x03\x02\x02\x02\u0D50\u0D51\t/\x02\x02\u0D51\u0125\x03" +
		"\x02\x02\x02\u0D52\u0D53\t0\x02\x02\u0D53\u0127\x03\x02\x02\x02\u0D54" +
		"\u0D55\t1\x02\x02\u0D55\u0129\x03\x02\x02\x02\u0D56\u0D59\x07\x95\x02" +
		"\x02\u0D57\u0D5A\x05\u012C\x97\x02\u0D58\u0D5A\x05\u0130\x99\x02\u0D59" +
		"\u0D57\x03\x02\x02\x02\u0D59\u0D58\x03\x02\x02\x02\u0D5A\u012B\x03\x02" +
		"\x02\x02\u0D5B\u0D5D\x05\u012E\x98\x02\u0D5C\u0D5E\x05\u0132\x9A\x02\u0D5D" +
		"\u0D5C\x03\x02\x02\x02\u0D5D\u0D5E\x03\x02\x02\x02\u0D5E\u012D\x03\x02" +
		"\x02\x02\u0D5F\u0D60\x05\u0134\x9B\x02\u0D60\u0D61\x05\u0136\x9C\x02\u0D61" +
		"\u0D63\x03\x02\x02\x02\u0D62\u0D5F\x03\x02\x02\x02\u0D63\u0D64\x03\x02" +
		"\x02\x02\u0D64\u0D62\x03\x02\x02\x02\u0D64\u0D65\x03\x02\x02\x02\u0D65" +
		"\u012F\x03\x02\x02\x02\u0D66\u0D69\x05\u0132\x9A\x02\u0D67\u0D6A\x05\u012E" +
		"\x98\x02\u0D68\u0D6A\x05\u0132\x9A\x02\u0D69\u0D67\x03\x02\x02\x02\u0D69" +
		"\u0D68\x03\x02\x02\x02\u0D69\u0D6A\x03\x02\x02\x02\u0D6A\u0131\x03\x02" +
		"\x02\x02\u0D6B\u0D6C\x05\u0134\x9B\x02\u0D6C\u0D6D\x05\u0138\x9D\x02\u0D6D" +
		"\u0D6E\x07\u0131\x02\x02\u0D6E\u0D6F\x05\u0138\x9D\x02\u0D6F\u0133\x03" +
		"\x02\x02\x02\u0D70\u0D72\t2\x02\x02\u0D71\u0D70\x03\x02\x02\x02\u0D71" +
		"\u0D72\x03\x02\x02\x02\u0D72\u0D76\x03\x02\x02\x02\u0D73\u0D77\x07\u0179" +
		"\x02\x02\u0D74\u0D77\x07\u017B\x02\x02\u0D75\u0D77\x05\u0182\xC2\x02\u0D76" +
		"\u0D73\x03\x02\x02\x02\u0D76\u0D74\x03\x02\x02\x02\u0D76\u0D75\x03\x02" +
		"\x02\x02\u0D77\u0135\x03\x02\x02\x02\u0D78\u0D79\t3\x02\x02\u0D79\u0137" +
		"\x03\x02\x02\x02\u0D7A\u0D7B\t4\x02\x02\u0D7B\u0139\x03\x02\x02\x02\u0D7C" +
		"\u0D80\x07t\x02\x02\u0D7D\u0D7E\x07\v\x02\x02\u0D7E\u0D80\x05\u0172\xBA" +
		"\x02\u0D7F\u0D7C\x03\x02\x02\x02\u0D7F\u0D7D\x03\x02\x02\x02\u0D80\u013B" +
		"\x03\x02\x02\x02\u0D81\u0DA0\x07\x1D\x02\x02\u0D82\u0DA0\x07\u0130\x02" +
		"\x02\u0D83\u0DA0\x07\"\x02\x02\u0D84\u0DA0\x07\u0110\x02\x02\u0D85\u0DA0" +
		"\x07\u010C\x02\x02\u0D86\u0DA0\x07\x96\x02\x02\u0D87\u0DA0\x07\x97\x02" +
		"\x02\u0D88\u0DA0\x07\x1B\x02\x02\u0D89\u0DA0\x07\xAD\x02\x02\u0D8A\u0DA0" +
		"\x07u\x02\x02\u0D8B\u0DA0\x07\xE7\x02\x02\u0D8C\u0DA0\x07`\x02\x02\u0D8D" +
		"\u0DA0\x07I\x02\x02\u0D8E\u0DA0\x07\u012B\x02\x02\u0D8F\u0DA0\x07\u012D" +
		"\x02\x02\u0D90\u0DA0\x07\u012C\x02\x02\u0D91\u0DA0\x07\u0119\x02\x02\u0D92" +
		"\u0DA0\x07+\x02\x02\u0D93\u0DA0\x07*\x02\x02\u0D94\u0DA0\x07\u014A\x02" +
		"\x02\u0D95\u0DA0\x07\x1C\x02\x02\u0D96\u0DA0\x07R\x02\x02\u0D97\u0DA0" +
		"\x07Q\x02\x02\u0D98\u0DA0\x07\xC6\x02\x02\u0D99\u0DA0\x07\u0150\x02\x02" +
		"\u0D9A\u0DA0\x07\x95\x02\x02\u0D9B\u0DA0\x07\x15\x02\x02\u0D9C\u0DA0\x07" +
		"\u011A\x02\x02\u0D9D\u0DA0\x07\xAF\x02\x02\u0D9E\u0DA0\x05\u0176\xBC\x02" +
		"\u0D9F\u0D81\x03\x02\x02\x02\u0D9F\u0D82\x03\x02\x02\x02\u0D9F\u0D83\x03" +
		"\x02\x02\x02\u0D9F\u0D84\x03\x02\x02\x02\u0D9F\u0D85\x03\x02\x02\x02\u0D9F" +
		"\u0D86\x03\x02\x02\x02\u0D9F\u0D87\x03\x02\x02\x02\u0D9F\u0D88\x03\x02" +
		"\x02\x02\u0D9F\u0D89\x03\x02\x02\x02\u0D9F\u0D8A\x03\x02\x02\x02\u0D9F" +
		"\u0D8B\x03\x02\x02\x02\u0D9F\u0D8C\x03\x02\x02\x02\u0D9F\u0D8D\x03\x02" +
		"\x02\x02\u0D9F\u0D8E\x03\x02\x02\x02\u0D9F\u0D8F\x03\x02\x02\x02\u0D9F" +
		"\u0D90\x03\x02\x02\x02\u0D9F\u0D91\x03\x02\x02\x02\u0D9F\u0D92\x03\x02" +
		"\x02\x02\u0D9F\u0D93\x03\x02\x02\x02\u0D9F\u0D94\x03\x02\x02\x02\u0D9F" +
		"\u0D95\x03\x02\x02\x02\u0D9F\u0D96\x03\x02\x02\x02\u0D9F\u0D97\x03\x02" +
		"\x02\x02\u0D9F\u0D98\x03\x02\x02\x02\u0D9F\u0D99\x03\x02\x02\x02\u0D9F" +
		"\u0D9A\x03\x02\x02\x02\u0D9F\u0D9B\x03\x02\x02\x02\u0D9F\u0D9C\x03\x02" +
		"\x02\x02\u0D9F\u0D9D\x03\x02\x02\x02\u0D9F\u0D9E\x03\x02\x02\x02\u0DA0" +
		"\u013D\x03\x02\x02\x02\u0DA1\u0DA2\x07\x15\x02\x02\u0DA2\u0DA3\x07\u015F" +
		"\x02\x02\u0DA3\u0DA4\x05\u013E\xA0\x02\u0DA4\u0DA5\x07\u0161\x02\x02\u0DA5" +
		"\u0DD0\x03\x02\x02\x02\u0DA6\u0DA7\x07\xAF\x02\x02\u0DA7\u0DA8\x07\u015F" +
		"\x02\x02\u0DA8\u0DA9\x05\u013E\xA0\x02\u0DA9\u0DAA\x07\x06\x02\x02\u0DAA" +
		"\u0DAB\x05\u013E\xA0\x02\u0DAB\u0DAC\x07\u0161\x02\x02\u0DAC\u0DD0\x03" +
		"\x02\x02\x02\u0DAD\u0DB4\x07\u011A\x02\x02\u0DAE\u0DB0\x07\u015F\x02\x02" +
		"\u0DAF\u0DB1\x05\u015A\xAE\x02\u0DB0\u0DAF\x03\x02\x02\x02\u0DB0\u0DB1" +
		"\x03\x02\x02\x02\u0DB1\u0DB2\x03\x02\x02\x02\u0DB2\u0DB5\x07\u0161\x02" +
		"\x02\u0DB3\u0DB5\x07\u015D\x02\x02\u0DB4\u0DAE\x03\x02\x02\x02\u0DB4\u0DB3" +
		"\x03\x02\x02\x02\u0DB5\u0DD0\x03\x02\x02\x02\u0DB6\u0DB7\x07\x95\x02\x02" +
		"\u0DB7\u0DBA\t5\x02\x02\u0DB8\u0DB9\x07\u0131\x02\x02\u0DB9\u0DBB\x07" +
		"\xB8\x02\x02\u0DBA\u0DB8\x03\x02\x02\x02\u0DBA\u0DBB\x03\x02\x02\x02\u0DBB" +
		"\u0DD0\x03\x02\x02\x02\u0DBC\u0DBD\x07\x95\x02\x02\u0DBD\u0DC0\t6\x02" +
		"\x02\u0DBE\u0DBF\x07\u0131\x02\x02\u0DBF\u0DC1\t7\x02\x02\u0DC0\u0DBE" +
		"\x03\x02\x02\x02\u0DC0\u0DC1\x03\x02\x02\x02\u0DC1\u0DD0\x03\x02\x02\x02" +
		"\u0DC2\u0DCD\x05\u013C\x9F\x02\u0DC3\u0DC4\x07\x04\x02\x02\u0DC4\u0DC9" +
		"\x07\u0179\x02\x02\u0DC5\u0DC6\x07\x06\x02\x02\u0DC6\u0DC8\x07\u0179\x02" +
		"\x02\u0DC7\u0DC5\x03\x02\x02\x02\u0DC8\u0DCB\x03\x02\x02\x02\u0DC9\u0DC7" +
		"\x03\x02\x02\x02\u0DC9\u0DCA\x03\x02\x02\x02\u0DCA\u0DCC\x03\x02\x02\x02" +
		"\u0DCB\u0DC9\x03\x02\x02\x02\u0DCC\u0DCE\x07\x05\x02\x02\u0DCD\u0DC3\x03" +
		"\x02\x02\x02\u0DCD\u0DCE\x03\x02\x02\x02\u0DCE\u0DD0\x03\x02\x02\x02\u0DCF" +
		"\u0DA1\x03\x02\x02\x02\u0DCF\u0DA6\x03\x02\x02\x02\u0DCF\u0DAD\x03\x02" +
		"\x02\x02\u0DCF\u0DB6\x03\x02\x02\x02\u0DCF\u0DBC\x03\x02\x02\x02\u0DCF" +
		"\u0DC2\x03\x02\x02\x02\u0DD0\u013F\x03\x02\x02\x02\u0DD1\u0DD6\x05\u0142" +
		"\xA2\x02\u0DD2\u0DD3\x07\x06\x02\x02\u0DD3\u0DD5\x05\u0142\xA2\x02\u0DD4" +
		"\u0DD2\x03\x02\x02\x02\u0DD5\u0DD8\x03\x02\x02\x02\u0DD6\u0DD4\x03\x02" +
		"\x02\x02\u0DD6\u0DD7\x03\x02\x02\x02\u0DD7\u0141\x03\x02\x02\x02\u0DD8" +
		"\u0DD6\x03\x02\x02\x02\u0DD9\u0DDA\x05`1\x02\u0DDA\u0DDE\x05\u013E\xA0" +
		"\x02\u0DDB\u0DDD\x05\u0148\xA5\x02\u0DDC\u0DDB\x03\x02\x02\x02\u0DDD\u0DE0" +
		"\x03\x02\x02\x02\u0DDE\u0DDC\x03\x02\x02\x02\u0DDE\u0DDF\x03\x02\x02\x02" +
		"\u0DDF\u0143\x03\x02\x02\x02\u0DE0\u0DDE\x03\x02\x02\x02\u0DE1\u0DE6\x05" +
		"\u0146\xA4\x02\u0DE2\u0DE3\x07\x06\x02\x02\u0DE3\u0DE5\x05\u0146\xA4\x02" +
		"\u0DE4\u0DE2\x03\x02\x02\x02\u0DE5\u0DE8\x03\x02\x02\x02\u0DE6\u0DE4\x03" +
		"\x02\x02\x02\u0DE6\u0DE7\x03\x02\x02\x02\u0DE7\u0145\x03\x02\x02\x02\u0DE8" +
		"\u0DE6\x03\x02\x02\x02\u0DE9\u0DEA\x05\\/\x02\u0DEA\u0DEE\x05\u013E\xA0" +
		"\x02\u0DEB\u0DED\x05\u0148\xA5\x02\u0DEC\u0DEB\x03\x02\x02\x02\u0DED\u0DF0" +
		"\x03\x02\x02\x02\u0DEE\u0DEC\x03\x02\x02\x02\u0DEE\u0DEF\x03\x02\x02\x02" +
		"\u0DEF\u0147\x03\x02\x02\x02\u0DF0\u0DEE\x03\x02\x02\x02\u0DF1\u0DF2\x07" +
		"\xC3\x02\x02\u0DF2\u0DF7\x07\xC4\x02\x02\u0DF3\u0DF7\x05\u014A\xA6\x02" +
		"\u0DF4\u0DF7\x05\x1A\x0E\x02\u0DF5\u0DF7\x05\u013A\x9E\x02\u0DF6\u0DF1" +
		"\x03\x02\x02\x02\u0DF6\u0DF3\x03\x02\x02\x02\u0DF6\u0DF4\x03\x02\x02\x02" +
		"\u0DF6\u0DF5\x03\x02\x02\x02\u0DF7\u0149\x03\x02\x02\x02\u0DF8\u0DF9\x07" +
		"T\x02\x02\u0DF9\u0DFA\x05\u010C\x87\x02\u0DFA\u014B\x03\x02\x02\x02\u0DFB" +
		"\u0DFC\t8\x02\x02\u0DFC\u0DFD\x05\u010C\x87\x02\u0DFD\u014D\x03\x02\x02" +
		"\x02\u0DFE\u0E03\x05\u0150\xA9\x02\u0DFF\u0E00\x07\x06\x02\x02\u0E00\u0E02" +
		"\x05\u0150\xA9\x02\u0E01\u0DFF\x03\x02\x02\x02\u0E02\u0E05\x03\x02\x02" +
		"\x02\u0E03\u0E01\x03\x02\x02\x02\u0E03\u0E04\x03\x02\x02\x02\u0E04\u014F" +
		"\x03\x02\x02\x02\u0E05\u0E03\x03\x02\x02\x02\u0E06\u0E07\x05\u0172\xBA" +
		"\x02\u0E07\u0E0A\x05\u013E\xA0\x02\u0E08\u0E09\x07\xC3\x02\x02\u0E09\u0E0B" +
		"\x07\xC4\x02\x02\u0E0A\u0E08\x03\x02\x02\x02\u0E0A\u0E0B\x03\x02\x02\x02" +
		"\u0E0B\u0E0D\x03\x02\x02\x02\u0E0C\u0E0E\x05\x1A\x0E\x02\u0E0D\u0E0C\x03" +
		"\x02\x02\x02\u0E0D\u0E0E\x03\x02\x02\x02\u0E0E\u0151\x03\x02\x02\x02\u0E0F" +
		"\u0E14\x05\u0154\xAB\x02\u0E10\u0E11\x07\x06\x02\x02\u0E11\u0E13\x05\u0154" +
		"\xAB\x02\u0E12\u0E10\x03\x02\x02\x02\u0E13\u0E16\x03\x02\x02\x02\u0E14" +
		"\u0E12\x03\x02\x02\x02\u0E14\u0E15\x03\x02\x02\x02\u0E15\u0153\x03\x02" +
		"\x02\x02\u0E16\u0E14\x03\x02\x02\x02\u0E17\u0E18\x05`1\x02\u0E18\u0E1C" +
		"\x05\u013E\xA0\x02\u0E19\u0E1B\x05\u0156\xAC\x02\u0E1A\u0E19\x03\x02\x02" +
		"\x02\u0E1B\u0E1E\x03\x02\x02\x02\u0E1C\u0E1A\x03\x02\x02\x02\u0E1C\u0E1D" +
		"\x03\x02\x02\x02\u0E1D\u0155\x03\x02\x02\x02\u0E1E\u0E1C\x03\x02\x02\x02" +
		"\u0E1F\u0E20\x07\xC3\x02\x02\u0E20\u0E25\x07\xC4\x02\x02\u0E21\u0E25\x05" +
		"\u014A\xA6\x02\u0E22\u0E25\x05\u0158\xAD\x02\u0E23\u0E25\x05\x1A\x0E\x02" +
		"\u0E24\u0E1F\x03\x02\x02\x02\u0E24\u0E21\x03\x02\x02\x02\u0E24\u0E22\x03" +
		"\x02\x02\x02\u0E24\u0E23\x03\x02\x02\x02\u0E25\u0157\x03\x02\x02\x02\u0E26" +
		"\u0E27\x07\x7F\x02\x02\u0E27\u0E28\x07\x0E\x02\x02\u0E28\u0E29\x07\x16" +
		"\x02\x02\u0E29\u0E2A\x07\x04\x02\x02\u0E2A\u0E2B\x05\u010C\x87\x02\u0E2B" +
		"\u0E2C\x07\x05\x02\x02\u0E2C\u0159\x03\x02\x02\x02\u0E2D\u0E32\x05\u015C" +
		"\xAF\x02\u0E2E\u0E2F\x07\x06\x02\x02\u0E2F\u0E31\x05\u015C\xAF\x02\u0E30" +
		"\u0E2E\x03\x02\x02\x02\u0E31\u0E34\x03\x02\x02\x02\u0E32\u0E30\x03\x02" +
		"\x02\x02\u0E32\u0E33\x03\x02\x02\x02\u0E33\u015B\x03\x02\x02\x02\u0E34" +
		"\u0E32\x03\x02\x02\x02\u0E35\u0E37\x05\u0176\xBC\x02\u0E36\u0E38\x07\u016E" +
		"\x02\x02\u0E37\u0E36\x03\x02\x02\x02\u0E37\u0E38\x03\x02\x02\x02\u0E38" +
		"\u0E39\x03\x02\x02\x02\u0E39\u0E3C\x05\u013E\xA0\x02\u0E3A\u0E3B\x07\xC3" +
		"\x02\x02\u0E3B\u0E3D\x07\xC4\x02\x02\u0E3C\u0E3A\x03\x02\x02\x02\u0E3C" +
		"\u0E3D\x03\x02\x02\x02\u0E3D\u0E3F\x03\x02\x02\x02\u0E3E\u0E40\x05\x1A" +
		"\x0E\x02\u0E3F\u0E3E\x03\x02\x02\x02\u0E3F\u0E40\x03\x02\x02\x02\u0E40" +
		"\u015D\x03\x02\x02\x02\u0E41\u0E42\x07\u0153\x02\x02\u0E42\u0E43\x05\u010C" +
		"\x87\x02\u0E43\u0E44\x07\u0128\x02\x02\u0E44\u0E45\x05\u010C\x87\x02\u0E45" +
		"\u015F\x03\x02\x02\x02\u0E46\u0E47\x07\u0155\x02\x02\u0E47\u0E4C\x05\u0162" +
		"\xB2\x02\u0E48\u0E49\x07\x06\x02\x02\u0E49\u0E4B\x05\u0162\xB2\x02\u0E4A" +
		"\u0E48\x03\x02\x02\x02\u0E4B\u0E4E\x03\x02\x02\x02\u0E4C\u0E4A\x03\x02" +
		"\x02\x02\u0E4C\u0E4D\x03\x02\x02\x02\u0E4D\u0161\x03\x02\x02\x02\u0E4E" +
		"\u0E4C\x03\x02\x02\x02\u0E4F\u0E50\x05\u0172\xBA\x02\u0E50\u0E51\x07\x16" +
		"\x02\x02\u0E51\u0E52\x05\u0164\xB3\x02\u0E52\u0163\x03\x02\x02\x02\u0E53" +
		"\u0E82\x05\u0172\xBA\x02\u0E54\u0E55\x07\x04\x02\x02\u0E55\u0E56\x05\u0172" +
		"\xBA\x02\u0E56\u0E57\x07\x05\x02\x02\u0E57\u0E82\x03\x02\x02\x02\u0E58" +
		"\u0E7B\x07\x04\x02\x02\u0E59\u0E5A\x07.\x02\x02\u0E5A\u0E5B\x07!\x02\x02" +
		"\u0E5B\u0E60\x05\u010C\x87\x02\u0E5C\u0E5D\x07\x06\x02\x02\u0E5D\u0E5F" +
		"\x05\u010C\x87\x02\u0E5E\u0E5C\x03\x02\x02\x02\u0E5F\u0E62\x03\x02\x02" +
		"\x02\u0E60\u0E5E\x03\x02\x02\x02\u0E60\u0E61\x03\x02\x02\x02\u0E61\u0E7C" +
		"\x03\x02\x02\x02\u0E62\u0E60\x03\x02\x02\x02\u0E63\u0E64\t\x19\x02\x02" +
		"\u0E64\u0E65\x07!\x02\x02\u0E65\u0E6A\x05\u010C\x87\x02\u0E66\u0E67\x07" +
		"\x06\x02\x02\u0E67\u0E69\x05\u010C\x87\x02\u0E68\u0E66\x03\x02\x02\x02" +
		"\u0E69\u0E6C\x03\x02\x02\x02\u0E6A\u0E68\x03\x02\x02\x02\u0E6A\u0E6B\x03" +
		"\x02\x02\x02\u0E6B\u0E6E\x03\x02\x02\x02\u0E6C\u0E6A\x03\x02\x02\x02\u0E6D" +
		"\u0E63\x03\x02\x02\x02\u0E6D\u0E6E\x03\x02\x02\x02\u0E6E\u0E79\x03\x02" +
		"\x02\x02\u0E6F\u0E70\t\x1A\x02\x02\u0E70\u0E71\x07!\x02\x02\u0E71\u0E76" +
		"\x05l7\x02\u0E72\u0E73\x07\x06\x02\x02\u0E73\u0E75\x05l7\x02\u0E74\u0E72" +
		"\x03\x02\x02\x02\u0E75\u0E78\x03\x02\x02\x02\u0E76\u0E74\x03\x02\x02\x02" +
		"\u0E76\u0E77\x03\x02\x02\x02\u0E77\u0E7A\x03\x02\x02\x02\u0E78\u0E76\x03" +
		"\x02\x02\x02\u0E79\u0E6F\x03\x02\x02\x02\u0E79\u0E7A\x03\x02\x02\x02\u0E7A" +
		"\u0E7C\x03\x02\x02\x02\u0E7B\u0E59\x03\x02\x02\x02\u0E7B\u0E6D\x03\x02" +
		"\x02\x02\u0E7C\u0E7E\x03\x02\x02\x02\u0E7D\u0E7F\x05\u0166\xB4\x02\u0E7E" +
		"\u0E7D\x03\x02\x02\x02\u0E7E\u0E7F\x03\x02\x02\x02\u0E7F\u0E80\x03\x02" +
		"\x02\x02\u0E80\u0E82\x07\x05\x02\x02\u0E81\u0E53\x03\x02\x02\x02\u0E81" +
		"\u0E54\x03\x02\x02\x02\u0E81\u0E58\x03\x02\x02\x02\u0E82\u0165\x03\x02" +
		"\x02\x02\u0E83\u0E84\x07\xE6\x02\x02\u0E84\u0E94\x05\u0168\xB5\x02\u0E85" +
		"\u0E86\x07\xFE\x02\x02\u0E86\u0E94\x05\u0168\xB5\x02\u0E87\u0E88\x07\xE6" +
		"\x02\x02\u0E88\u0E89\x07\x1A\x02\x02\u0E89\u0E8A\x05\u0168\xB5\x02\u0E8A" +
		"\u0E8B\x07\x10\x02\x02\u0E8B\u0E8C\x05\u0168\xB5\x02\u0E8C\u0E94\x03\x02" +
		"\x02\x02\u0E8D\u0E8E\x07\xFE\x02\x02\u0E8E\u0E8F\x07\x1A\x02\x02\u0E8F" +
		"\u0E90\x05\u0168\xB5\x02\u0E90\u0E91\x07\x10\x02\x02\u0E91\u0E92\x05\u0168" +
		"\xB5\x02\u0E92\u0E94\x03\x02\x02";
	private static readonly _serializedATNSegment7: string =
		"\x02\u0E93\u0E83\x03\x02\x02\x02\u0E93\u0E85\x03\x02\x02\x02\u0E93\u0E87" +
		"\x03\x02\x02\x02\u0E93\u0E8D\x03\x02\x02\x02\u0E94\u0167\x03\x02\x02\x02" +
		"\u0E95\u0E96\x07\u013D\x02\x02\u0E96\u0E9D\t9\x02\x02\u0E97\u0E98\x07" +
		"@\x02\x02\u0E98\u0E9D\x07\xFD\x02\x02\u0E99\u0E9A\x05\u010C\x87\x02\u0E9A" +
		"\u0E9B\t9\x02\x02\u0E9B\u0E9D\x03\x02\x02\x02\u0E9C\u0E95\x03\x02\x02" +
		"\x02\u0E9C\u0E97\x03\x02\x02\x02\u0E9C\u0E99\x03\x02\x02\x02\u0E9D\u0169" +
		"\x03\x02\x02\x02\u0E9E\u0EA3\x05\u0170\xB9\x02\u0E9F\u0EA0\x07\x06\x02" +
		"\x02\u0EA0\u0EA2\x05\u0170\xB9\x02\u0EA1\u0E9F\x03\x02\x02\x02\u0EA2\u0EA5" +
		"\x03\x02\x02\x02\u0EA3\u0EA1\x03\x02\x02\x02\u0EA3\u0EA4\x03\x02\x02\x02" +
		"\u0EA4\u016B\x03\x02\x02\x02\u0EA5\u0EA3\x03\x02\x02\x02\u0EA6\u0EA7\x07" +
		"\x88\x02\x02\u0EA7\u0EA8\x07\x04\x02\x02\u0EA8\u0EA9\x05\u010C\x87\x02" +
		"\u0EA9\u0EAA\x07\x05\x02\x02\u0EAA\u0EB0\x03\x02\x02\x02\u0EAB\u0EB0\x05" +
		"\u0170\xB9\x02\u0EAC\u0EB0\x07r\x02\x02\u0EAD\u0EB0\x07\xA1\x02\x02\u0EAE" +
		"\u0EB0\x07\xF6\x02\x02\u0EAF\u0EA6\x03\x02\x02\x02\u0EAF\u0EAB\x03\x02" +
		"\x02\x02\u0EAF\u0EAC\x03\x02\x02\x02\u0EAF\u0EAD\x03\x02\x02\x02\u0EAF" +
		"\u0EAE\x03\x02\x02\x02\u0EB0\u016D\x03\x02\x02\x02\u0EB1\u0EB2\x05\u0170" +
		"\xB9\x02\u0EB2\u016F\x03\x02\x02\x02\u0EB3\u0EB8\x05\u0176\xBC\x02\u0EB4" +
		"\u0EB5\x07\x07\x02\x02\u0EB5\u0EB7\x05\u0176\xBC\x02\u0EB6\u0EB4\x03\x02" +
		"\x02\x02\u0EB7\u0EBA\x03\x02\x02\x02\u0EB8\u0EB6\x03\x02\x02\x02\u0EB8" +
		"\u0EB9\x03\x02\x02\x02\u0EB9\u0171\x03\x02\x02\x02\u0EBA\u0EB8\x03\x02" +
		"\x02\x02\u0EBB\u0EBC\x05\u0176\xBC\x02\u0EBC\u0EBD\x05\u0174\xBB\x02\u0EBD" +
		"\u0173\x03\x02\x02\x02\u0EBE\u0EBF\x07\u0165\x02\x02\u0EBF\u0EC1\x05\u0176" +
		"\xBC\x02\u0EC0\u0EBE\x03\x02\x02\x02\u0EC1\u0EC2\x03\x02\x02\x02\u0EC2" +
		"\u0EC0\x03\x02\x02\x02\u0EC2\u0EC3\x03\x02\x02\x02\u0EC3\u0EC6\x03\x02" +
		"\x02\x02\u0EC4\u0EC6\x03\x02\x02\x02\u0EC5\u0EC0\x03\x02\x02\x02\u0EC5" +
		"\u0EC4\x03\x02\x02\x02\u0EC6\u0175\x03\x02\x02\x02\u0EC7\u0ECA\x05\u0178" +
		"\xBD\x02\u0EC8\u0ECA\x05\u018A\xC6\x02\u0EC9\u0EC7\x03\x02\x02\x02\u0EC9" +
		"\u0EC8\x03\x02\x02\x02\u0ECA\u0177\x03\x02\x02\x02\u0ECB\u0ED0\x07\u017F" +
		"\x02\x02\u0ECC\u0ED0\x05\u017A\xBE\x02\u0ECD\u0ED0\x05\u0188\xC5\x02\u0ECE" +
		"\u0ED0\x05\u018C\xC7\x02\u0ECF\u0ECB\x03\x02\x02\x02\u0ECF\u0ECC\x03\x02" +
		"\x02\x02\u0ECF\u0ECD\x03\x02\x02\x02\u0ECF\u0ECE\x03\x02\x02\x02\u0ED0" +
		"\u0179\x03\x02\x02\x02\u0ED1\u0ED2\t:\x02\x02\u0ED2\u017B\x03\x02\x02" +
		"\x02\u0ED3\u0ED4\x07\u0180\x02\x02\u0ED4\u017D\x03\x02\x02\x02\u0ED5\u0ED7" +
		"\x07\u0165\x02\x02\u0ED6\u0ED5\x03\x02\x02\x02\u0ED6\u0ED7\x03\x02\x02" +
		"\x02\u0ED7\u0ED8\x03\x02\x02\x02\u0ED8\u0EFE\x07\u017A\x02\x02\u0ED9\u0EDB" +
		"\x07\u0165\x02\x02\u0EDA\u0ED9\x03\x02\x02\x02\u0EDA\u0EDB\x03\x02\x02" +
		"\x02\u0EDB\u0EDC\x03\x02\x02\x02\u0EDC\u0EFE\x07\u017B\x02\x02\u0EDD\u0EDF" +
		"\x07\u0165\x02\x02\u0EDE\u0EDD\x03\x02\x02\x02\u0EDE\u0EDF\x03\x02\x02" +
		"\x02\u0EDF\u0EE0\x03\x02\x02\x02\u0EE0\u0EFE\t;\x02\x02\u0EE1\u0EE3\x07" +
		"\u0165\x02\x02\u0EE2\u0EE1\x03\x02\x02\x02\u0EE2\u0EE3\x03\x02\x02\x02" +
		"\u0EE3\u0EE4\x03\x02\x02\x02\u0EE4\u0EFE\x07\u0179\x02\x02\u0EE5\u0EE7" +
		"\x07\u0165\x02\x02\u0EE6\u0EE5\x03\x02\x02\x02\u0EE6\u0EE7\x03\x02\x02" +
		"\x02\u0EE7\u0EE8\x03\x02\x02\x02\u0EE8\u0EFE\x07\u0176\x02\x02\u0EE9\u0EEB" +
		"\x07\u0165\x02\x02\u0EEA\u0EE9\x03\x02\x02\x02\u0EEA\u0EEB\x03\x02\x02" +
		"\x02\u0EEB\u0EEC\x03\x02\x02\x02\u0EEC\u0EFE\x07\u0177\x02\x02\u0EED\u0EEF" +
		"\x07\u0165\x02\x02\u0EEE\u0EED\x03\x02\x02\x02\u0EEE\u0EEF\x03\x02\x02" +
		"\x02\u0EEF\u0EF0\x03\x02\x02\x02\u0EF0\u0EFE\x07\u0178\x02\x02\u0EF1\u0EF3" +
		"\x07\u0165\x02\x02\u0EF2\u0EF1\x03\x02\x02\x02\u0EF2\u0EF3\x03\x02\x02" +
		"\x02\u0EF3\u0EF4\x03\x02\x02\x02\u0EF4\u0EFE\x07\u017D\x02\x02\u0EF5\u0EF7" +
		"\x07\u0165\x02\x02\u0EF6\u0EF5\x03\x02\x02\x02\u0EF6\u0EF7\x03\x02\x02" +
		"\x02\u0EF7\u0EF8\x03\x02\x02\x02\u0EF8\u0EFE\x07\u017C\x02\x02\u0EF9\u0EFB" +
		"\x07\u0165\x02\x02\u0EFA\u0EF9\x03\x02\x02\x02\u0EFA\u0EFB\x03\x02\x02" +
		"\x02\u0EFB\u0EFC\x03\x02\x02\x02\u0EFC\u0EFE\x07\u017E\x02\x02\u0EFD\u0ED6" +
		"\x03\x02\x02\x02\u0EFD\u0EDA\x03\x02\x02\x02\u0EFD\u0EDE\x03\x02\x02\x02" +
		"\u0EFD\u0EE2\x03\x02\x02\x02\u0EFD\u0EE6\x03\x02\x02\x02\u0EFD\u0EEA\x03" +
		"\x02\x02\x02\u0EFD\u0EEE\x03\x02\x02\x02\u0EFD\u0EF2\x03\x02\x02\x02\u0EFD" +
		"\u0EF6\x03\x02\x02\x02\u0EFD\u0EFA\x03\x02\x02\x02\u0EFE\u017F\x03\x02" +
		"\x02\x02\u0EFF\u0F00\x07\u013B\x02\x02\u0F00\u0F0B\x05\u013E\xA0\x02\u0F01" +
		"\u0F0B\x05\x1A\x0E\x02\u0F02\u0F0B\x05\u013A\x9E\x02\u0F03\u0F04\t<\x02" +
		"\x02\u0F04\u0F05\x07\xC3\x02\x02\u0F05\u0F0B\x07\xC4\x02\x02\u0F06\u0F07" +
		"\x07\u0109\x02\x02\u0F07\u0F0B\x05\u014A\xA6\x02\u0F08\u0F09\x07a\x02" +
		"\x02\u0F09\u0F0B\x07T\x02\x02\u0F0A\u0EFF\x03\x02\x02\x02\u0F0A\u0F01" +
		"\x03\x02\x02\x02\u0F0A\u0F02\x03\x02\x02\x02\u0F0A\u0F03\x03\x02\x02\x02" +
		"\u0F0A\u0F06\x03\x02\x02\x02\u0F0A\u0F08\x03\x02\x02\x02\u0F0B\u0181\x03" +
		"\x02\x02\x02\u0F0C\u0F0D\t=\x02\x02\u0F0D\u0183\x03\x02\x02\x02\u0F0E" +
		"\u0F11\x05\u0182\xC2\x02\u0F0F\u0F11\x07\xC4\x02\x02\u0F10\u0F0E\x03\x02" +
		"\x02\x02\u0F10\u0F0F\x03\x02\x02\x02\u0F11\u0185\x03\x02\x02\x02\u0F12" +
		"\u0F15\x07\u0179\x02\x02\u0F13\u0F15\x05\u0182\xC2\x02\u0F14\u0F12\x03" +
		"\x02\x02\x02\u0F14\u0F13\x03\x02\x02\x02\u0F15\u0187\x03\x02\x02\x02\u0F16" +
		"\u0F17\t>\x02\x02\u0F17\u0189\x03\x02\x02\x02\u0F18\u0F19\t?\x02\x02\u0F19" +
		"\u018B\x03\x02\x02\x02\u0F1A\u0F1B\t@\x02\x02\u0F1B\u018D\x03\x02\x02" +
		"\x02\u01FA\u0191\u0198\u019C\u01A9\u01AE\u01B6\u01B8\u01CB\u01CF\u01D5" +
		"\u01D8\u01DB\u01E2\u01E5\u01E9\u01EC\u01F1\u01FC\u01FE\u0206\u0209\u020D" +
		"\u0210\u0216\u0221\u0227\u022C\u024D\u0257\u0262\u026D\u0278\u027D\u0286" +
		"\u028A\u0290\u0294\u0299\u029F\u02AB\u02B3\u02B9\u02C4\u02C8\u02CD\u02DC" +
		"\u02E0\u02E7\u02EB\u02F1\u02FF\u0303\u0308\u030E\u0311\u0314\u0318\u031C" +
		"\u0324\u0326\u032F\u0332\u033B\u0340\u0346\u034D\u0350\u0354\u035F\u0362" +
		"\u0366\u036A\u0370\u0373\u0377\u037A\u0380\u0385\u0389\u0390\u0393\u0396" +
		"\u039D\u03A2\u03AB\u03B3\u03B9\u03BC\u03BF\u03C5\u03C9\u03CE\u03D1\u03D5" +
		"\u03D7\u03DF\u03E7\u03EA\u03EF\u03F5\u03FA\u03FD\u0401\u0404\u0408\u0424" +
		"\u0427\u042B\u0431\u0434\u0437\u043C\u0444\u0449\u044F\u0455\u0458\u045F" +
		"\u0466\u046E\u047F\u049A\u049D\u04A3\u04AC\u04B5\u04BB\u04C0\u04C5\u04CC" +
		"\u04D1\u04D6\u04DE\u04E1\u04E5\u04F1\u04F5\u04FC\u0570\u0578\u0580\u0589" +
		"\u0593\u0597\u059A\u059E\u05A4\u05B0\u05BC\u05C1\u05CA\u05D2\u05D7\u05D9" +
		"\u05E1\u05E6\u05EA\u05ED\u05F5\u05FA\u0603\u0608\u060B\u0610\u0614\u0619" +
		"\u061B\u061F\u0628\u0630\u0636\u0641\u0648\u0651\u0656\u0659\u066F\u0671" +
		"\u067A\u0681\u0684\u068B\u068F\u0695\u069D\u06A4\u06A7\u06AF\u06BA\u06C5" +
		"\u06CD\u06D3\u06DF\u06E6\u06ED\u06F9\u0701\u0707\u070D\u0710\u0725\u0730" +
		"\u0739\u073C\u0745\u0748\u0751\u0754\u075D\u0760\u0763\u0768\u076A\u076E" +
		"\u0779\u077F\u0785\u0788\u078A\u0796\u079A\u079D\u07A1\u07A7\u07AB\u07B3" +
		"\u07B7\u07BA\u07BD\u07C0\u07C4\u07C8\u07CD\u07D1\u07D4\u07D7\u07DA\u07DE" +
		"\u07E3\u07E7\u07EA\u07ED\u07F0\u07F2\u07F8\u07FF\u0804\u0807\u080A\u080E" +
		"\u0818\u081C\u081E\u0821\u0825\u082B\u082F\u083A\u0844\u0848\u0854\u0860" +
		"\u086F\u0874\u087A\u0881\u0891\u0896\u08A3\u08A8\u08B0\u08B6\u08BA\u08BD" +
		"\u08C2\u08C9\u08CF\u08D8\u08E2\u08F1\u08F6\u08F8\u08FD\u0906\u0913\u0918" +
		"\u091C\u0923\u0928\u092C\u092F\u0932\u0940\u094D\u0952\u0956\u0959\u095D" +
		"\u0963\u0966\u096D\u0979\u0984\u0991\u099C\u09A1\u09A9\u09AE\u09BC\u09C5" +
		"\u09C8\u09CD\u09D4\u09D7\u09DC\u09E2\u09E6\u09EB\u09F0\u09F4\u09FA\u09FE" +
		"\u0A01\u0A06\u0A09\u0A0E\u0A12\u0A15\u0A18\u0A1E\u0A23\u0A2A\u0A2D\u0A3F" +
		"\u0A41\u0A44\u0A4F\u0A58\u0A5F\u0A67\u0A6E\u0A72\u0A75\u0A7D\u0A85\u0A8B" +
		"\u0A93\u0A9B\u0AA2\u0AA9\u0AAB\u0AB8\u0ABE\u0AC0\u0ACA\u0AD0\u0AD2\u0ADA" +
		"\u0ADE\u0AE7\u0AEA\u0AF0\u0AF4\u0AF6\u0AFF\u0B0B\u0B0D\u0B14\u0B1B\u0B21" +
		"\u0B27\u0B29\u0B30\u0B38\u0B40\u0B46\u0B4B\u0B52\u0B58\u0B5B\u0B5F\u0B61" +
		"\u0B68\u0B71\u0B78\u0B82\u0B87\u0B8B\u0B95\u0B9C\u0BA9\u0BAB\u0BB3\u0BB5" +
		"\u0BB9\u0BC1\u0BCA\u0BD0\u0BD8\u0BDD\u0BE9\u0BEE\u0BF1\u0BF7\u0BFB\u0C00" +
		"\u0C05\u0C0A\u0C10\u0C25\u0C27\u0C32\u0C3E\u0C4A\u0C4E\u0C57\u0C5B\u0C6D" +
		"\u0C70\u0C78\u0C81\u0C8A\u0CA1\u0CB1\u0CB8\u0CBB\u0CC4\u0CC8\u0CCC\u0CD8" +
		"\u0CF1\u0CF8\u0CFB\u0D0A\u0D1F\u0D23\u0D25\u0D2F\u0D31\u0D3B\u0D4A\u0D4C" +
		"\u0D59\u0D5D\u0D64\u0D69\u0D71\u0D76\u0D7F\u0D9F\u0DB0\u0DB4\u0DBA\u0DC0" +
		"\u0DC9\u0DCD\u0DCF\u0DD6\u0DDE\u0DE6\u0DEE\u0DF6\u0E03\u0E0A\u0E0D\u0E14" +
		"\u0E1C\u0E24\u0E32\u0E37\u0E3C\u0E3F\u0E4C\u0E60\u0E6A\u0E6D\u0E76\u0E79" +
		"\u0E7B\u0E7E\u0E81\u0E93\u0E9C\u0EA3\u0EAF\u0EB8\u0EC2\u0EC5\u0EC9\u0ECF" +
		"\u0ED6\u0EDA\u0EDE\u0EE2\u0EE6\u0EEA\u0EEE\u0EF2\u0EF6\u0EFA\u0EFD\u0F0A" +
		"\u0F10\u0F14";
	public static readonly _serializedATN: string = Utils.join(
		[
			SparkSqlParser._serializedATNSegment0,
			SparkSqlParser._serializedATNSegment1,
			SparkSqlParser._serializedATNSegment2,
			SparkSqlParser._serializedATNSegment3,
			SparkSqlParser._serializedATNSegment4,
			SparkSqlParser._serializedATNSegment5,
			SparkSqlParser._serializedATNSegment6,
			SparkSqlParser._serializedATNSegment7,
		],
		"",
	);
	public static __ATN: ATN;
	public static get _ATN(): ATN {
		if (!SparkSqlParser.__ATN) {
			SparkSqlParser.__ATN = new ATNDeserializer().deserialize(Utils.toCharArray(SparkSqlParser._serializedATN));
		}

		return SparkSqlParser.__ATN;
	}

}

export class ProgramContext extends ParserRuleContext {
	public EOF(): TerminalNode { return this.getToken(SparkSqlParser.EOF, 0); }
	public singleStatement(): SingleStatementContext[];
	public singleStatement(i: number): SingleStatementContext;
	public singleStatement(i?: number): SingleStatementContext | SingleStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SingleStatementContext);
		} else {
			return this.getRuleContext(i, SingleStatementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_program; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterProgram) {
			listener.enterProgram(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitProgram) {
			listener.exitProgram(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitProgram) {
			return visitor.visitProgram(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SingleStatementContext extends ParserRuleContext {
	public statement(): StatementContext {
		return this.getRuleContext(0, StatementContext);
	}
	public SEMICOLON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SEMICOLON, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_singleStatement; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSingleStatement) {
			listener.enterSingleStatement(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSingleStatement) {
			listener.exitSingleStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSingleStatement) {
			return visitor.visitSingleStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StatementContext extends ParserRuleContext {
	public _pattern!: StringLitContext;
	public _target!: TableNameCreateContext;
	public _source!: TableNameContext;
	public _tableProps!: PropertyListContext;
	public _table!: TableNameContext;
	public _column!: ColumnNameContext;
	public _colName!: ColumnNameContext;
	public _className!: StringLitContext;
	public _ns!: DbSchemaNameContext;
	public _key!: PropertyKeyContext;
	public _legacy!: MultipartIdentifierContext;
	public _option!: Token;
	public _options!: PropertyListContext;
	public _path!: StringLitContext;
	public _op!: Token;
	public _indexType!: IdentifierContext;
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public dmlStatementNoWith(): DmlStatementNoWithContext | undefined {
		return this.tryGetRuleContext(0, DmlStatementNoWithContext);
	}
	public ctes(): CtesContext | undefined {
		return this.tryGetRuleContext(0, CtesContext);
	}
	public KW_USE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USE, 0); }
	public dbSchemaName(): DbSchemaNameContext | undefined {
		return this.tryGetRuleContext(0, DbSchemaNameContext);
	}
	public dbSchema(): DbSchemaContext | undefined {
		return this.tryGetRuleContext(0, DbSchemaContext);
	}
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOG, 0); }
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
	public dbSchemaNameCreate(): DbSchemaNameCreateContext | undefined {
		return this.tryGetRuleContext(0, DbSchemaNameCreateContext);
	}
	public ifNotExists(): IfNotExistsContext | undefined {
		return this.tryGetRuleContext(0, IfNotExistsContext);
	}
	public commentSpec(): CommentSpecContext[];
	public commentSpec(i: number): CommentSpecContext;
	public commentSpec(i?: number): CommentSpecContext | CommentSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CommentSpecContext);
		} else {
			return this.getRuleContext(i, CommentSpecContext);
		}
	}
	public locationSpec(): LocationSpecContext[];
	public locationSpec(i: number): LocationSpecContext;
	public locationSpec(i?: number): LocationSpecContext | LocationSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LocationSpecContext);
		} else {
			return this.getRuleContext(i, LocationSpecContext);
		}
	}
	public KW_WITH(): TerminalNode[];
	public KW_WITH(i: number): TerminalNode;
	public KW_WITH(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_WITH);
		} else {
			return this.getToken(SparkSqlParser.KW_WITH, i);
		}
	}
	public propertyList(): PropertyListContext[];
	public propertyList(i: number): PropertyListContext;
	public propertyList(i?: number): PropertyListContext | PropertyListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PropertyListContext);
		} else {
			return this.getRuleContext(i, PropertyListContext);
		}
	}
	public KW_DBPROPERTIES(): TerminalNode[];
	public KW_DBPROPERTIES(i: number): TerminalNode;
	public KW_DBPROPERTIES(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_DBPROPERTIES);
		} else {
			return this.getToken(SparkSqlParser.KW_DBPROPERTIES, i);
		}
	}
	public KW_PROPERTIES(): TerminalNode[];
	public KW_PROPERTIES(i: number): TerminalNode;
	public KW_PROPERTIES(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_PROPERTIES);
		} else {
			return this.getToken(SparkSqlParser.KW_PROPERTIES, i);
		}
	}
	public KW_ALTER(): TerminalNode[];
	public KW_ALTER(i: number): TerminalNode;
	public KW_ALTER(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_ALTER);
		} else {
			return this.getToken(SparkSqlParser.KW_ALTER, i);
		}
	}
	public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
	public ifExists(): IfExistsContext | undefined {
		return this.tryGetRuleContext(0, IfExistsContext);
	}
	public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESTRICT, 0); }
	public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASCADE, 0); }
	public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
	public dbSchemas(): DbSchemasContext | undefined {
		return this.tryGetRuleContext(0, DbSchemasContext);
	}
	public multipartIdentifier(): MultipartIdentifierContext | undefined {
		return this.tryGetRuleContext(0, MultipartIdentifierContext);
	}
	public KW_FROM(): TerminalNode[];
	public KW_FROM(i: number): TerminalNode;
	public KW_FROM(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_FROM);
		} else {
			return this.getToken(SparkSqlParser.KW_FROM, i);
		}
	}
	public KW_IN(): TerminalNode[];
	public KW_IN(i: number): TerminalNode;
	public KW_IN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_IN);
		} else {
			return this.getToken(SparkSqlParser.KW_IN, i);
		}
	}
	public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
	public createTableHeader(): CreateTableHeaderContext | undefined {
		return this.tryGetRuleContext(0, CreateTableHeaderContext);
	}
	public createTableClauses(): CreateTableClausesContext | undefined {
		return this.tryGetRuleContext(0, CreateTableClausesContext);
	}
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext | undefined {
		return this.tryGetRuleContext(0, CreateOrReplaceTableColTypeListContext);
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public tableProvider(): TableProviderContext[];
	public tableProvider(i: number): TableProviderContext;
	public tableProvider(i?: number): TableProviderContext | TableProviderContext[] {
		if (i === undefined) {
			return this.getRuleContexts(TableProviderContext);
		} else {
			return this.getRuleContext(i, TableProviderContext);
		}
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
	public tableNameCreate(): TableNameCreateContext | undefined {
		return this.tryGetRuleContext(0, TableNameCreateContext);
	}
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	public rowFormat(): RowFormatContext[];
	public rowFormat(i: number): RowFormatContext;
	public rowFormat(i?: number): RowFormatContext | RowFormatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(RowFormatContext);
		} else {
			return this.getRuleContext(i, RowFormatContext);
		}
	}
	public createFileFormat(): CreateFileFormatContext[];
	public createFileFormat(i: number): CreateFileFormatContext;
	public createFileFormat(i?: number): CreateFileFormatContext | CreateFileFormatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CreateFileFormatContext);
		} else {
			return this.getRuleContext(i, CreateFileFormatContext);
		}
	}
	public KW_TBLPROPERTIES(): TerminalNode[];
	public KW_TBLPROPERTIES(i: number): TerminalNode;
	public KW_TBLPROPERTIES(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
		} else {
			return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
		}
	}
	public replaceTableHeader(): ReplaceTableHeaderContext | undefined {
		return this.tryGetRuleContext(0, ReplaceTableHeaderContext);
	}
	public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANALYZE, 0); }
	public KW_COMPUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPUTE, 0); }
	public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STATISTICS, 0); }
	public partitionSpec(): PartitionSpecContext[];
	public partitionSpec(i: number): PartitionSpecContext;
	public partitionSpec(i?: number): PartitionSpecContext | PartitionSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PartitionSpecContext);
		} else {
			return this.getRuleContext(i, PartitionSpecContext);
		}
	}
	public KW_NOSCAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOSCAN, 0); }
	public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
	public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
	public columnNameSeq(): ColumnNameSeqContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameSeqContext);
	}
	public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
	public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLES, 0); }
	public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ADD, 0); }
	public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMN, 0); }
	public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext | undefined {
		return this.tryGetRuleContext(0, QualifiedColTypeWithPositionForAddContext);
	}
	public qualifiedColTypeWithPositionSeqForAdd(): QualifiedColTypeWithPositionSeqForAddContext | undefined {
		return this.tryGetRuleContext(0, QualifiedColTypeWithPositionSeqForAddContext);
	}
	public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RENAME, 0); }
	public columnName(): ColumnNameContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameContext);
	}
	public KW_TO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TO, 0); }
	public columnNameCreate(): ColumnNameCreateContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameCreateContext);
	}
	public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEW, 0); }
	public viewName(): ViewNameContext | undefined {
		return this.tryGetRuleContext(0, ViewNameContext);
	}
	public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNSET, 0); }
	public KW_CHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHANGE, 0); }
	public alterColumnAction(): AlterColumnActionContext | undefined {
		return this.tryGetRuleContext(0, AlterColumnActionContext);
	}
	public colType(): ColTypeContext | undefined {
		return this.tryGetRuleContext(0, ColTypeContext);
	}
	public colPosition(): ColPositionContext | undefined {
		return this.tryGetRuleContext(0, ColPositionContext);
	}
	public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
	public qualifiedColTypeWithPositionSeqForReplace(): QualifiedColTypeWithPositionSeqForReplaceContext | undefined {
		return this.tryGetRuleContext(0, QualifiedColTypeWithPositionSeqForReplaceContext);
	}
	public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
	public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
	public partitionSpecLocation(): PartitionSpecLocationContext[];
	public partitionSpecLocation(i: number): PartitionSpecLocationContext;
	public partitionSpecLocation(i?: number): PartitionSpecLocationContext | PartitionSpecLocationContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PartitionSpecLocationContext);
		} else {
			return this.getRuleContext(i, PartitionSpecLocationContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PURGE, 0); }
	public KW_RECOVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECOVER, 0); }
	public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONS, 0); }
	public viewNameCreate(): ViewNameCreateContext | undefined {
		return this.tryGetRuleContext(0, ViewNameCreateContext);
	}
	public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
	public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
	public identifierCommentList(): IdentifierCommentListContext | undefined {
		return this.tryGetRuleContext(0, IdentifierCommentListContext);
	}
	public KW_PARTITIONED(): TerminalNode[];
	public KW_PARTITIONED(i: number): TerminalNode;
	public KW_PARTITIONED(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_PARTITIONED);
		} else {
			return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
		}
	}
	public KW_ON(): TerminalNode[];
	public KW_ON(i: number): TerminalNode;
	public KW_ON(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_ON);
		} else {
			return this.getToken(SparkSqlParser.KW_ON, i);
		}
	}
	public identifierList(): IdentifierListContext[];
	public identifierList(i: number): IdentifierListContext;
	public identifierList(i?: number): IdentifierListContext | IdentifierListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierListContext);
		} else {
			return this.getRuleContext(i, IdentifierListContext);
		}
	}
	public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GLOBAL, 0); }
	public colTypeList(): ColTypeListContext | undefined {
		return this.tryGetRuleContext(0, ColTypeListContext);
	}
	public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
	public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTION, 0); }
	public functionNameCreate(): FunctionNameCreateContext | undefined {
		return this.tryGetRuleContext(0, FunctionNameCreateContext);
	}
	public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
	public resource(): ResourceContext[];
	public resource(i: number): ResourceContext;
	public resource(i?: number): ResourceContext | ResourceContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ResourceContext);
		} else {
			return this.getRuleContext(i, ResourceContext);
		}
	}
	public functionName(): FunctionNameContext | undefined {
		return this.tryGetRuleContext(0, FunctionNameContext);
	}
	public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECLARE, 0); }
	public KW_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARIABLE, 0); }
	public dataType(): DataTypeContext | undefined {
		return this.tryGetRuleContext(0, DataTypeContext);
	}
	public variableDefaultExpression(): VariableDefaultExpressionContext | undefined {
		return this.tryGetRuleContext(0, VariableDefaultExpressionContext);
	}
	public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPLAIN, 0); }
	public statement(): StatementContext | undefined {
		return this.tryGetRuleContext(0, StatementContext);
	}
	public KW_LOGICAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOGICAL, 0); }
	public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMATTED, 0); }
	public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTENDED, 0); }
	public KW_CODEGEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CODEGEN, 0); }
	public KW_COST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COST, 0); }
	public propertyKey(): PropertyKeyContext | undefined {
		return this.tryGetRuleContext(0, PropertyKeyContext);
	}
	public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEWS, 0); }
	public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTIONS, 0); }
	public functionKind(): FunctionKindContext | undefined {
		return this.tryGetRuleContext(0, FunctionKindContext);
	}
	public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
	public KW_CATALOGS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOGS, 0); }
	public describeFuncName(): DescribeFuncNameContext | undefined {
		return this.tryGetRuleContext(0, DescribeFuncNameContext);
	}
	public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
	public KW_DESCRIBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESCRIBE, 0); }
	public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
	public describeColName(): DescribeColNameContext | undefined {
		return this.tryGetRuleContext(0, DescribeColNameContext);
	}
	public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUERY, 0); }
	public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMENT, 0); }
	public KW_IS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IS, 0); }
	public comment(): CommentContext | undefined {
		return this.tryGetRuleContext(0, CommentContext);
	}
	public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFRESH, 0); }
	public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CACHE, 0); }
	public KW_LAZY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAZY, 0); }
	public KW_UNCACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNCACHE, 0); }
	public KW_CLEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLEAR, 0); }
	public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOAD, 0); }
	public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATA, 0); }
	public KW_INPATH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPATH, 0); }
	public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
	public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
	public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
	public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUNCATE, 0); }
	public KW_REPAIR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPAIR, 0); }
	public KW_MSCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MSCK, 0); }
	public KW_SYNC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYNC, 0); }
	public KW_LIST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIST, 0); }
	public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
	public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIME, 0); }
	public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ZONE, 0); }
	public interval(): IntervalContext | undefined {
		return this.tryGetRuleContext(0, IntervalContext);
	}
	public timezone(): TimezoneContext | undefined {
		return this.tryGetRuleContext(0, TimezoneContext);
	}
	public assignmentList(): AssignmentListContext | undefined {
		return this.tryGetRuleContext(0, AssignmentListContext);
	}
	public KW_VAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VAR, 0); }
	public multipartIdentifierList(): MultipartIdentifierListContext | undefined {
		return this.tryGetRuleContext(0, MultipartIdentifierListContext);
	}
	public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
	public configKey(): ConfigKeyContext | undefined {
		return this.tryGetRuleContext(0, ConfigKeyContext);
	}
	public configValue(): ConfigValueContext | undefined {
		return this.tryGetRuleContext(0, ConfigValueContext);
	}
	public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESET, 0); }
	public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
	public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext | undefined {
		return this.tryGetRuleContext(0, MultipartIdentifierPropertyListContext);
	}
	public unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext | undefined {
		return this.tryGetRuleContext(0, UnsupportedHiveNativeCommandsContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_statement; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterStatement) {
			listener.enterStatement(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitStatement) {
			listener.exitStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitStatement) {
			return visitor.visitStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TimezoneContext extends ParserRuleContext {
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_timezone; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTimezone) {
			listener.enterTimezone(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTimezone) {
			listener.exitTimezone(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTimezone) {
			return visitor.visitTimezone(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ConfigKeyContext extends ParserRuleContext {
	public quotedIdentifier(): QuotedIdentifierContext {
		return this.getRuleContext(0, QuotedIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_configKey; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterConfigKey) {
			listener.enterConfigKey(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitConfigKey) {
			listener.exitConfigKey(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitConfigKey) {
			return visitor.visitConfigKey(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ConfigValueContext extends ParserRuleContext {
	public backQuotedIdentifier(): BackQuotedIdentifierContext {
		return this.getRuleContext(0, BackQuotedIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_configValue; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterConfigValue) {
			listener.enterConfigValue(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitConfigValue) {
			listener.exitConfigValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitConfigValue) {
			return visitor.visitConfigValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnsupportedHiveNativeCommandsContext extends ParserRuleContext {
	public _kw1!: Token;
	public _kw2!: Token;
	public _kw3!: Token;
	public _kw4!: Token;
	public _kw5!: Token;
	public _kw6!: Token;
	public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
	public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
	public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
	public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GRANT, 0); }
	public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REVOKE, 0); }
	public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
	public KW_PRINCIPALS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRINCIPALS, 0); }
	public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLES, 0); }
	public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
	public KW_EXPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPORT, 0); }
	public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
	public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IMPORT, 0); }
	public KW_COMPACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACTIONS, 0); }
	public KW_TRANSACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTIONS, 0); }
	public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEXES, 0); }
	public KW_LOCKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCKS, 0); }
	public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
	public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALTER, 0); }
	public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCK, 0); }
	public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
	public KW_UNLOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNLOCK, 0); }
	public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
	public KW_MACRO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MACRO, 0); }
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_CLUSTERED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTERED, 0); }
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
	public KW_SKEWED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SKEWED, 0); }
	public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCATION, 0); }
	public KW_EXCHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCHANGE, 0); }
	public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
	public KW_ARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARCHIVE, 0); }
	public KW_UNARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNARCHIVE, 0); }
	public KW_TOUCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TOUCH, 0); }
	public KW_COMPACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACT, 0); }
	public partitionSpec(): PartitionSpecContext | undefined {
		return this.tryGetRuleContext(0, PartitionSpecContext);
	}
	public KW_CONCATENATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONCATENATE, 0); }
	public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILEFORMAT, 0); }
	public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
	public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
	public KW_START(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_START, 0); }
	public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTION, 0); }
	public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMIT, 0); }
	public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLBACK, 0); }
	public KW_DFS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DFS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unsupportedHiveNativeCommands; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnsupportedHiveNativeCommands) {
			listener.enterUnsupportedHiveNativeCommands(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnsupportedHiveNativeCommands) {
			listener.exitUnsupportedHiveNativeCommands(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnsupportedHiveNativeCommands) {
			return visitor.visitUnsupportedHiveNativeCommands(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CreateTableHeaderContext extends ParserRuleContext {
	public KW_CREATE(): TerminalNode { return this.getToken(SparkSqlParser.KW_CREATE, 0); }
	public KW_TABLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLE, 0); }
	public tableNameCreate(): TableNameCreateContext {
		return this.getRuleContext(0, TableNameCreateContext);
	}
	public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
	public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTERNAL, 0); }
	public ifNotExists(): IfNotExistsContext | undefined {
		return this.tryGetRuleContext(0, IfNotExistsContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_createTableHeader; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCreateTableHeader) {
			listener.enterCreateTableHeader(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCreateTableHeader) {
			listener.exitCreateTableHeader(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCreateTableHeader) {
			return visitor.visitCreateTableHeader(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ReplaceTableHeaderContext extends ParserRuleContext {
	public KW_REPLACE(): TerminalNode { return this.getToken(SparkSqlParser.KW_REPLACE, 0); }
	public KW_TABLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLE, 0); }
	public tableNameCreate(): TableNameCreateContext {
		return this.getRuleContext(0, TableNameCreateContext);
	}
	public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
	public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_replaceTableHeader; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterReplaceTableHeader) {
			listener.enterReplaceTableHeader(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitReplaceTableHeader) {
			listener.exitReplaceTableHeader(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitReplaceTableHeader) {
			return visitor.visitReplaceTableHeader(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BucketSpecContext extends ParserRuleContext {
	public KW_CLUSTERED(): TerminalNode { return this.getToken(SparkSqlParser.KW_CLUSTERED, 0); }
	public KW_BY(): TerminalNode[];
	public KW_BY(i: number): TerminalNode;
	public KW_BY(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_BY);
		} else {
			return this.getToken(SparkSqlParser.KW_BY, i);
		}
	}
	public identifierList(): IdentifierListContext {
		return this.getRuleContext(0, IdentifierListContext);
	}
	public KW_INTO(): TerminalNode { return this.getToken(SparkSqlParser.KW_INTO, 0); }
	public INTEGER_VALUE(): TerminalNode { return this.getToken(SparkSqlParser.INTEGER_VALUE, 0); }
	public KW_BUCKETS(): TerminalNode { return this.getToken(SparkSqlParser.KW_BUCKETS, 0); }
	public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
	public orderedIdentifierList(): OrderedIdentifierListContext | undefined {
		return this.tryGetRuleContext(0, OrderedIdentifierListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_bucketSpec; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterBucketSpec) {
			listener.enterBucketSpec(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitBucketSpec) {
			listener.exitBucketSpec(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitBucketSpec) {
			return visitor.visitBucketSpec(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SkewSpecContext extends ParserRuleContext {
	public KW_SKEWED(): TerminalNode { return this.getToken(SparkSqlParser.KW_SKEWED, 0); }
	public KW_BY(): TerminalNode { return this.getToken(SparkSqlParser.KW_BY, 0); }
	public identifierList(): IdentifierListContext {
		return this.getRuleContext(0, IdentifierListContext);
	}
	public KW_ON(): TerminalNode { return this.getToken(SparkSqlParser.KW_ON, 0); }
	public constantList(): ConstantListContext | undefined {
		return this.tryGetRuleContext(0, ConstantListContext);
	}
	public nestedConstantList(): NestedConstantListContext | undefined {
		return this.tryGetRuleContext(0, NestedConstantListContext);
	}
	public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_skewSpec; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSkewSpec) {
			listener.enterSkewSpec(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSkewSpec) {
			listener.exitSkewSpec(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSkewSpec) {
			return visitor.visitSkewSpec(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class LocationSpecContext extends ParserRuleContext {
	public KW_LOCATION(): TerminalNode { return this.getToken(SparkSqlParser.KW_LOCATION, 0); }
	public stringLit(): StringLitContext {
		return this.getRuleContext(0, StringLitContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_locationSpec; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterLocationSpec) {
			listener.enterLocationSpec(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitLocationSpec) {
			listener.exitLocationSpec(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitLocationSpec) {
			return visitor.visitLocationSpec(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CommentSpecContext extends ParserRuleContext {
	public KW_COMMENT(): TerminalNode { return this.getToken(SparkSqlParser.KW_COMMENT, 0); }
	public stringLit(): StringLitContext {
		return this.getRuleContext(0, StringLitContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_commentSpec; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCommentSpec) {
			listener.enterCommentSpec(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCommentSpec) {
			listener.exitCommentSpec(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCommentSpec) {
			return visitor.visitCommentSpec(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QueryContext extends ParserRuleContext {
	public queryTerm(): QueryTermContext {
		return this.getRuleContext(0, QueryTermContext);
	}
	public queryOrganization(): QueryOrganizationContext {
		return this.getRuleContext(0, QueryOrganizationContext);
	}
	public ctes(): CtesContext | undefined {
		return this.tryGetRuleContext(0, CtesContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_query; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQuery) {
			listener.enterQuery(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQuery) {
			listener.exitQuery(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQuery) {
			return visitor.visitQuery(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class InsertIntoContext extends ParserRuleContext {
	public _path!: StringLitContext;
	public _options!: PropertyListContext;
	public KW_INSERT(): TerminalNode { return this.getToken(SparkSqlParser.KW_INSERT, 0); }
	public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
	public partitionSpec(): PartitionSpecContext | undefined {
		return this.tryGetRuleContext(0, PartitionSpecContext);
	}
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAME, 0); }
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public columnNameSeq(): ColumnNameSeqContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameSeqContext);
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public ifNotExists(): IfNotExistsContext | undefined {
		return this.tryGetRuleContext(0, IfNotExistsContext);
	}
	public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
	public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
	public whereClause(): WhereClauseContext | undefined {
		return this.tryGetRuleContext(0, WhereClauseContext);
	}
	public KW_DIRECTORY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORY, 0); }
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
	public rowFormat(): RowFormatContext | undefined {
		return this.tryGetRuleContext(0, RowFormatContext);
	}
	public createFileFormat(): CreateFileFormatContext | undefined {
		return this.tryGetRuleContext(0, CreateFileFormatContext);
	}
	public tableProvider(): TableProviderContext | undefined {
		return this.tryGetRuleContext(0, TableProviderContext);
	}
	public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
	public propertyList(): PropertyListContext | undefined {
		return this.tryGetRuleContext(0, PropertyListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_insertInto; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterInsertInto) {
			listener.enterInsertInto(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitInsertInto) {
			listener.exitInsertInto(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitInsertInto) {
			return visitor.visitInsertInto(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PartitionSpecLocationContext extends ParserRuleContext {
	public partitionSpec(): PartitionSpecContext {
		return this.getRuleContext(0, PartitionSpecContext);
	}
	public locationSpec(): LocationSpecContext | undefined {
		return this.tryGetRuleContext(0, LocationSpecContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_partitionSpecLocation; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPartitionSpecLocation) {
			listener.enterPartitionSpecLocation(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPartitionSpecLocation) {
			listener.exitPartitionSpecLocation(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPartitionSpecLocation) {
			return visitor.visitPartitionSpecLocation(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PartitionSpecContext extends ParserRuleContext {
	public KW_PARTITION(): TerminalNode { return this.getToken(SparkSqlParser.KW_PARTITION, 0); }
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public partitionVal(): PartitionValContext[];
	public partitionVal(i: number): PartitionValContext;
	public partitionVal(i?: number): PartitionValContext | PartitionValContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PartitionValContext);
		} else {
			return this.getRuleContext(i, PartitionValContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_partitionSpec; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPartitionSpec) {
			listener.enterPartitionSpec(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPartitionSpec) {
			listener.exitPartitionSpec(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPartitionSpec) {
			return visitor.visitPartitionSpec(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PartitionValContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
	public constant(): ConstantContext | undefined {
		return this.tryGetRuleContext(0, ConstantContext);
	}
	public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_partitionVal; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPartitionVal) {
			listener.enterPartitionVal(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPartitionVal) {
			listener.exitPartitionVal(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPartitionVal) {
			return visitor.visitPartitionVal(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DbSchemaContext extends ParserRuleContext {
	public KW_NAMESPACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACE, 0); }
	public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
	public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMA, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchema; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDbSchema) {
			listener.enterDbSchema(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDbSchema) {
			listener.exitDbSchema(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDbSchema) {
			return visitor.visitDbSchema(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DbSchemasContext extends ParserRuleContext {
	public KW_NAMESPACES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACES, 0); }
	public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASES, 0); }
	public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMAS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchemas; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDbSchemas) {
			listener.enterDbSchemas(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDbSchemas) {
			listener.exitDbSchemas(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDbSchemas) {
			return visitor.visitDbSchemas(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DescribeFuncNameContext extends ParserRuleContext {
	public identifierReference(): IdentifierReferenceContext | undefined {
		return this.tryGetRuleContext(0, IdentifierReferenceContext);
	}
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public comparisonOperator(): ComparisonOperatorContext | undefined {
		return this.tryGetRuleContext(0, ComparisonOperatorContext);
	}
	public arithmeticOperator(): ArithmeticOperatorContext | undefined {
		return this.tryGetRuleContext(0, ArithmeticOperatorContext);
	}
	public predicateOperator(): PredicateOperatorContext | undefined {
		return this.tryGetRuleContext(0, PredicateOperatorContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_describeFuncName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDescribeFuncName) {
			listener.enterDescribeFuncName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDescribeFuncName) {
			listener.exitDescribeFuncName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDescribeFuncName) {
			return visitor.visitDescribeFuncName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DescribeColNameContext extends ParserRuleContext {
	public _identifier!: IdentifierContext;
	public _nameParts: IdentifierContext[] = [];
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public DOT(): TerminalNode[];
	public DOT(i: number): TerminalNode;
	public DOT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.DOT);
		} else {
			return this.getToken(SparkSqlParser.DOT, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_describeColName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDescribeColName) {
			listener.enterDescribeColName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDescribeColName) {
			listener.exitDescribeColName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDescribeColName) {
			return visitor.visitDescribeColName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CtesContext extends ParserRuleContext {
	public KW_WITH(): TerminalNode { return this.getToken(SparkSqlParser.KW_WITH, 0); }
	public namedQuery(): NamedQueryContext[];
	public namedQuery(i: number): NamedQueryContext;
	public namedQuery(i?: number): NamedQueryContext | NamedQueryContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NamedQueryContext);
		} else {
			return this.getRuleContext(i, NamedQueryContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_ctes; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCtes) {
			listener.enterCtes(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCtes) {
			listener.exitCtes(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCtes) {
			return visitor.visitCtes(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NamedQueryContext extends ParserRuleContext {
	public _name!: ErrorCapturingIdentifierContext;
	public _columnAliases!: IdentifierListContext;
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public query(): QueryContext {
		return this.getRuleContext(0, QueryContext);
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierContext);
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public identifierList(): IdentifierListContext | undefined {
		return this.tryGetRuleContext(0, IdentifierListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_namedQuery; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNamedQuery) {
			listener.enterNamedQuery(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNamedQuery) {
			listener.exitNamedQuery(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNamedQuery) {
			return visitor.visitNamedQuery(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TableProviderContext extends ParserRuleContext {
	public KW_USING(): TerminalNode { return this.getToken(SparkSqlParser.KW_USING, 0); }
	public multipartIdentifier(): MultipartIdentifierContext {
		return this.getRuleContext(0, MultipartIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_tableProvider; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTableProvider) {
			listener.enterTableProvider(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTableProvider) {
			listener.exitTableProvider(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTableProvider) {
			return visitor.visitTableProvider(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CreateTableClausesContext extends ParserRuleContext {
	public _options!: ExpressionPropertyListContext;
	public _partitioning!: PartitionFieldListContext;
	public _tableProps!: PropertyListContext;
	public skewSpec(): SkewSpecContext[];
	public skewSpec(i: number): SkewSpecContext;
	public skewSpec(i?: number): SkewSpecContext | SkewSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SkewSpecContext);
		} else {
			return this.getRuleContext(i, SkewSpecContext);
		}
	}
	public bucketSpec(): BucketSpecContext[];
	public bucketSpec(i: number): BucketSpecContext;
	public bucketSpec(i?: number): BucketSpecContext | BucketSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(BucketSpecContext);
		} else {
			return this.getRuleContext(i, BucketSpecContext);
		}
	}
	public rowFormat(): RowFormatContext[];
	public rowFormat(i: number): RowFormatContext;
	public rowFormat(i?: number): RowFormatContext | RowFormatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(RowFormatContext);
		} else {
			return this.getRuleContext(i, RowFormatContext);
		}
	}
	public createFileFormat(): CreateFileFormatContext[];
	public createFileFormat(i: number): CreateFileFormatContext;
	public createFileFormat(i?: number): CreateFileFormatContext | CreateFileFormatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CreateFileFormatContext);
		} else {
			return this.getRuleContext(i, CreateFileFormatContext);
		}
	}
	public locationSpec(): LocationSpecContext[];
	public locationSpec(i: number): LocationSpecContext;
	public locationSpec(i?: number): LocationSpecContext | LocationSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LocationSpecContext);
		} else {
			return this.getRuleContext(i, LocationSpecContext);
		}
	}
	public commentSpec(): CommentSpecContext[];
	public commentSpec(i: number): CommentSpecContext;
	public commentSpec(i?: number): CommentSpecContext | CommentSpecContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CommentSpecContext);
		} else {
			return this.getRuleContext(i, CommentSpecContext);
		}
	}
	public KW_OPTIONS(): TerminalNode[];
	public KW_OPTIONS(i: number): TerminalNode;
	public KW_OPTIONS(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_OPTIONS);
		} else {
			return this.getToken(SparkSqlParser.KW_OPTIONS, i);
		}
	}
	public KW_PARTITIONED(): TerminalNode[];
	public KW_PARTITIONED(i: number): TerminalNode;
	public KW_PARTITIONED(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_PARTITIONED);
		} else {
			return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
		}
	}
	public KW_BY(): TerminalNode[];
	public KW_BY(i: number): TerminalNode;
	public KW_BY(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_BY);
		} else {
			return this.getToken(SparkSqlParser.KW_BY, i);
		}
	}
	public KW_TBLPROPERTIES(): TerminalNode[];
	public KW_TBLPROPERTIES(i: number): TerminalNode;
	public KW_TBLPROPERTIES(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
		} else {
			return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
		}
	}
	public expressionPropertyList(): ExpressionPropertyListContext[];
	public expressionPropertyList(i: number): ExpressionPropertyListContext;
	public expressionPropertyList(i?: number): ExpressionPropertyListContext | ExpressionPropertyListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionPropertyListContext);
		} else {
			return this.getRuleContext(i, ExpressionPropertyListContext);
		}
	}
	public partitionFieldList(): PartitionFieldListContext[];
	public partitionFieldList(i: number): PartitionFieldListContext;
	public partitionFieldList(i?: number): PartitionFieldListContext | PartitionFieldListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PartitionFieldListContext);
		} else {
			return this.getRuleContext(i, PartitionFieldListContext);
		}
	}
	public propertyList(): PropertyListContext[];
	public propertyList(i: number): PropertyListContext;
	public propertyList(i?: number): PropertyListContext | PropertyListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PropertyListContext);
		} else {
			return this.getRuleContext(i, PropertyListContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_createTableClauses; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCreateTableClauses) {
			listener.enterCreateTableClauses(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCreateTableClauses) {
			listener.exitCreateTableClauses(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCreateTableClauses) {
			return visitor.visitCreateTableClauses(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PropertyListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public property(): PropertyContext[];
	public property(i: number): PropertyContext;
	public property(i?: number): PropertyContext | PropertyContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PropertyContext);
		} else {
			return this.getRuleContext(i, PropertyContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_propertyList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPropertyList) {
			listener.enterPropertyList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPropertyList) {
			listener.exitPropertyList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPropertyList) {
			return visitor.visitPropertyList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PropertyContext extends ParserRuleContext {
	public _key!: PropertyKeyContext;
	public _value!: PropertyValueContext;
	public propertyKey(): PropertyKeyContext {
		return this.getRuleContext(0, PropertyKeyContext);
	}
	public propertyValue(): PropertyValueContext | undefined {
		return this.tryGetRuleContext(0, PropertyValueContext);
	}
	public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_property; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterProperty) {
			listener.enterProperty(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitProperty) {
			listener.exitProperty(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitProperty) {
			return visitor.visitProperty(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PropertyKeyContext extends ParserRuleContext {
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public DOT(): TerminalNode[];
	public DOT(i: number): TerminalNode;
	public DOT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.DOT);
		} else {
			return this.getToken(SparkSqlParser.DOT, i);
		}
	}
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_propertyKey; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPropertyKey) {
			listener.enterPropertyKey(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPropertyKey) {
			listener.exitPropertyKey(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPropertyKey) {
			return visitor.visitPropertyKey(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PropertyValueContext extends ParserRuleContext {
	public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
	public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
	public booleanValue(): BooleanValueContext | undefined {
		return this.tryGetRuleContext(0, BooleanValueContext);
	}
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_propertyValue; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPropertyValue) {
			listener.enterPropertyValue(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPropertyValue) {
			listener.exitPropertyValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPropertyValue) {
			return visitor.visitPropertyValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExpressionPropertyListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public expressionProperty(): ExpressionPropertyContext[];
	public expressionProperty(i: number): ExpressionPropertyContext;
	public expressionProperty(i?: number): ExpressionPropertyContext | ExpressionPropertyContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionPropertyContext);
		} else {
			return this.getRuleContext(i, ExpressionPropertyContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_expressionPropertyList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterExpressionPropertyList) {
			listener.enterExpressionPropertyList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitExpressionPropertyList) {
			listener.exitExpressionPropertyList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitExpressionPropertyList) {
			return visitor.visitExpressionPropertyList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExpressionPropertyContext extends ParserRuleContext {
	public _key!: PropertyKeyContext;
	public _value!: ExpressionContext;
	public propertyKey(): PropertyKeyContext {
		return this.getRuleContext(0, PropertyKeyContext);
	}
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_expressionProperty; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterExpressionProperty) {
			listener.enterExpressionProperty(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitExpressionProperty) {
			listener.exitExpressionProperty(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitExpressionProperty) {
			return visitor.visitExpressionProperty(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ConstantListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public constant(): ConstantContext[];
	public constant(i: number): ConstantContext;
	public constant(i?: number): ConstantContext | ConstantContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ConstantContext);
		} else {
			return this.getRuleContext(i, ConstantContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_constantList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterConstantList) {
			listener.enterConstantList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitConstantList) {
			listener.exitConstantList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitConstantList) {
			return visitor.visitConstantList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NestedConstantListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public constantList(): ConstantListContext[];
	public constantList(i: number): ConstantListContext;
	public constantList(i?: number): ConstantListContext | ConstantListContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ConstantListContext);
		} else {
			return this.getRuleContext(i, ConstantListContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_nestedConstantList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNestedConstantList) {
			listener.enterNestedConstantList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNestedConstantList) {
			listener.exitNestedConstantList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNestedConstantList) {
			return visitor.visitNestedConstantList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CreateFileFormatContext extends ParserRuleContext {
	public KW_STORED(): TerminalNode { return this.getToken(SparkSqlParser.KW_STORED, 0); }
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public fileFormat(): FileFormatContext | undefined {
		return this.tryGetRuleContext(0, FileFormatContext);
	}
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public storageHandler(): StorageHandlerContext | undefined {
		return this.tryGetRuleContext(0, StorageHandlerContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_createFileFormat; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCreateFileFormat) {
			listener.enterCreateFileFormat(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCreateFileFormat) {
			listener.exitCreateFileFormat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCreateFileFormat) {
			return visitor.visitCreateFileFormat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FileFormatContext extends ParserRuleContext {
	public _inFmt!: StringLitContext;
	public _outFmt!: StringLitContext;
	public KW_INPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPUTFORMAT, 0); }
	public KW_OUTPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTPUTFORMAT, 0); }
	public stringLit(): StringLitContext[];
	public stringLit(i: number): StringLitContext;
	public stringLit(i?: number): StringLitContext | StringLitContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StringLitContext);
		} else {
			return this.getRuleContext(i, StringLitContext);
		}
	}
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_fileFormat; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFileFormat) {
			listener.enterFileFormat(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFileFormat) {
			listener.exitFileFormat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFileFormat) {
			return visitor.visitFileFormat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StorageHandlerContext extends ParserRuleContext {
	public stringLit(): StringLitContext {
		return this.getRuleContext(0, StringLitContext);
	}
	public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
	public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
	public propertyList(): PropertyListContext | undefined {
		return this.tryGetRuleContext(0, PropertyListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_storageHandler; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterStorageHandler) {
			listener.enterStorageHandler(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitStorageHandler) {
			listener.exitStorageHandler(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitStorageHandler) {
			return visitor.visitStorageHandler(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ResourceContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public stringLit(): StringLitContext {
		return this.getRuleContext(0, StringLitContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_resource; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterResource) {
			listener.enterResource(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitResource) {
			listener.exitResource(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitResource) {
			return visitor.visitResource(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DmlStatementNoWithContext extends ParserRuleContext {
	public _target!: TableNameContext;
	public _targetAlias!: TableAliasContext;
	public _source!: IdentifierReferenceContext;
	public _sourceQuery!: QueryContext;
	public _sourceAlias!: TableAliasContext;
	public _mergeCondition!: BooleanExpressionContext;
	public insertInto(): InsertIntoContext | undefined {
		return this.tryGetRuleContext(0, InsertIntoContext);
	}
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public fromClause(): FromClauseContext | undefined {
		return this.tryGetRuleContext(0, FromClauseContext);
	}
	public multiInsertQueryBody(): MultiInsertQueryBodyContext[];
	public multiInsertQueryBody(i: number): MultiInsertQueryBodyContext;
	public multiInsertQueryBody(i?: number): MultiInsertQueryBodyContext | MultiInsertQueryBodyContext[] {
		if (i === undefined) {
			return this.getRuleContexts(MultiInsertQueryBodyContext);
		} else {
			return this.getRuleContext(i, MultiInsertQueryBodyContext);
		}
	}
	public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
	public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	public tableAlias(): TableAliasContext[];
	public tableAlias(i: number): TableAliasContext;
	public tableAlias(i?: number): TableAliasContext | TableAliasContext[] {
		if (i === undefined) {
			return this.getRuleContexts(TableAliasContext);
		} else {
			return this.getRuleContext(i, TableAliasContext);
		}
	}
	public whereClause(): WhereClauseContext | undefined {
		return this.tryGetRuleContext(0, WhereClauseContext);
	}
	public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
	public setClause(): SetClauseContext | undefined {
		return this.tryGetRuleContext(0, SetClauseContext);
	}
	public KW_MERGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MERGE, 0); }
	public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
	public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
	public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
	public booleanExpression(): BooleanExpressionContext | undefined {
		return this.tryGetRuleContext(0, BooleanExpressionContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public identifierReference(): IdentifierReferenceContext | undefined {
		return this.tryGetRuleContext(0, IdentifierReferenceContext);
	}
	public matchedClause(): MatchedClauseContext[];
	public matchedClause(i: number): MatchedClauseContext;
	public matchedClause(i?: number): MatchedClauseContext | MatchedClauseContext[] {
		if (i === undefined) {
			return this.getRuleContexts(MatchedClauseContext);
		} else {
			return this.getRuleContext(i, MatchedClauseContext);
		}
	}
	public notMatchedClause(): NotMatchedClauseContext[];
	public notMatchedClause(i: number): NotMatchedClauseContext;
	public notMatchedClause(i?: number): NotMatchedClauseContext | NotMatchedClauseContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NotMatchedClauseContext);
		} else {
			return this.getRuleContext(i, NotMatchedClauseContext);
		}
	}
	public notMatchedBySourceClause(): NotMatchedBySourceClauseContext[];
	public notMatchedBySourceClause(i: number): NotMatchedBySourceClauseContext;
	public notMatchedBySourceClause(i?: number): NotMatchedBySourceClauseContext | NotMatchedBySourceClauseContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NotMatchedBySourceClauseContext);
		} else {
			return this.getRuleContext(i, NotMatchedBySourceClauseContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_dmlStatementNoWith; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDmlStatementNoWith) {
			listener.enterDmlStatementNoWith(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDmlStatementNoWith) {
			listener.exitDmlStatementNoWith(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDmlStatementNoWith) {
			return visitor.visitDmlStatementNoWith(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DbSchemaNameContext extends ParserRuleContext {
	public identifierReference(): IdentifierReferenceContext {
		return this.getRuleContext(0, IdentifierReferenceContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchemaName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDbSchemaName) {
			listener.enterDbSchemaName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDbSchemaName) {
			listener.exitDbSchemaName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDbSchemaName) {
			return visitor.visitDbSchemaName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DbSchemaNameCreateContext extends ParserRuleContext {
	public identifierReference(): IdentifierReferenceContext {
		return this.getRuleContext(0, IdentifierReferenceContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_dbSchemaNameCreate; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDbSchemaNameCreate) {
			listener.enterDbSchemaNameCreate(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDbSchemaNameCreate) {
			listener.exitDbSchemaNameCreate(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDbSchemaNameCreate) {
			return visitor.visitDbSchemaNameCreate(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TableNameCreateContext extends ParserRuleContext {
	public tableIdentifier(): TableIdentifierContext {
		return this.getRuleContext(0, TableIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_tableNameCreate; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTableNameCreate) {
			listener.enterTableNameCreate(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTableNameCreate) {
			listener.exitTableNameCreate(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTableNameCreate) {
			return visitor.visitTableNameCreate(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TableNameContext extends ParserRuleContext {
	public tableIdentifier(): TableIdentifierContext {
		return this.getRuleContext(0, TableIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_tableName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTableName) {
			listener.enterTableName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTableName) {
			listener.exitTableName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTableName) {
			return visitor.visitTableName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ViewNameCreateContext extends ParserRuleContext {
	public viewIdentifier(): ViewIdentifierContext {
		return this.getRuleContext(0, ViewIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_viewNameCreate; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterViewNameCreate) {
			listener.enterViewNameCreate(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitViewNameCreate) {
			listener.exitViewNameCreate(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitViewNameCreate) {
			return visitor.visitViewNameCreate(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ViewNameContext extends ParserRuleContext {
	public viewIdentifier(): ViewIdentifierContext {
		return this.getRuleContext(0, ViewIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_viewName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterViewName) {
			listener.enterViewName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitViewName) {
			listener.exitViewName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitViewName) {
			return visitor.visitViewName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColumnNameContext extends ParserRuleContext {
	public multipartIdentifier(): MultipartIdentifierContext {
		return this.getRuleContext(0, MultipartIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_columnName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColumnName) {
			listener.enterColumnName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColumnName) {
			listener.exitColumnName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColumnName) {
			return visitor.visitColumnName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColumnNameSeqContext extends ParserRuleContext {
	public columnName(): ColumnNameContext[];
	public columnName(i: number): ColumnNameContext;
	public columnName(i?: number): ColumnNameContext | ColumnNameContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ColumnNameContext);
		} else {
			return this.getRuleContext(i, ColumnNameContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_columnNameSeq; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColumnNameSeq) {
			listener.enterColumnNameSeq(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColumnNameSeq) {
			listener.exitColumnNameSeq(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColumnNameSeq) {
			return visitor.visitColumnNameSeq(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColumnNameCreateContext extends ParserRuleContext {
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_columnNameCreate; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColumnNameCreate) {
			listener.enterColumnNameCreate(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColumnNameCreate) {
			listener.exitColumnNameCreate(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColumnNameCreate) {
			return visitor.visitColumnNameCreate(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IdentifierReferenceContext extends ParserRuleContext {
	public KW_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER, 0); }
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public multipartIdentifier(): MultipartIdentifierContext | undefined {
		return this.tryGetRuleContext(0, MultipartIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_identifierReference; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIdentifierReference) {
			listener.enterIdentifierReference(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIdentifierReference) {
			listener.exitIdentifierReference(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIdentifierReference) {
			return visitor.visitIdentifierReference(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QueryOrganizationContext extends ParserRuleContext {
	public _sortItem!: SortItemContext;
	public _order: SortItemContext[] = [];
	public _expression!: ExpressionContext;
	public _clusterBy: ExpressionContext[] = [];
	public _distributeBy: ExpressionContext[] = [];
	public _sort: SortItemContext[] = [];
	public _limit!: ExpressionContext;
	public _offset!: ExpressionContext;
	public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
	public KW_BY(): TerminalNode[];
	public KW_BY(i: number): TerminalNode;
	public KW_BY(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_BY);
		} else {
			return this.getToken(SparkSqlParser.KW_BY, i);
		}
	}
	public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
	public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
	public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
	public windowClause(): WindowClauseContext | undefined {
		return this.tryGetRuleContext(0, WindowClauseContext);
	}
	public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIMIT, 0); }
	public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OFFSET, 0); }
	public sortItem(): SortItemContext[];
	public sortItem(i: number): SortItemContext;
	public sortItem(i?: number): SortItemContext | SortItemContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SortItemContext);
		} else {
			return this.getRuleContext(i, SortItemContext);
		}
	}
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_queryOrganization; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQueryOrganization) {
			listener.enterQueryOrganization(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQueryOrganization) {
			listener.exitQueryOrganization(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQueryOrganization) {
			return visitor.visitQueryOrganization(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MultiInsertQueryBodyContext extends ParserRuleContext {
	public insertInto(): InsertIntoContext {
		return this.getRuleContext(0, InsertIntoContext);
	}
	public fromStatementBody(): FromStatementBodyContext {
		return this.getRuleContext(0, FromStatementBodyContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_multiInsertQueryBody; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMultiInsertQueryBody) {
			listener.enterMultiInsertQueryBody(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMultiInsertQueryBody) {
			listener.exitMultiInsertQueryBody(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMultiInsertQueryBody) {
			return visitor.visitMultiInsertQueryBody(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QueryTermContext extends ParserRuleContext {
	public _left!: QueryTermContext;
	public _operator!: Token;
	public _right!: QueryTermContext;
	public queryPrimary(): QueryPrimaryContext | undefined {
		return this.tryGetRuleContext(0, QueryPrimaryContext);
	}
	public queryTerm(): QueryTermContext[];
	public queryTerm(i: number): QueryTermContext;
	public queryTerm(i?: number): QueryTermContext | QueryTermContext[] {
		if (i === undefined) {
			return this.getRuleContexts(QueryTermContext);
		} else {
			return this.getRuleContext(i, QueryTermContext);
		}
	}
	public KW_INTERSECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERSECT, 0); }
	public KW_UNION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNION, 0); }
	public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCEPT, 0); }
	public KW_MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUS, 0); }
	public setQuantifier(): SetQuantifierContext | undefined {
		return this.tryGetRuleContext(0, SetQuantifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_queryTerm; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQueryTerm) {
			listener.enterQueryTerm(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQueryTerm) {
			listener.exitQueryTerm(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQueryTerm) {
			return visitor.visitQueryTerm(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QueryPrimaryContext extends ParserRuleContext {
	public querySpecification(): QuerySpecificationContext | undefined {
		return this.tryGetRuleContext(0, QuerySpecificationContext);
	}
	public fromStatement(): FromStatementContext | undefined {
		return this.tryGetRuleContext(0, FromStatementContext);
	}
	public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	public inlineTable(): InlineTableContext | undefined {
		return this.tryGetRuleContext(0, InlineTableContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_queryPrimary; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQueryPrimary) {
			listener.enterQueryPrimary(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQueryPrimary) {
			listener.exitQueryPrimary(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQueryPrimary) {
			return visitor.visitQueryPrimary(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SortItemContext extends ParserRuleContext {
	public _ordering!: Token;
	public _nullOrder!: Token;
	public columnName(): ColumnNameContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameContext);
	}
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
	public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
	public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
	public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
	public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_sortItem; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSortItem) {
			listener.enterSortItem(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSortItem) {
			listener.exitSortItem(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSortItem) {
			return visitor.visitSortItem(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FromStatementContext extends ParserRuleContext {
	public fromClause(): FromClauseContext {
		return this.getRuleContext(0, FromClauseContext);
	}
	public fromStatementBody(): FromStatementBodyContext[];
	public fromStatementBody(i: number): FromStatementBodyContext;
	public fromStatementBody(i?: number): FromStatementBodyContext | FromStatementBodyContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FromStatementBodyContext);
		} else {
			return this.getRuleContext(i, FromStatementBodyContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_fromStatement; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFromStatement) {
			listener.enterFromStatement(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFromStatement) {
			listener.exitFromStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFromStatement) {
			return visitor.visitFromStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FromStatementBodyContext extends ParserRuleContext {
	public transformClause(): TransformClauseContext | undefined {
		return this.tryGetRuleContext(0, TransformClauseContext);
	}
	public queryOrganization(): QueryOrganizationContext {
		return this.getRuleContext(0, QueryOrganizationContext);
	}
	public whereClause(): WhereClauseContext | undefined {
		return this.tryGetRuleContext(0, WhereClauseContext);
	}
	public selectClause(): SelectClauseContext | undefined {
		return this.tryGetRuleContext(0, SelectClauseContext);
	}
	public lateralView(): LateralViewContext[];
	public lateralView(i: number): LateralViewContext;
	public lateralView(i?: number): LateralViewContext | LateralViewContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LateralViewContext);
		} else {
			return this.getRuleContext(i, LateralViewContext);
		}
	}
	public aggregationClause(): AggregationClauseContext | undefined {
		return this.tryGetRuleContext(0, AggregationClauseContext);
	}
	public havingClause(): HavingClauseContext | undefined {
		return this.tryGetRuleContext(0, HavingClauseContext);
	}
	public windowClause(): WindowClauseContext | undefined {
		return this.tryGetRuleContext(0, WindowClauseContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_fromStatementBody; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFromStatementBody) {
			listener.enterFromStatementBody(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFromStatementBody) {
			listener.exitFromStatementBody(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFromStatementBody) {
			return visitor.visitFromStatementBody(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QuerySpecificationContext extends ParserRuleContext {
	public transformClause(): TransformClauseContext | undefined {
		return this.tryGetRuleContext(0, TransformClauseContext);
	}
	public fromClause(): FromClauseContext | undefined {
		return this.tryGetRuleContext(0, FromClauseContext);
	}
	public lateralView(): LateralViewContext[];
	public lateralView(i: number): LateralViewContext;
	public lateralView(i?: number): LateralViewContext | LateralViewContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LateralViewContext);
		} else {
			return this.getRuleContext(i, LateralViewContext);
		}
	}
	public whereClause(): WhereClauseContext | undefined {
		return this.tryGetRuleContext(0, WhereClauseContext);
	}
	public aggregationClause(): AggregationClauseContext | undefined {
		return this.tryGetRuleContext(0, AggregationClauseContext);
	}
	public havingClause(): HavingClauseContext | undefined {
		return this.tryGetRuleContext(0, HavingClauseContext);
	}
	public windowClause(): WindowClauseContext | undefined {
		return this.tryGetRuleContext(0, WindowClauseContext);
	}
	public selectClause(): SelectClauseContext | undefined {
		return this.tryGetRuleContext(0, SelectClauseContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_querySpecification; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQuerySpecification) {
			listener.enterQuerySpecification(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQuerySpecification) {
			listener.exitQuerySpecification(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQuerySpecification) {
			return visitor.visitQuerySpecification(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TransformClauseContext extends ParserRuleContext {
	public _kind!: Token;
	public _inRowFormat!: RowFormatContext;
	public _recordWriter!: StringLitContext;
	public _script!: StringLitContext;
	public _outRowFormat!: RowFormatContext;
	public _recordReader!: StringLitContext;
	public KW_USING(): TerminalNode { return this.getToken(SparkSqlParser.KW_USING, 0); }
	public stringLit(): StringLitContext[];
	public stringLit(i: number): StringLitContext;
	public stringLit(i?: number): StringLitContext | StringLitContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StringLitContext);
		} else {
			return this.getRuleContext(i, StringLitContext);
		}
	}
	public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SELECT, 0); }
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public expressionSeq(): ExpressionSeqContext | undefined {
		return this.tryGetRuleContext(0, ExpressionSeqContext);
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSFORM, 0); }
	public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
	public KW_REDUCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REDUCE, 0); }
	public KW_RECORDWRITER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDWRITER, 0); }
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public KW_RECORDREADER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDREADER, 0); }
	public rowFormat(): RowFormatContext[];
	public rowFormat(i: number): RowFormatContext;
	public rowFormat(i?: number): RowFormatContext | RowFormatContext[] {
		if (i === undefined) {
			return this.getRuleContexts(RowFormatContext);
		} else {
			return this.getRuleContext(i, RowFormatContext);
		}
	}
	public setQuantifier(): SetQuantifierContext | undefined {
		return this.tryGetRuleContext(0, SetQuantifierContext);
	}
	public identifierSeq(): IdentifierSeqContext | undefined {
		return this.tryGetRuleContext(0, IdentifierSeqContext);
	}
	public colTypeList(): ColTypeListContext | undefined {
		return this.tryGetRuleContext(0, ColTypeListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_transformClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTransformClause) {
			listener.enterTransformClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTransformClause) {
			listener.exitTransformClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTransformClause) {
			return visitor.visitTransformClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SelectClauseContext extends ParserRuleContext {
	public _hint!: HintContext;
	public _hints: HintContext[] = [];
	public KW_SELECT(): TerminalNode { return this.getToken(SparkSqlParser.KW_SELECT, 0); }
	public namedExpressionSeq(): NamedExpressionSeqContext {
		return this.getRuleContext(0, NamedExpressionSeqContext);
	}
	public setQuantifier(): SetQuantifierContext | undefined {
		return this.tryGetRuleContext(0, SetQuantifierContext);
	}
	public hint(): HintContext[];
	public hint(i: number): HintContext;
	public hint(i?: number): HintContext | HintContext[] {
		if (i === undefined) {
			return this.getRuleContexts(HintContext);
		} else {
			return this.getRuleContext(i, HintContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_selectClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSelectClause) {
			listener.enterSelectClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSelectClause) {
			listener.exitSelectClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSelectClause) {
			return visitor.visitSelectClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetClauseContext extends ParserRuleContext {
	public KW_SET(): TerminalNode { return this.getToken(SparkSqlParser.KW_SET, 0); }
	public assignmentList(): AssignmentListContext {
		return this.getRuleContext(0, AssignmentListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_setClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSetClause) {
			listener.enterSetClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSetClause) {
			listener.exitSetClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSetClause) {
			return visitor.visitSetClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MatchedClauseContext extends ParserRuleContext {
	public _matchedCond!: BooleanExpressionContext;
	public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
	public KW_MATCHED(): TerminalNode { return this.getToken(SparkSqlParser.KW_MATCHED, 0); }
	public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
	public matchedAction(): MatchedActionContext {
		return this.getRuleContext(0, MatchedActionContext);
	}
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public booleanExpression(): BooleanExpressionContext | undefined {
		return this.tryGetRuleContext(0, BooleanExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_matchedClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMatchedClause) {
			listener.enterMatchedClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMatchedClause) {
			listener.exitMatchedClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMatchedClause) {
			return visitor.visitMatchedClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NotMatchedClauseContext extends ParserRuleContext {
	public _notMatchedCond!: BooleanExpressionContext;
	public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
	public KW_NOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_NOT, 0); }
	public KW_MATCHED(): TerminalNode { return this.getToken(SparkSqlParser.KW_MATCHED, 0); }
	public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
	public notMatchedAction(): NotMatchedActionContext {
		return this.getRuleContext(0, NotMatchedActionContext);
	}
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public KW_TARGET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TARGET, 0); }
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public booleanExpression(): BooleanExpressionContext | undefined {
		return this.tryGetRuleContext(0, BooleanExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNotMatchedClause) {
			listener.enterNotMatchedClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNotMatchedClause) {
			listener.exitNotMatchedClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNotMatchedClause) {
			return visitor.visitNotMatchedClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NotMatchedBySourceClauseContext extends ParserRuleContext {
	public _notMatchedBySourceCond!: BooleanExpressionContext;
	public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
	public KW_NOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_NOT, 0); }
	public KW_MATCHED(): TerminalNode { return this.getToken(SparkSqlParser.KW_MATCHED, 0); }
	public KW_BY(): TerminalNode { return this.getToken(SparkSqlParser.KW_BY, 0); }
	public KW_SOURCE(): TerminalNode { return this.getToken(SparkSqlParser.KW_SOURCE, 0); }
	public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
	public notMatchedBySourceAction(): NotMatchedBySourceActionContext {
		return this.getRuleContext(0, NotMatchedBySourceActionContext);
	}
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public booleanExpression(): BooleanExpressionContext | undefined {
		return this.tryGetRuleContext(0, BooleanExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedBySourceClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNotMatchedBySourceClause) {
			listener.enterNotMatchedBySourceClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNotMatchedBySourceClause) {
			listener.exitNotMatchedBySourceClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNotMatchedBySourceClause) {
			return visitor.visitNotMatchedBySourceClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MatchedActionContext extends ParserRuleContext {
	public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
	public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
	public assignmentList(): AssignmentListContext | undefined {
		return this.tryGetRuleContext(0, AssignmentListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_matchedAction; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMatchedAction) {
			listener.enterMatchedAction(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMatchedAction) {
			listener.exitMatchedAction(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMatchedAction) {
			return visitor.visitMatchedAction(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NotMatchedActionContext extends ParserRuleContext {
	public KW_INSERT(): TerminalNode { return this.getToken(SparkSqlParser.KW_INSERT, 0); }
	public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public multipartIdentifierList(): MultipartIdentifierListContext | undefined {
		return this.tryGetRuleContext(0, MultipartIdentifierListContext);
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VALUES, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedAction; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNotMatchedAction) {
			listener.enterNotMatchedAction(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNotMatchedAction) {
			listener.exitNotMatchedAction(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNotMatchedAction) {
			return visitor.visitNotMatchedAction(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NotMatchedBySourceActionContext extends ParserRuleContext {
	public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
	public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public assignmentList(): AssignmentListContext | undefined {
		return this.tryGetRuleContext(0, AssignmentListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_notMatchedBySourceAction; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNotMatchedBySourceAction) {
			listener.enterNotMatchedBySourceAction(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNotMatchedBySourceAction) {
			listener.exitNotMatchedBySourceAction(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNotMatchedBySourceAction) {
			return visitor.visitNotMatchedBySourceAction(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AssignmentListContext extends ParserRuleContext {
	public assignment(): AssignmentContext[];
	public assignment(i: number): AssignmentContext;
	public assignment(i?: number): AssignmentContext | AssignmentContext[] {
		if (i === undefined) {
			return this.getRuleContexts(AssignmentContext);
		} else {
			return this.getRuleContext(i, AssignmentContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_assignmentList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterAssignmentList) {
			listener.enterAssignmentList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitAssignmentList) {
			listener.exitAssignmentList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitAssignmentList) {
			return visitor.visitAssignmentList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AssignmentContext extends ParserRuleContext {
	public _key!: MultipartIdentifierContext;
	public _value!: ExpressionContext;
	public EQ(): TerminalNode { return this.getToken(SparkSqlParser.EQ, 0); }
	public multipartIdentifier(): MultipartIdentifierContext {
		return this.getRuleContext(0, MultipartIdentifierContext);
	}
	public expression(): ExpressionContext {
		return this.getRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_assignment; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterAssignment) {
			listener.enterAssignment(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitAssignment) {
			listener.exitAssignment(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitAssignment) {
			return visitor.visitAssignment(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class WhereClauseContext extends ParserRuleContext {
	public KW_WHERE(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHERE, 0); }
	public booleanExpression(): BooleanExpressionContext {
		return this.getRuleContext(0, BooleanExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_whereClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterWhereClause) {
			listener.enterWhereClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitWhereClause) {
			listener.exitWhereClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitWhereClause) {
			return visitor.visitWhereClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class HavingClauseContext extends ParserRuleContext {
	public KW_HAVING(): TerminalNode { return this.getToken(SparkSqlParser.KW_HAVING, 0); }
	public booleanExpression(): BooleanExpressionContext {
		return this.getRuleContext(0, BooleanExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_havingClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterHavingClause) {
			listener.enterHavingClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitHavingClause) {
			listener.exitHavingClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitHavingClause) {
			return visitor.visitHavingClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class HintContext extends ParserRuleContext {
	public _hintStatement!: HintStatementContext;
	public _hintStatements: HintStatementContext[] = [];
	public HENT_START(): TerminalNode { return this.getToken(SparkSqlParser.HENT_START, 0); }
	public HENT_END(): TerminalNode { return this.getToken(SparkSqlParser.HENT_END, 0); }
	public hintStatement(): HintStatementContext[];
	public hintStatement(i: number): HintStatementContext;
	public hintStatement(i?: number): HintStatementContext | HintStatementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(HintStatementContext);
		} else {
			return this.getRuleContext(i, HintStatementContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_hint; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterHint) {
			listener.enterHint(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitHint) {
			listener.exitHint(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitHint) {
			return visitor.visitHint(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class HintStatementContext extends ParserRuleContext {
	public _hintName!: IdentifierContext;
	public _primaryExpression!: PrimaryExpressionContext;
	public _parameters: PrimaryExpressionContext[] = [];
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public primaryExpression(): PrimaryExpressionContext[];
	public primaryExpression(i: number): PrimaryExpressionContext;
	public primaryExpression(i?: number): PrimaryExpressionContext | PrimaryExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PrimaryExpressionContext);
		} else {
			return this.getRuleContext(i, PrimaryExpressionContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_hintStatement; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterHintStatement) {
			listener.enterHintStatement(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitHintStatement) {
			listener.exitHintStatement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitHintStatement) {
			return visitor.visitHintStatement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FromClauseContext extends ParserRuleContext {
	public KW_FROM(): TerminalNode { return this.getToken(SparkSqlParser.KW_FROM, 0); }
	public relation(): RelationContext[];
	public relation(i: number): RelationContext;
	public relation(i?: number): RelationContext | RelationContext[] {
		if (i === undefined) {
			return this.getRuleContexts(RelationContext);
		} else {
			return this.getRuleContext(i, RelationContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public lateralView(): LateralViewContext[];
	public lateralView(i: number): LateralViewContext;
	public lateralView(i?: number): LateralViewContext | LateralViewContext[] {
		if (i === undefined) {
			return this.getRuleContexts(LateralViewContext);
		} else {
			return this.getRuleContext(i, LateralViewContext);
		}
	}
	public pivotClause(): PivotClauseContext | undefined {
		return this.tryGetRuleContext(0, PivotClauseContext);
	}
	public unpivotClause(): UnpivotClauseContext | undefined {
		return this.tryGetRuleContext(0, UnpivotClauseContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_fromClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFromClause) {
			listener.enterFromClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFromClause) {
			listener.exitFromClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFromClause) {
			return visitor.visitFromClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionKindContext extends ParserRuleContext {
	public KW_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USER, 0); }
	public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM, 0); }
	public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionKind; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionKind) {
			listener.enterFunctionKind(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionKind) {
			listener.exitFunctionKind(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionKind) {
			return visitor.visitFunctionKind(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TemporalClauseContext extends ParserRuleContext {
	public _timestamp!: ValueExpressionContext;
	public KW_AS(): TerminalNode { return this.getToken(SparkSqlParser.KW_AS, 0); }
	public KW_OF(): TerminalNode { return this.getToken(SparkSqlParser.KW_OF, 0); }
	public version(): VersionContext | undefined {
		return this.tryGetRuleContext(0, VersionContext);
	}
	public KW_SYSTEM_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_VERSION, 0); }
	public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VERSION, 0); }
	public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
	public KW_SYSTEM_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_TIME, 0); }
	public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
	public valueExpression(): ValueExpressionContext | undefined {
		return this.tryGetRuleContext(0, ValueExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_temporalClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTemporalClause) {
			listener.enterTemporalClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTemporalClause) {
			listener.exitTemporalClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTemporalClause) {
			return visitor.visitTemporalClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AggregationClauseContext extends ParserRuleContext {
	public _groupByClause!: GroupByClauseContext;
	public _groupingExpressionsWithGroupingAnalytics: GroupByClauseContext[] = [];
	public _expression!: ExpressionContext;
	public _groupingExpressions: ExpressionContext[] = [];
	public _kind!: Token;
	public KW_GROUP(): TerminalNode { return this.getToken(SparkSqlParser.KW_GROUP, 0); }
	public KW_BY(): TerminalNode { return this.getToken(SparkSqlParser.KW_BY, 0); }
	public groupByClause(): GroupByClauseContext[];
	public groupByClause(i: number): GroupByClauseContext;
	public groupByClause(i?: number): GroupByClauseContext | GroupByClauseContext[] {
		if (i === undefined) {
			return this.getRuleContexts(GroupByClauseContext);
		} else {
			return this.getRuleContext(i, GroupByClauseContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
	public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public groupingSet(): GroupingSetContext[];
	public groupingSet(i: number): GroupingSetContext;
	public groupingSet(i?: number): GroupingSetContext | GroupingSetContext[] {
		if (i === undefined) {
			return this.getRuleContexts(GroupingSetContext);
		} else {
			return this.getRuleContext(i, GroupingSetContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
	public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
	public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_aggregationClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterAggregationClause) {
			listener.enterAggregationClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitAggregationClause) {
			listener.exitAggregationClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitAggregationClause) {
			return visitor.visitAggregationClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class GroupByClauseContext extends ParserRuleContext {
	public columnName(): ColumnNameContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameContext);
	}
	public groupingAnalytics(): GroupingAnalyticsContext | undefined {
		return this.tryGetRuleContext(0, GroupingAnalyticsContext);
	}
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_groupByClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterGroupByClause) {
			listener.enterGroupByClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitGroupByClause) {
			listener.exitGroupByClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitGroupByClause) {
			return visitor.visitGroupByClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class GroupingAnalyticsContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public groupingSet(): GroupingSetContext[];
	public groupingSet(i: number): GroupingSetContext;
	public groupingSet(i?: number): GroupingSetContext | GroupingSetContext[] {
		if (i === undefined) {
			return this.getRuleContexts(GroupingSetContext);
		} else {
			return this.getRuleContext(i, GroupingSetContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
	public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
	public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
	public groupingElement(): GroupingElementContext[];
	public groupingElement(i: number): GroupingElementContext;
	public groupingElement(i?: number): GroupingElementContext | GroupingElementContext[] {
		if (i === undefined) {
			return this.getRuleContexts(GroupingElementContext);
		} else {
			return this.getRuleContext(i, GroupingElementContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_groupingAnalytics; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterGroupingAnalytics) {
			listener.enterGroupingAnalytics(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitGroupingAnalytics) {
			listener.exitGroupingAnalytics(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitGroupingAnalytics) {
			return visitor.visitGroupingAnalytics(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class GroupingElementContext extends ParserRuleContext {
	public groupingAnalytics(): GroupingAnalyticsContext | undefined {
		return this.tryGetRuleContext(0, GroupingAnalyticsContext);
	}
	public groupingSet(): GroupingSetContext | undefined {
		return this.tryGetRuleContext(0, GroupingSetContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_groupingElement; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterGroupingElement) {
			listener.enterGroupingElement(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitGroupingElement) {
			listener.exitGroupingElement(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitGroupingElement) {
			return visitor.visitGroupingElement(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class GroupingSetContext extends ParserRuleContext {
	public columnName(): ColumnNameContext[];
	public columnName(i: number): ColumnNameContext;
	public columnName(i?: number): ColumnNameContext | ColumnNameContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ColumnNameContext);
		} else {
			return this.getRuleContext(i, ColumnNameContext);
		}
	}
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_groupingSet; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterGroupingSet) {
			listener.enterGroupingSet(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitGroupingSet) {
			listener.exitGroupingSet(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitGroupingSet) {
			return visitor.visitGroupingSet(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PivotClauseContext extends ParserRuleContext {
	public _aggregates!: NamedExpressionSeqContext;
	public _pivotValue!: PivotValueContext;
	public _pivotValues: PivotValueContext[] = [];
	public KW_PIVOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_PIVOT, 0); }
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public KW_FOR(): TerminalNode { return this.getToken(SparkSqlParser.KW_FOR, 0); }
	public pivotColumn(): PivotColumnContext {
		return this.getRuleContext(0, PivotColumnContext);
	}
	public KW_IN(): TerminalNode { return this.getToken(SparkSqlParser.KW_IN, 0); }
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public namedExpressionSeq(): NamedExpressionSeqContext {
		return this.getRuleContext(0, NamedExpressionSeqContext);
	}
	public pivotValue(): PivotValueContext[];
	public pivotValue(i: number): PivotValueContext;
	public pivotValue(i?: number): PivotValueContext | PivotValueContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PivotValueContext);
		} else {
			return this.getRuleContext(i, PivotValueContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_pivotClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPivotClause) {
			listener.enterPivotClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPivotClause) {
			listener.exitPivotClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPivotClause) {
			return visitor.visitPivotClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PivotColumnContext extends ParserRuleContext {
	public _identifier!: IdentifierContext;
	public _identifiers: IdentifierContext[] = [];
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_pivotColumn; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPivotColumn) {
			listener.enterPivotColumn(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPivotColumn) {
			listener.exitPivotColumn(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPivotColumn) {
			return visitor.visitPivotColumn(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PivotValueContext extends ParserRuleContext {
	public expression(): ExpressionContext {
		return this.getRuleContext(0, ExpressionContext);
	}
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_pivotValue; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPivotValue) {
			listener.enterPivotValue(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPivotValue) {
			listener.exitPivotValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPivotValue) {
			return visitor.visitPivotValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotClauseContext extends ParserRuleContext {
	public _nullOperator!: UnpivotNullClauseContext;
	public _operator!: UnpivotOperatorContext;
	public KW_UNPIVOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_UNPIVOT, 0); }
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public unpivotOperator(): UnpivotOperatorContext {
		return this.getRuleContext(0, UnpivotOperatorContext);
	}
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	public unpivotNullClause(): UnpivotNullClauseContext | undefined {
		return this.tryGetRuleContext(0, UnpivotNullClauseContext);
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotClause) {
			listener.enterUnpivotClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotClause) {
			listener.exitUnpivotClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotClause) {
			return visitor.visitUnpivotClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotNullClauseContext extends ParserRuleContext {
	public KW_NULLS(): TerminalNode { return this.getToken(SparkSqlParser.KW_NULLS, 0); }
	public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INCLUDE, 0); }
	public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCLUDE, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotNullClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotNullClause) {
			listener.enterUnpivotNullClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotNullClause) {
			listener.exitUnpivotNullClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotNullClause) {
			return visitor.visitUnpivotNullClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotOperatorContext extends ParserRuleContext {
	public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext | undefined {
		return this.tryGetRuleContext(0, UnpivotSingleValueColumnClauseContext);
	}
	public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext | undefined {
		return this.tryGetRuleContext(0, UnpivotMultiValueColumnClauseContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotOperator; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotOperator) {
			listener.enterUnpivotOperator(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotOperator) {
			listener.exitUnpivotOperator(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotOperator) {
			return visitor.visitUnpivotOperator(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotSingleValueColumnClauseContext extends ParserRuleContext {
	public _unpivotColumnAndAlias!: UnpivotColumnAndAliasContext;
	public _unpivotColumns: UnpivotColumnAndAliasContext[] = [];
	public unpivotValueColumn(): UnpivotValueColumnContext {
		return this.getRuleContext(0, UnpivotValueColumnContext);
	}
	public KW_FOR(): TerminalNode { return this.getToken(SparkSqlParser.KW_FOR, 0); }
	public unpivotNameColumn(): UnpivotNameColumnContext {
		return this.getRuleContext(0, UnpivotNameColumnContext);
	}
	public KW_IN(): TerminalNode { return this.getToken(SparkSqlParser.KW_IN, 0); }
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext[];
	public unpivotColumnAndAlias(i: number): UnpivotColumnAndAliasContext;
	public unpivotColumnAndAlias(i?: number): UnpivotColumnAndAliasContext | UnpivotColumnAndAliasContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnpivotColumnAndAliasContext);
		} else {
			return this.getRuleContext(i, UnpivotColumnAndAliasContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotSingleValueColumnClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotSingleValueColumnClause) {
			listener.enterUnpivotSingleValueColumnClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotSingleValueColumnClause) {
			listener.exitUnpivotSingleValueColumnClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotSingleValueColumnClause) {
			return visitor.visitUnpivotSingleValueColumnClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotMultiValueColumnClauseContext extends ParserRuleContext {
	public _unpivotValueColumn!: UnpivotValueColumnContext;
	public _unpivotValueColumns: UnpivotValueColumnContext[] = [];
	public _unpivotColumnSet!: UnpivotColumnSetContext;
	public _unpivotColumnSets: UnpivotColumnSetContext[] = [];
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public KW_FOR(): TerminalNode { return this.getToken(SparkSqlParser.KW_FOR, 0); }
	public unpivotNameColumn(): UnpivotNameColumnContext {
		return this.getRuleContext(0, UnpivotNameColumnContext);
	}
	public KW_IN(): TerminalNode { return this.getToken(SparkSqlParser.KW_IN, 0); }
	public unpivotValueColumn(): UnpivotValueColumnContext[];
	public unpivotValueColumn(i: number): UnpivotValueColumnContext;
	public unpivotValueColumn(i?: number): UnpivotValueColumnContext | UnpivotValueColumnContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnpivotValueColumnContext);
		} else {
			return this.getRuleContext(i, UnpivotValueColumnContext);
		}
	}
	public unpivotColumnSet(): UnpivotColumnSetContext[];
	public unpivotColumnSet(i: number): UnpivotColumnSetContext;
	public unpivotColumnSet(i?: number): UnpivotColumnSetContext | UnpivotColumnSetContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnpivotColumnSetContext);
		} else {
			return this.getRuleContext(i, UnpivotColumnSetContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotMultiValueColumnClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotMultiValueColumnClause) {
			listener.enterUnpivotMultiValueColumnClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotMultiValueColumnClause) {
			listener.exitUnpivotMultiValueColumnClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotMultiValueColumnClause) {
			return visitor.visitUnpivotMultiValueColumnClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotColumnSetContext extends ParserRuleContext {
	public _unpivotColumn!: UnpivotColumnContext;
	public _unpivotColumns: UnpivotColumnContext[] = [];
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public unpivotColumn(): UnpivotColumnContext[];
	public unpivotColumn(i: number): UnpivotColumnContext;
	public unpivotColumn(i?: number): UnpivotColumnContext | UnpivotColumnContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnpivotColumnContext);
		} else {
			return this.getRuleContext(i, UnpivotColumnContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public unpivotAlias(): UnpivotAliasContext | undefined {
		return this.tryGetRuleContext(0, UnpivotAliasContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotColumnSet; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotColumnSet) {
			listener.enterUnpivotColumnSet(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotColumnSet) {
			listener.exitUnpivotColumnSet(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotColumnSet) {
			return visitor.visitUnpivotColumnSet(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotValueColumnContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotValueColumn; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotValueColumn) {
			listener.enterUnpivotValueColumn(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotValueColumn) {
			listener.exitUnpivotValueColumn(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotValueColumn) {
			return visitor.visitUnpivotValueColumn(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotNameColumnContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotNameColumn; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotNameColumn) {
			listener.enterUnpivotNameColumn(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotNameColumn) {
			listener.exitUnpivotNameColumn(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotNameColumn) {
			return visitor.visitUnpivotNameColumn(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotColumnAndAliasContext extends ParserRuleContext {
	public unpivotColumn(): UnpivotColumnContext {
		return this.getRuleContext(0, UnpivotColumnContext);
	}
	public unpivotAlias(): UnpivotAliasContext | undefined {
		return this.tryGetRuleContext(0, UnpivotAliasContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotColumnAndAlias; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotColumnAndAlias) {
			listener.enterUnpivotColumnAndAlias(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotColumnAndAlias) {
			listener.exitUnpivotColumnAndAlias(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotColumnAndAlias) {
			return visitor.visitUnpivotColumnAndAlias(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotColumnContext extends ParserRuleContext {
	public multipartIdentifier(): MultipartIdentifierContext {
		return this.getRuleContext(0, MultipartIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotColumn; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotColumn) {
			listener.enterUnpivotColumn(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotColumn) {
			listener.exitUnpivotColumn(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotColumn) {
			return visitor.visitUnpivotColumn(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnpivotAliasContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unpivotAlias; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnpivotAlias) {
			listener.enterUnpivotAlias(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnpivotAlias) {
			listener.exitUnpivotAlias(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnpivotAlias) {
			return visitor.visitUnpivotAlias(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IfNotExistsContext extends ParserRuleContext {
	public KW_IF(): TerminalNode { return this.getToken(SparkSqlParser.KW_IF, 0); }
	public KW_NOT(): TerminalNode { return this.getToken(SparkSqlParser.KW_NOT, 0); }
	public KW_EXISTS(): TerminalNode { return this.getToken(SparkSqlParser.KW_EXISTS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_ifNotExists; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIfNotExists) {
			listener.enterIfNotExists(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIfNotExists) {
			listener.exitIfNotExists(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIfNotExists) {
			return visitor.visitIfNotExists(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IfExistsContext extends ParserRuleContext {
	public KW_IF(): TerminalNode { return this.getToken(SparkSqlParser.KW_IF, 0); }
	public KW_EXISTS(): TerminalNode { return this.getToken(SparkSqlParser.KW_EXISTS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_ifExists; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIfExists) {
			listener.enterIfExists(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIfExists) {
			listener.exitIfExists(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIfExists) {
			return visitor.visitIfExists(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class LateralViewContext extends ParserRuleContext {
	public _identifier!: IdentifierContext;
	public _colName: IdentifierContext[] = [];
	public KW_LATERAL(): TerminalNode { return this.getToken(SparkSqlParser.KW_LATERAL, 0); }
	public KW_VIEW(): TerminalNode { return this.getToken(SparkSqlParser.KW_VIEW, 0); }
	public viewName(): ViewNameContext {
		return this.getRuleContext(0, ViewNameContext);
	}
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public tableAlias(): TableAliasContext {
		return this.getRuleContext(0, TableAliasContext);
	}
	public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTER, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_lateralView; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterLateralView) {
			listener.enterLateralView(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitLateralView) {
			listener.exitLateralView(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitLateralView) {
			return visitor.visitLateralView(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SetQuantifierContext extends ParserRuleContext {
	public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTINCT, 0); }
	public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_setQuantifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSetQuantifier) {
			listener.enterSetQuantifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSetQuantifier) {
			listener.exitSetQuantifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSetQuantifier) {
			return visitor.visitSetQuantifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class RelationContext extends ParserRuleContext {
	public relationPrimary(): RelationPrimaryContext | undefined {
		return this.tryGetRuleContext(0, RelationPrimaryContext);
	}
	public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LATERAL, 0); }
	public relationExtension(): RelationExtensionContext[];
	public relationExtension(i: number): RelationExtensionContext;
	public relationExtension(i?: number): RelationExtensionContext | RelationExtensionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(RelationExtensionContext);
		} else {
			return this.getRuleContext(i, RelationExtensionContext);
		}
	}
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_relation; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterRelation) {
			listener.enterRelation(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitRelation) {
			listener.exitRelation(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitRelation) {
			return visitor.visitRelation(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class RelationExtensionContext extends ParserRuleContext {
	public joinRelation(): JoinRelationContext | undefined {
		return this.tryGetRuleContext(0, JoinRelationContext);
	}
	public pivotClause(): PivotClauseContext | undefined {
		return this.tryGetRuleContext(0, PivotClauseContext);
	}
	public unpivotClause(): UnpivotClauseContext | undefined {
		return this.tryGetRuleContext(0, UnpivotClauseContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_relationExtension; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterRelationExtension) {
			listener.enterRelationExtension(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitRelationExtension) {
			listener.exitRelationExtension(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitRelationExtension) {
			return visitor.visitRelationExtension(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class JoinRelationContext extends ParserRuleContext {
	public _right!: RelationPrimaryContext;
	public KW_JOIN(): TerminalNode { return this.getToken(SparkSqlParser.KW_JOIN, 0); }
	public relationPrimary(): RelationPrimaryContext {
		return this.getRuleContext(0, RelationPrimaryContext);
	}
	public joinType(): JoinTypeContext | undefined {
		return this.tryGetRuleContext(0, JoinTypeContext);
	}
	public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LATERAL, 0); }
	public joinCriteria(): JoinCriteriaContext | undefined {
		return this.tryGetRuleContext(0, JoinCriteriaContext);
	}
	public KW_NATURAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NATURAL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_joinRelation; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterJoinRelation) {
			listener.enterJoinRelation(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitJoinRelation) {
			listener.exitJoinRelation(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitJoinRelation) {
			return visitor.visitJoinRelation(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class JoinTypeContext extends ParserRuleContext {
	public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INNER, 0); }
	public KW_CROSS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CROSS, 0); }
	public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEFT, 0); }
	public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTER, 0); }
	public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEMI, 0); }
	public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RIGHT, 0); }
	public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FULL, 0); }
	public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANTI, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_joinType; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterJoinType) {
			listener.enterJoinType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitJoinType) {
			listener.exitJoinType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitJoinType) {
			return visitor.visitJoinType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class JoinCriteriaContext extends ParserRuleContext {
	public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
	public booleanExpression(): BooleanExpressionContext | undefined {
		return this.tryGetRuleContext(0, BooleanExpressionContext);
	}
	public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
	public identifierList(): IdentifierListContext | undefined {
		return this.tryGetRuleContext(0, IdentifierListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_joinCriteria; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterJoinCriteria) {
			listener.enterJoinCriteria(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitJoinCriteria) {
			listener.exitJoinCriteria(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitJoinCriteria) {
			return visitor.visitJoinCriteria(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SampleContext extends ParserRuleContext {
	public _seed!: Token;
	public KW_TABLESAMPLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLESAMPLE, 0); }
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public sampleMethod(): SampleMethodContext | undefined {
		return this.tryGetRuleContext(0, SampleMethodContext);
	}
	public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPEATABLE, 0); }
	public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_sample; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSample) {
			listener.enterSample(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSample) {
			listener.exitSample(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSample) {
			return visitor.visitSample(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class SampleMethodContext extends ParserRuleContext {
	public _negativeSign!: Token;
	public _percentage!: Token;
	public _sampleType!: Token;
	public _numerator!: Token;
	public _denominator!: Token;
	public _bytes!: ExpressionContext;
	public KW_PERCENTLIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTLIT, 0); }
	public INTEGER_VALUE(): TerminalNode[];
	public INTEGER_VALUE(i: number): TerminalNode;
	public INTEGER_VALUE(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.INTEGER_VALUE);
		} else {
			return this.getToken(SparkSqlParser.INTEGER_VALUE, i);
		}
	}
	public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
	public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
	public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUT, 0); }
	public KW_OF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OF, 0); }
	public KW_BUCKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKET, 0); }
	public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	public qualifiedName(): QualifiedNameContext | undefined {
		return this.tryGetRuleContext(0, QualifiedNameContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_sampleMethod; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterSampleMethod) {
			listener.enterSampleMethod(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitSampleMethod) {
			listener.exitSampleMethod(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitSampleMethod) {
			return visitor.visitSampleMethod(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IdentifierListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public identifierSeq(): IdentifierSeqContext {
		return this.getRuleContext(0, IdentifierSeqContext);
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_identifierList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIdentifierList) {
			listener.enterIdentifierList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIdentifierList) {
			listener.exitIdentifierList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIdentifierList) {
			return visitor.visitIdentifierList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IdentifierSeqContext extends ParserRuleContext {
	public _errorCapturingIdentifier!: ErrorCapturingIdentifierContext;
	public _ident: ErrorCapturingIdentifierContext[] = [];
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
	public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
	public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ErrorCapturingIdentifierContext);
		} else {
			return this.getRuleContext(i, ErrorCapturingIdentifierContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_identifierSeq; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIdentifierSeq) {
			listener.enterIdentifierSeq(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIdentifierSeq) {
			listener.exitIdentifierSeq(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIdentifierSeq) {
			return visitor.visitIdentifierSeq(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class OrderedIdentifierListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public orderedIdentifier(): OrderedIdentifierContext[];
	public orderedIdentifier(i: number): OrderedIdentifierContext;
	public orderedIdentifier(i?: number): OrderedIdentifierContext | OrderedIdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(OrderedIdentifierContext);
		} else {
			return this.getRuleContext(i, OrderedIdentifierContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_orderedIdentifierList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterOrderedIdentifierList) {
			listener.enterOrderedIdentifierList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitOrderedIdentifierList) {
			listener.exitOrderedIdentifierList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitOrderedIdentifierList) {
			return visitor.visitOrderedIdentifierList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class OrderedIdentifierContext extends ParserRuleContext {
	public _ident!: ErrorCapturingIdentifierContext;
	public _ordering!: Token;
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierContext);
	}
	public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
	public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_orderedIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterOrderedIdentifier) {
			listener.enterOrderedIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitOrderedIdentifier) {
			listener.exitOrderedIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitOrderedIdentifier) {
			return visitor.visitOrderedIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IdentifierCommentListContext extends ParserRuleContext {
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public identifierComment(): IdentifierCommentContext[];
	public identifierComment(i: number): IdentifierCommentContext;
	public identifierComment(i?: number): IdentifierCommentContext | IdentifierCommentContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierCommentContext);
		} else {
			return this.getRuleContext(i, IdentifierCommentContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_identifierCommentList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIdentifierCommentList) {
			listener.enterIdentifierCommentList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIdentifierCommentList) {
			listener.exitIdentifierCommentList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIdentifierCommentList) {
			return visitor.visitIdentifierCommentList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IdentifierCommentContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public commentSpec(): CommentSpecContext | undefined {
		return this.tryGetRuleContext(0, CommentSpecContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_identifierComment; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIdentifierComment) {
			listener.enterIdentifierComment(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIdentifierComment) {
			listener.exitIdentifierComment(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIdentifierComment) {
			return visitor.visitIdentifierComment(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class RelationPrimaryContext extends ParserRuleContext {
	public identifierReference(): IdentifierReferenceContext | undefined {
		return this.tryGetRuleContext(0, IdentifierReferenceContext);
	}
	public tableAlias(): TableAliasContext | undefined {
		return this.tryGetRuleContext(0, TableAliasContext);
	}
	public temporalClause(): TemporalClauseContext | undefined {
		return this.tryGetRuleContext(0, TemporalClauseContext);
	}
	public sample(): SampleContext | undefined {
		return this.tryGetRuleContext(0, SampleContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public relation(): RelationContext | undefined {
		return this.tryGetRuleContext(0, RelationContext);
	}
	public inlineTable(): InlineTableContext | undefined {
		return this.tryGetRuleContext(0, InlineTableContext);
	}
	public functionTable(): FunctionTableContext | undefined {
		return this.tryGetRuleContext(0, FunctionTableContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_relationPrimary; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterRelationPrimary) {
			listener.enterRelationPrimary(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitRelationPrimary) {
			listener.exitRelationPrimary(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitRelationPrimary) {
			return visitor.visitRelationPrimary(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class InlineTableContext extends ParserRuleContext {
	public KW_VALUES(): TerminalNode { return this.getToken(SparkSqlParser.KW_VALUES, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public tableAlias(): TableAliasContext {
		return this.getRuleContext(0, TableAliasContext);
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_inlineTable; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterInlineTable) {
			listener.enterInlineTable(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitInlineTable) {
			listener.exitInlineTable(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitInlineTable) {
			return visitor.visitInlineTable(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionTableSubqueryArgumentContext extends ParserRuleContext {
	public KW_TABLE(): TerminalNode { return this.getToken(SparkSqlParser.KW_TABLE, 0); }
	public tableName(): TableNameContext | undefined {
		return this.tryGetRuleContext(0, TableNameContext);
	}
	public tableArgumentPartitioning(): TableArgumentPartitioningContext | undefined {
		return this.tryGetRuleContext(0, TableArgumentPartitioningContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableSubqueryArgument; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionTableSubqueryArgument) {
			listener.enterFunctionTableSubqueryArgument(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionTableSubqueryArgument) {
			listener.exitFunctionTableSubqueryArgument(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionTableSubqueryArgument) {
			return visitor.visitFunctionTableSubqueryArgument(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TableArgumentPartitioningContext extends ParserRuleContext {
	public _expression!: ExpressionContext;
	public _partition: ExpressionContext[] = [];
	public KW_BY(): TerminalNode[];
	public KW_BY(i: number): TerminalNode;
	public KW_BY(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_BY);
		} else {
			return this.getToken(SparkSqlParser.KW_BY, i);
		}
	}
	public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
	public KW_SINGLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SINGLE, 0); }
	public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
	public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
	public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
	public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public sortItem(): SortItemContext[];
	public sortItem(i: number): SortItemContext;
	public sortItem(i?: number): SortItemContext | SortItemContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SortItemContext);
		} else {
			return this.getRuleContext(i, SortItemContext);
		}
	}
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_tableArgumentPartitioning; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTableArgumentPartitioning) {
			listener.enterTableArgumentPartitioning(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTableArgumentPartitioning) {
			listener.exitTableArgumentPartitioning(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTableArgumentPartitioning) {
			return visitor.visitTableArgumentPartitioning(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionTableNamedArgumentExpressionContext extends ParserRuleContext {
	public _key!: IdentifierContext;
	public _table!: FunctionTableSubqueryArgumentContext;
	public FAT_ARROW(): TerminalNode { return this.getToken(SparkSqlParser.FAT_ARROW, 0); }
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext {
		return this.getRuleContext(0, FunctionTableSubqueryArgumentContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableNamedArgumentExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionTableNamedArgumentExpression) {
			listener.enterFunctionTableNamedArgumentExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionTableNamedArgumentExpression) {
			listener.exitFunctionTableNamedArgumentExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionTableNamedArgumentExpression) {
			return visitor.visitFunctionTableNamedArgumentExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionTableReferenceArgumentContext extends ParserRuleContext {
	public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext | undefined {
		return this.tryGetRuleContext(0, FunctionTableSubqueryArgumentContext);
	}
	public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext | undefined {
		return this.tryGetRuleContext(0, FunctionTableNamedArgumentExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableReferenceArgument; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionTableReferenceArgument) {
			listener.enterFunctionTableReferenceArgument(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionTableReferenceArgument) {
			listener.exitFunctionTableReferenceArgument(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionTableReferenceArgument) {
			return visitor.visitFunctionTableReferenceArgument(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionTableArgumentContext extends ParserRuleContext {
	public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext | undefined {
		return this.tryGetRuleContext(0, FunctionTableReferenceArgumentContext);
	}
	public functionArgument(): FunctionArgumentContext | undefined {
		return this.tryGetRuleContext(0, FunctionArgumentContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionTableArgument; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionTableArgument) {
			listener.enterFunctionTableArgument(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionTableArgument) {
			listener.exitFunctionTableArgument(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionTableArgument) {
			return visitor.visitFunctionTableArgument(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionTableContext extends ParserRuleContext {
	public functionName(): FunctionNameContext {
		return this.getRuleContext(0, FunctionNameContext);
	}
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public tableAlias(): TableAliasContext {
		return this.getRuleContext(0, TableAliasContext);
	}
	public functionTableArgument(): FunctionTableArgumentContext[];
	public functionTableArgument(i: number): FunctionTableArgumentContext;
	public functionTableArgument(i?: number): FunctionTableArgumentContext | FunctionTableArgumentContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FunctionTableArgumentContext);
		} else {
			return this.getRuleContext(i, FunctionTableArgumentContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionTable; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionTable) {
			listener.enterFunctionTable(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionTable) {
			listener.exitFunctionTable(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionTable) {
			return visitor.visitFunctionTable(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TableAliasContext extends ParserRuleContext {
	public strictIdentifier(): StrictIdentifierContext | undefined {
		return this.tryGetRuleContext(0, StrictIdentifierContext);
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public identifierList(): IdentifierListContext | undefined {
		return this.tryGetRuleContext(0, IdentifierListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_tableAlias; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTableAlias) {
			listener.enterTableAlias(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTableAlias) {
			listener.exitTableAlias(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTableAlias) {
			return visitor.visitTableAlias(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class RowFormatContext extends ParserRuleContext {
	public _name!: StringLitContext;
	public _props!: PropertyListContext;
	public _fieldsTerminatedBy!: StringLitContext;
	public _escapedBy!: StringLitContext;
	public _collectionItemsTerminatedBy!: StringLitContext;
	public _keysTerminatedBy!: StringLitContext;
	public _linesSeparatedBy!: StringLitContext;
	public _nullDefinedAs!: StringLitContext;
	public KW_ROW(): TerminalNode { return this.getToken(SparkSqlParser.KW_ROW, 0); }
	public KW_FORMAT(): TerminalNode { return this.getToken(SparkSqlParser.KW_FORMAT, 0); }
	public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
	public stringLit(): StringLitContext[];
	public stringLit(i: number): StringLitContext;
	public stringLit(i?: number): StringLitContext | StringLitContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StringLitContext);
		} else {
			return this.getRuleContext(i, StringLitContext);
		}
	}
	public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
	public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
	public propertyList(): PropertyListContext | undefined {
		return this.tryGetRuleContext(0, PropertyListContext);
	}
	public KW_DELIMITED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELIMITED, 0); }
	public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIELDS, 0); }
	public KW_TERMINATED(): TerminalNode[];
	public KW_TERMINATED(i: number): TerminalNode;
	public KW_TERMINATED(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_TERMINATED);
		} else {
			return this.getToken(SparkSqlParser.KW_TERMINATED, i);
		}
	}
	public KW_BY(): TerminalNode[];
	public KW_BY(i: number): TerminalNode;
	public KW_BY(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_BY);
		} else {
			return this.getToken(SparkSqlParser.KW_BY, i);
		}
	}
	public KW_COLLECTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLECTION, 0); }
	public KW_ITEMS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ITEMS, 0); }
	public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
	public KW_KEYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_KEYS, 0); }
	public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LINES, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public KW_DEFINED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFINED, 0); }
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPED, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_rowFormat; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterRowFormat) {
			listener.enterRowFormat(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitRowFormat) {
			listener.exitRowFormat(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitRowFormat) {
			return visitor.visitRowFormat(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MultipartIdentifierListContext extends ParserRuleContext {
	public multipartIdentifier(): MultipartIdentifierContext[];
	public multipartIdentifier(i: number): MultipartIdentifierContext;
	public multipartIdentifier(i?: number): MultipartIdentifierContext | MultipartIdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(MultipartIdentifierContext);
		} else {
			return this.getRuleContext(i, MultipartIdentifierContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifierList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMultipartIdentifierList) {
			listener.enterMultipartIdentifierList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMultipartIdentifierList) {
			listener.exitMultipartIdentifierList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMultipartIdentifierList) {
			return visitor.visitMultipartIdentifierList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MultipartIdentifierContext extends ParserRuleContext {
	public _errorCapturingIdentifier!: ErrorCapturingIdentifierContext;
	public _parts: ErrorCapturingIdentifierContext[] = [];
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
	public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
	public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ErrorCapturingIdentifierContext);
		} else {
			return this.getRuleContext(i, ErrorCapturingIdentifierContext);
		}
	}
	public DOT(): TerminalNode[];
	public DOT(i: number): TerminalNode;
	public DOT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.DOT);
		} else {
			return this.getToken(SparkSqlParser.DOT, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMultipartIdentifier) {
			listener.enterMultipartIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMultipartIdentifier) {
			listener.exitMultipartIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMultipartIdentifier) {
			return visitor.visitMultipartIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MultipartIdentifierPropertyListContext extends ParserRuleContext {
	public multipartIdentifierProperty(): MultipartIdentifierPropertyContext[];
	public multipartIdentifierProperty(i: number): MultipartIdentifierPropertyContext;
	public multipartIdentifierProperty(i?: number): MultipartIdentifierPropertyContext | MultipartIdentifierPropertyContext[] {
		if (i === undefined) {
			return this.getRuleContexts(MultipartIdentifierPropertyContext);
		} else {
			return this.getRuleContext(i, MultipartIdentifierPropertyContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifierPropertyList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMultipartIdentifierPropertyList) {
			listener.enterMultipartIdentifierPropertyList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMultipartIdentifierPropertyList) {
			listener.exitMultipartIdentifierPropertyList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMultipartIdentifierPropertyList) {
			return visitor.visitMultipartIdentifierPropertyList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MultipartIdentifierPropertyContext extends ParserRuleContext {
	public _options!: PropertyListContext;
	public multipartIdentifier(): MultipartIdentifierContext {
		return this.getRuleContext(0, MultipartIdentifierContext);
	}
	public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
	public propertyList(): PropertyListContext | undefined {
		return this.tryGetRuleContext(0, PropertyListContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_multipartIdentifierProperty; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMultipartIdentifierProperty) {
			listener.enterMultipartIdentifierProperty(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMultipartIdentifierProperty) {
			listener.exitMultipartIdentifierProperty(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMultipartIdentifierProperty) {
			return visitor.visitMultipartIdentifierProperty(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TableIdentifierContext extends ParserRuleContext {
	public _db!: ErrorCapturingIdentifierContext;
	public _table!: ErrorCapturingIdentifierContext;
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
	public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
	public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ErrorCapturingIdentifierContext);
		} else {
			return this.getRuleContext(i, ErrorCapturingIdentifierContext);
		}
	}
	public DOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_tableIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTableIdentifier) {
			listener.enterTableIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTableIdentifier) {
			listener.exitTableIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTableIdentifier) {
			return visitor.visitTableIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ViewIdentifierContext extends ParserRuleContext {
	public _db!: ErrorCapturingIdentifierContext;
	public _view!: ErrorCapturingIdentifierContext;
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
	public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext;
	public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext | ErrorCapturingIdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ErrorCapturingIdentifierContext);
		} else {
			return this.getRuleContext(i, ErrorCapturingIdentifierContext);
		}
	}
	public DOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_viewIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterViewIdentifier) {
			listener.enterViewIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitViewIdentifier) {
			listener.exitViewIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitViewIdentifier) {
			return visitor.visitViewIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NamedExpressionContext extends ParserRuleContext {
	public _name!: ErrorCapturingIdentifierContext;
	public columnName(): ColumnNameContext | undefined {
		return this.tryGetRuleContext(0, ColumnNameContext);
	}
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public identifierList(): IdentifierListContext | undefined {
		return this.tryGetRuleContext(0, IdentifierListContext);
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
		return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_namedExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNamedExpression) {
			listener.enterNamedExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNamedExpression) {
			listener.exitNamedExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNamedExpression) {
			return visitor.visitNamedExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NamedExpressionSeqContext extends ParserRuleContext {
	public namedExpression(): NamedExpressionContext[];
	public namedExpression(i: number): NamedExpressionContext;
	public namedExpression(i?: number): NamedExpressionContext | NamedExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NamedExpressionContext);
		} else {
			return this.getRuleContext(i, NamedExpressionContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_namedExpressionSeq; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNamedExpressionSeq) {
			listener.enterNamedExpressionSeq(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNamedExpressionSeq) {
			listener.exitNamedExpressionSeq(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNamedExpressionSeq) {
			return visitor.visitNamedExpressionSeq(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PartitionFieldListContext extends ParserRuleContext {
	public _partitionField!: PartitionFieldContext;
	public _fields: PartitionFieldContext[] = [];
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public partitionField(): PartitionFieldContext[];
	public partitionField(i: number): PartitionFieldContext;
	public partitionField(i?: number): PartitionFieldContext | PartitionFieldContext[] {
		if (i === undefined) {
			return this.getRuleContexts(PartitionFieldContext);
		} else {
			return this.getRuleContext(i, PartitionFieldContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_partitionFieldList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPartitionFieldList) {
			listener.enterPartitionFieldList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPartitionFieldList) {
			listener.exitPartitionFieldList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPartitionFieldList) {
			return visitor.visitPartitionFieldList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PartitionFieldContext extends ParserRuleContext {
	public transform(): TransformContext | undefined {
		return this.tryGetRuleContext(0, TransformContext);
	}
	public colType(): ColTypeContext | undefined {
		return this.tryGetRuleContext(0, ColTypeContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_partitionField; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPartitionField) {
			listener.enterPartitionField(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPartitionField) {
			listener.exitPartitionField(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPartitionField) {
			return visitor.visitPartitionField(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TransformContext extends ParserRuleContext {
	public _transformName!: IdentifierContext;
	public qualifiedName(): QualifiedNameContext | undefined {
		return this.tryGetRuleContext(0, QualifiedNameContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public transformArgument(): TransformArgumentContext[];
	public transformArgument(i: number): TransformArgumentContext;
	public transformArgument(i?: number): TransformArgumentContext | TransformArgumentContext[] {
		if (i === undefined) {
			return this.getRuleContexts(TransformArgumentContext);
		} else {
			return this.getRuleContext(i, TransformArgumentContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_transform; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTransform) {
			listener.enterTransform(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTransform) {
			listener.exitTransform(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTransform) {
			return visitor.visitTransform(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TransformArgumentContext extends ParserRuleContext {
	public qualifiedName(): QualifiedNameContext | undefined {
		return this.tryGetRuleContext(0, QualifiedNameContext);
	}
	public constant(): ConstantContext | undefined {
		return this.tryGetRuleContext(0, ConstantContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_transformArgument; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterTransformArgument) {
			listener.enterTransformArgument(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitTransformArgument) {
			listener.exitTransformArgument(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitTransformArgument) {
			return visitor.visitTransformArgument(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExpressionContext extends ParserRuleContext {
	public booleanExpression(): BooleanExpressionContext {
		return this.getRuleContext(0, BooleanExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_expression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterExpression) {
			listener.enterExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitExpression) {
			listener.exitExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitExpression) {
			return visitor.visitExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NamedArgumentExpressionContext extends ParserRuleContext {
	public _key!: IdentifierContext;
	public _value!: ExpressionContext;
	public FAT_ARROW(): TerminalNode { return this.getToken(SparkSqlParser.FAT_ARROW, 0); }
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public expression(): ExpressionContext {
		return this.getRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_namedArgumentExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNamedArgumentExpression) {
			listener.enterNamedArgumentExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNamedArgumentExpression) {
			listener.exitNamedArgumentExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNamedArgumentExpression) {
			return visitor.visitNamedArgumentExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionArgumentContext extends ParserRuleContext {
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public namedArgumentExpression(): NamedArgumentExpressionContext | undefined {
		return this.tryGetRuleContext(0, NamedArgumentExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionArgument; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionArgument) {
			listener.enterFunctionArgument(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionArgument) {
			listener.exitFunctionArgument(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionArgument) {
			return visitor.visitFunctionArgument(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ExpressionSeqContext extends ParserRuleContext {
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_expressionSeq; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterExpressionSeq) {
			listener.enterExpressionSeq(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitExpressionSeq) {
			listener.exitExpressionSeq(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitExpressionSeq) {
			return visitor.visitExpressionSeq(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BooleanExpressionContext extends ParserRuleContext {
	public _left!: BooleanExpressionContext;
	public _operator!: Token;
	public _right!: BooleanExpressionContext;
	public booleanExpression(): BooleanExpressionContext[];
	public booleanExpression(i: number): BooleanExpressionContext;
	public booleanExpression(i?: number): BooleanExpressionContext | BooleanExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(BooleanExpressionContext);
		} else {
			return this.getRuleContext(i, BooleanExpressionContext);
		}
	}
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NOT, 0); }
	public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXISTS, 0); }
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public valueExpression(): ValueExpressionContext | undefined {
		return this.tryGetRuleContext(0, ValueExpressionContext);
	}
	public predicate(): PredicateContext | undefined {
		return this.tryGetRuleContext(0, PredicateContext);
	}
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_booleanExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterBooleanExpression) {
			listener.enterBooleanExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitBooleanExpression) {
			listener.exitBooleanExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitBooleanExpression) {
			return visitor.visitBooleanExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PredicateContext extends ParserRuleContext {
	public _kind!: Token;
	public _lower!: ValueExpressionContext;
	public _upper!: ValueExpressionContext;
	public _pattern!: ValueExpressionContext;
	public _quantifier!: Token;
	public _escapeChar!: StringLitContext;
	public _right!: ValueExpressionContext;
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
	public valueExpression(): ValueExpressionContext[];
	public valueExpression(i: number): ValueExpressionContext;
	public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueExpressionContext);
		} else {
			return this.getRuleContext(i, ValueExpressionContext);
		}
	}
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RLIKE, 0); }
	public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REGEXP, 0); }
	public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
	public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ILIKE, 0); }
	public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY, 0); }
	public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOME, 0); }
	public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
	public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPE, 0); }
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public KW_IS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IS, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
	public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FALSE, 0); }
	public KW_UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNKNOWN, 0); }
	public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
	public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTINCT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_predicate; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPredicate) {
			listener.enterPredicate(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPredicate) {
			listener.exitPredicate(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPredicate) {
			return visitor.visitPredicate(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ValueExpressionContext extends ParserRuleContext {
	public _left!: ValueExpressionContext;
	public _operator!: Token;
	public _right!: ValueExpressionContext;
	public primaryExpression(): PrimaryExpressionContext | undefined {
		return this.tryGetRuleContext(0, PrimaryExpressionContext);
	}
	public valueExpression(): ValueExpressionContext[];
	public valueExpression(i: number): ValueExpressionContext;
	public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueExpressionContext);
		} else {
			return this.getRuleContext(i, ValueExpressionContext);
		}
	}
	public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
	public PLUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PLUS, 0); }
	public TILDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.TILDE, 0); }
	public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
	public SLASH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SLASH, 0); }
	public PERCENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PERCENT, 0); }
	public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
	public CONCAT_PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.CONCAT_PIPE, 0); }
	public AMPERSAND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.AMPERSAND, 0); }
	public HAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.HAT, 0); }
	public PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PIPE, 0); }
	public comparisonOperator(): ComparisonOperatorContext | undefined {
		return this.tryGetRuleContext(0, ComparisonOperatorContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_valueExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterValueExpression) {
			listener.enterValueExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitValueExpression) {
			listener.exitValueExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitValueExpression) {
			return visitor.visitValueExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DatetimeUnitContext extends ParserRuleContext {
	public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
	public KW_QUARTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUARTER, 0); }
	public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
	public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
	public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
	public KW_DAYOFYEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYOFYEAR, 0); }
	public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
	public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
	public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
	public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
	public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_datetimeUnit; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDatetimeUnit) {
			listener.enterDatetimeUnit(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDatetimeUnit) {
			listener.exitDatetimeUnit(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDatetimeUnit) {
			return visitor.visitDatetimeUnit(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PrimaryExpressionContext extends ParserRuleContext {
	public _value!: PrimaryExpressionContext;
	public _base!: PrimaryExpressionContext;
	public _name!: Token;
	public _unit!: DatetimeUnitContext;
	public _invalidUnit!: StringLitContext;
	public _unitsAmount!: ValueExpressionContext;
	public _timestamp!: ValueExpressionContext;
	public _startTimestamp!: ValueExpressionContext;
	public _endTimestamp!: ValueExpressionContext;
	public _elseExpression!: ExpressionContext;
	public _substr!: ValueExpressionContext;
	public _str!: ValueExpressionContext;
	public _where!: BooleanExpressionContext;
	public _nullsOption!: Token;
	public _field!: IdentifierContext;
	public _source!: ValueExpressionContext;
	public _pos!: ValueExpressionContext;
	public _len!: ValueExpressionContext;
	public _trimOption!: Token;
	public _trimStr!: ValueExpressionContext;
	public _srcStr!: ValueExpressionContext;
	public _input!: ValueExpressionContext;
	public _replace!: ValueExpressionContext;
	public _position!: ValueExpressionContext;
	public _length!: ValueExpressionContext;
	public _percentage!: ValueExpressionContext;
	public _index!: ValueExpressionContext;
	public _fieldName!: IdentifierContext;
	public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_DATE, 0); }
	public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_TIMESTAMP, 0); }
	public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_USER, 0); }
	public KW_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USER, 0); }
	public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SESSION_USER, 0); }
	public LEFT_PAREN(): TerminalNode[];
	public LEFT_PAREN(i: number): TerminalNode;
	public LEFT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.LEFT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.LEFT_PAREN, i);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public RIGHT_PAREN(): TerminalNode[];
	public RIGHT_PAREN(i: number): TerminalNode;
	public RIGHT_PAREN(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.RIGHT_PAREN);
		} else {
			return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
		}
	}
	public valueExpression(): ValueExpressionContext[];
	public valueExpression(i: number): ValueExpressionContext;
	public valueExpression(i?: number): ValueExpressionContext | ValueExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ValueExpressionContext);
		} else {
			return this.getRuleContext(i, ValueExpressionContext);
		}
	}
	public KW_TIMESTAMPADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPADD, 0); }
	public KW_DATEADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEADD, 0); }
	public KW_DATE_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_ADD, 0); }
	public datetimeUnit(): DatetimeUnitContext | undefined {
		return this.tryGetRuleContext(0, DatetimeUnitContext);
	}
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public KW_TIMESTAMPDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0); }
	public KW_DATEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEDIFF, 0); }
	public KW_DATE_DIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_DIFF, 0); }
	public KW_TIMEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMEDIFF, 0); }
	public KW_CASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASE, 0); }
	public KW_END(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_END, 0); }
	public whenClause(): WhenClauseContext[];
	public whenClause(i: number): WhenClauseContext;
	public whenClause(i?: number): WhenClauseContext | WhenClauseContext[] {
		if (i === undefined) {
			return this.getRuleContexts(WhenClauseContext);
		} else {
			return this.getRuleContext(i, WhenClauseContext);
		}
	}
	public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ELSE, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public dataType(): DataTypeContext | undefined {
		return this.tryGetRuleContext(0, DataTypeContext);
	}
	public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CAST, 0); }
	public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRY_CAST, 0); }
	public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
	public namedExpression(): NamedExpressionContext[];
	public namedExpression(i: number): NamedExpressionContext;
	public namedExpression(i?: number): NamedExpressionContext | NamedExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NamedExpressionContext);
		} else {
			return this.getRuleContext(i, NamedExpressionContext);
		}
	}
	public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
	public KW_IGNORE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IGNORE, 0); }
	public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
	public KW_ANY_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY_VALUE, 0); }
	public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
	public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_POSITION, 0); }
	public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
	public constant(): ConstantContext | undefined {
		return this.tryGetRuleContext(0, ConstantContext);
	}
	public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
	public qualifiedName(): QualifiedNameContext | undefined {
		return this.tryGetRuleContext(0, QualifiedNameContext);
	}
	public DOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOT, 0); }
	public query(): QueryContext | undefined {
		return this.tryGetRuleContext(0, QueryContext);
	}
	public KW_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER, 0); }
	public functionName(): FunctionNameContext | undefined {
		return this.tryGetRuleContext(0, FunctionNameContext);
	}
	public functionArgument(): FunctionArgumentContext[];
	public functionArgument(i: number): FunctionArgumentContext;
	public functionArgument(i?: number): FunctionArgumentContext | FunctionArgumentContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FunctionArgumentContext);
		} else {
			return this.getRuleContext(i, FunctionArgumentContext);
		}
	}
	public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILTER, 0); }
	public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WHERE, 0); }
	public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVER, 0); }
	public windowSpec(): WindowSpecContext | undefined {
		return this.tryGetRuleContext(0, WindowSpecContext);
	}
	public booleanExpression(): BooleanExpressionContext | undefined {
		return this.tryGetRuleContext(0, BooleanExpressionContext);
	}
	public KW_RESPECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESPECT, 0); }
	public setQuantifier(): SetQuantifierContext | undefined {
		return this.tryGetRuleContext(0, SetQuantifierContext);
	}
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public ARROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ARROW, 0); }
	public LEFT_BRACKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_BRACKET, 0); }
	public RIGHT_BRACKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_BRACKET, 0); }
	public primaryExpression(): PrimaryExpressionContext | undefined {
		return this.tryGetRuleContext(0, PrimaryExpressionContext);
	}
	public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTRACT, 0); }
	public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
	public KW_SUBSTR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTR, 0); }
	public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTRING, 0); }
	public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
	public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRIM, 0); }
	public KW_BOTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOTH, 0); }
	public KW_LEADING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEADING, 0); }
	public KW_TRAILING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRAILING, 0); }
	public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAY, 0); }
	public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PLACING, 0); }
	public KW_WITHIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITHIN, 0); }
	public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUP, 0); }
	public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public sortItem(): SortItemContext | undefined {
		return this.tryGetRuleContext(0, SortItemContext);
	}
	public KW_PERCENTILE_CONT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_CONT, 0); }
	public KW_PERCENTILE_DISC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_DISC, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_primaryExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPrimaryExpression) {
			listener.enterPrimaryExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPrimaryExpression) {
			listener.exitPrimaryExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPrimaryExpression) {
			return visitor.visitPrimaryExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class LiteralTypeContext extends ParserRuleContext {
	public _unsupportedType!: IdentifierContext;
	public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
	public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
	public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
	public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
	public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
	public KW_BINARY_HEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY_HEX, 0); }
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_literalType; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterLiteralType) {
			listener.enterLiteralType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitLiteralType) {
			listener.exitLiteralType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitLiteralType) {
			return visitor.visitLiteralType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ConstantContext extends ParserRuleContext {
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public QUESTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.QUESTION, 0); }
	public COLON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.COLON, 0); }
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	public interval(): IntervalContext | undefined {
		return this.tryGetRuleContext(0, IntervalContext);
	}
	public literalType(): LiteralTypeContext | undefined {
		return this.tryGetRuleContext(0, LiteralTypeContext);
	}
	public stringLit(): StringLitContext[];
	public stringLit(i: number): StringLitContext;
	public stringLit(i?: number): StringLitContext | StringLitContext[] {
		if (i === undefined) {
			return this.getRuleContexts(StringLitContext);
		} else {
			return this.getRuleContext(i, StringLitContext);
		}
	}
	public number(): NumberContext | undefined {
		return this.tryGetRuleContext(0, NumberContext);
	}
	public booleanValue(): BooleanValueContext | undefined {
		return this.tryGetRuleContext(0, BooleanValueContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_constant; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterConstant) {
			listener.enterConstant(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitConstant) {
			listener.exitConstant(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitConstant) {
			return visitor.visitConstant(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ComparisonOperatorContext extends ParserRuleContext {
	public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
	public NEQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NEQ, 0); }
	public NEQJ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NEQJ, 0); }
	public LT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LT, 0); }
	public LTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LTE, 0); }
	public GT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.GT, 0); }
	public GTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.GTE, 0); }
	public NSEQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NSEQ, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_comparisonOperator; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterComparisonOperator) {
			listener.enterComparisonOperator(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitComparisonOperator) {
			listener.exitComparisonOperator(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitComparisonOperator) {
			return visitor.visitComparisonOperator(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ArithmeticOperatorContext extends ParserRuleContext {
	public PLUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PLUS, 0); }
	public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
	public ASTERISK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.ASTERISK, 0); }
	public SLASH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SLASH, 0); }
	public PERCENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PERCENT, 0); }
	public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
	public TILDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.TILDE, 0); }
	public AMPERSAND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.AMPERSAND, 0); }
	public PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PIPE, 0); }
	public CONCAT_PIPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.CONCAT_PIPE, 0); }
	public HAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.HAT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_arithmeticOperator; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterArithmeticOperator) {
			listener.enterArithmeticOperator(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitArithmeticOperator) {
			listener.exitArithmeticOperator(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitArithmeticOperator) {
			return visitor.visitArithmeticOperator(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class PredicateOperatorContext extends ParserRuleContext {
	public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_predicateOperator; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterPredicateOperator) {
			listener.enterPredicateOperator(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitPredicateOperator) {
			listener.exitPredicateOperator(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitPredicateOperator) {
			return visitor.visitPredicateOperator(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BooleanValueContext extends ParserRuleContext {
	public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
	public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FALSE, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_booleanValue; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterBooleanValue) {
			listener.enterBooleanValue(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitBooleanValue) {
			listener.exitBooleanValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitBooleanValue) {
			return visitor.visitBooleanValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IntervalContext extends ParserRuleContext {
	public KW_INTERVAL(): TerminalNode { return this.getToken(SparkSqlParser.KW_INTERVAL, 0); }
	public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext | undefined {
		return this.tryGetRuleContext(0, ErrorCapturingMultiUnitsIntervalContext);
	}
	public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext | undefined {
		return this.tryGetRuleContext(0, ErrorCapturingUnitToUnitIntervalContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_interval; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterInterval) {
			listener.enterInterval(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitInterval) {
			listener.exitInterval(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitInterval) {
			return visitor.visitInterval(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ErrorCapturingMultiUnitsIntervalContext extends ParserRuleContext {
	public _body!: MultiUnitsIntervalContext;
	public multiUnitsInterval(): MultiUnitsIntervalContext {
		return this.getRuleContext(0, MultiUnitsIntervalContext);
	}
	public unitToUnitInterval(): UnitToUnitIntervalContext | undefined {
		return this.tryGetRuleContext(0, UnitToUnitIntervalContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingMultiUnitsInterval; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterErrorCapturingMultiUnitsInterval) {
			listener.enterErrorCapturingMultiUnitsInterval(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitErrorCapturingMultiUnitsInterval) {
			listener.exitErrorCapturingMultiUnitsInterval(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitErrorCapturingMultiUnitsInterval) {
			return visitor.visitErrorCapturingMultiUnitsInterval(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class MultiUnitsIntervalContext extends ParserRuleContext {
	public _unitInMultiUnits!: UnitInMultiUnitsContext;
	public _unit: UnitInMultiUnitsContext[] = [];
	public intervalValue(): IntervalValueContext[];
	public intervalValue(i: number): IntervalValueContext;
	public intervalValue(i?: number): IntervalValueContext | IntervalValueContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IntervalValueContext);
		} else {
			return this.getRuleContext(i, IntervalValueContext);
		}
	}
	public unitInMultiUnits(): UnitInMultiUnitsContext[];
	public unitInMultiUnits(i: number): UnitInMultiUnitsContext;
	public unitInMultiUnits(i?: number): UnitInMultiUnitsContext | UnitInMultiUnitsContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnitInMultiUnitsContext);
		} else {
			return this.getRuleContext(i, UnitInMultiUnitsContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_multiUnitsInterval; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterMultiUnitsInterval) {
			listener.enterMultiUnitsInterval(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitMultiUnitsInterval) {
			listener.exitMultiUnitsInterval(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitMultiUnitsInterval) {
			return visitor.visitMultiUnitsInterval(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ErrorCapturingUnitToUnitIntervalContext extends ParserRuleContext {
	public _body!: UnitToUnitIntervalContext;
	public _error1!: MultiUnitsIntervalContext;
	public _error2!: UnitToUnitIntervalContext;
	public unitToUnitInterval(): UnitToUnitIntervalContext[];
	public unitToUnitInterval(i: number): UnitToUnitIntervalContext;
	public unitToUnitInterval(i?: number): UnitToUnitIntervalContext | UnitToUnitIntervalContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnitToUnitIntervalContext);
		} else {
			return this.getRuleContext(i, UnitToUnitIntervalContext);
		}
	}
	public multiUnitsInterval(): MultiUnitsIntervalContext | undefined {
		return this.tryGetRuleContext(0, MultiUnitsIntervalContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingUnitToUnitInterval; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterErrorCapturingUnitToUnitInterval) {
			listener.enterErrorCapturingUnitToUnitInterval(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitErrorCapturingUnitToUnitInterval) {
			listener.exitErrorCapturingUnitToUnitInterval(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitErrorCapturingUnitToUnitInterval) {
			return visitor.visitErrorCapturingUnitToUnitInterval(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnitToUnitIntervalContext extends ParserRuleContext {
	public _value!: IntervalValueContext;
	public unitInUnitToUnit(): UnitInUnitToUnitContext[];
	public unitInUnitToUnit(i: number): UnitInUnitToUnitContext;
	public unitInUnitToUnit(i?: number): UnitInUnitToUnitContext | UnitInUnitToUnitContext[] {
		if (i === undefined) {
			return this.getRuleContexts(UnitInUnitToUnitContext);
		} else {
			return this.getRuleContext(i, UnitInUnitToUnitContext);
		}
	}
	public KW_TO(): TerminalNode { return this.getToken(SparkSqlParser.KW_TO, 0); }
	public intervalValue(): IntervalValueContext {
		return this.getRuleContext(0, IntervalValueContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unitToUnitInterval; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnitToUnitInterval) {
			listener.enterUnitToUnitInterval(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnitToUnitInterval) {
			listener.exitUnitToUnitInterval(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnitToUnitInterval) {
			return visitor.visitUnitToUnitInterval(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IntervalValueContext extends ParserRuleContext {
	public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
	public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public PLUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.PLUS, 0); }
	public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_intervalValue; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIntervalValue) {
			listener.enterIntervalValue(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIntervalValue) {
			listener.exitIntervalValue(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIntervalValue) {
			return visitor.visitIntervalValue(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnitInMultiUnitsContext extends ParserRuleContext {
	public KW_NANOSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECOND, 0); }
	public KW_NANOSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECONDS, 0); }
	public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
	public KW_MICROSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECONDS, 0); }
	public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
	public KW_MILLISECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECONDS, 0); }
	public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
	public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECONDS, 0); }
	public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
	public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTES, 0); }
	public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
	public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOURS, 0); }
	public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
	public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYS, 0); }
	public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
	public KW_WEEKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEKS, 0); }
	public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
	public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTHS, 0); }
	public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
	public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEARS, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unitInMultiUnits; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnitInMultiUnits) {
			listener.enterUnitInMultiUnits(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnitInMultiUnits) {
			listener.exitUnitInMultiUnits(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnitInMultiUnits) {
			return visitor.visitUnitInMultiUnits(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class UnitInUnitToUnitContext extends ParserRuleContext {
	public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
	public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
	public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
	public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
	public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
	public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_unitInUnitToUnit; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterUnitInUnitToUnit) {
			listener.enterUnitInUnitToUnit(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitUnitInUnitToUnit) {
			listener.exitUnitInUnitToUnit(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitUnitInUnitToUnit) {
			return visitor.visitUnitInUnitToUnit(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColPositionContext extends ParserRuleContext {
	public _position!: Token;
	public _afterCol!: ErrorCapturingIdentifierContext;
	public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
	public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AFTER, 0); }
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
		return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_colPosition; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColPosition) {
			listener.enterColPosition(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColPosition) {
			listener.exitColPosition(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColPosition) {
			return visitor.visitColPosition(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class TypeContext extends ParserRuleContext {
	public _unsupportedType!: IdentifierContext;
	public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOOLEAN, 0); }
	public KW_TINYINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TINYINT, 0); }
	public KW_BYTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BYTE, 0); }
	public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SMALLINT, 0); }
	public KW_SHORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHORT, 0); }
	public KW_INT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INT, 0); }
	public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTEGER, 0); }
	public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BIGINT, 0); }
	public KW_LONG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LONG, 0); }
	public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FLOAT, 0); }
	public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REAL, 0); }
	public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DOUBLE, 0); }
	public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
	public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
	public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
	public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
	public KW_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRING, 0); }
	public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHARACTER, 0); }
	public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHAR, 0); }
	public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARCHAR, 0); }
	public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY, 0); }
	public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECIMAL, 0); }
	public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEC, 0); }
	public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NUMERIC, 0); }
	public KW_VOID(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VOID, 0); }
	public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
	public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
	public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
	public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
	public identifier(): IdentifierContext | undefined {
		return this.tryGetRuleContext(0, IdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_type; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterType) {
			listener.enterType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitType) {
			listener.exitType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitType) {
			return visitor.visitType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DataTypeContext extends ParserRuleContext {
	public _complex!: Token;
	public LT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LT, 0); }
	public dataType(): DataTypeContext[];
	public dataType(i: number): DataTypeContext;
	public dataType(i?: number): DataTypeContext | DataTypeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(DataTypeContext);
		} else {
			return this.getRuleContext(i, DataTypeContext);
		}
	}
	public GT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.GT, 0); }
	public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
	public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
	public NEQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.NEQ, 0); }
	public complexColTypeList(): ComplexColTypeListContext | undefined {
		return this.tryGetRuleContext(0, ComplexColTypeListContext);
	}
	public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
	public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
	public KW_MONTH(): TerminalNode[];
	public KW_MONTH(i: number): TerminalNode;
	public KW_MONTH(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_MONTH);
		} else {
			return this.getToken(SparkSqlParser.KW_MONTH, i);
		}
	}
	public KW_TO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TO, 0); }
	public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
	public KW_HOUR(): TerminalNode[];
	public KW_HOUR(i: number): TerminalNode;
	public KW_HOUR(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_HOUR);
		} else {
			return this.getToken(SparkSqlParser.KW_HOUR, i);
		}
	}
	public KW_MINUTE(): TerminalNode[];
	public KW_MINUTE(i: number): TerminalNode;
	public KW_MINUTE(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_MINUTE);
		} else {
			return this.getToken(SparkSqlParser.KW_MINUTE, i);
		}
	}
	public KW_SECOND(): TerminalNode[];
	public KW_SECOND(i: number): TerminalNode;
	public KW_SECOND(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_SECOND);
		} else {
			return this.getToken(SparkSqlParser.KW_SECOND, i);
		}
	}
	public type(): TypeContext | undefined {
		return this.tryGetRuleContext(0, TypeContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public INTEGER_VALUE(): TerminalNode[];
	public INTEGER_VALUE(i: number): TerminalNode;
	public INTEGER_VALUE(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.INTEGER_VALUE);
		} else {
			return this.getToken(SparkSqlParser.INTEGER_VALUE, i);
		}
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_dataType; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDataType) {
			listener.enterDataType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDataType) {
			listener.exitDataType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDataType) {
			return visitor.visitDataType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QualifiedColTypeWithPositionSeqForAddContext extends ParserRuleContext {
	public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext[];
	public qualifiedColTypeWithPositionForAdd(i: number): QualifiedColTypeWithPositionForAddContext;
	public qualifiedColTypeWithPositionForAdd(i?: number): QualifiedColTypeWithPositionForAddContext | QualifiedColTypeWithPositionForAddContext[] {
		if (i === undefined) {
			return this.getRuleContexts(QualifiedColTypeWithPositionForAddContext);
		} else {
			return this.getRuleContext(i, QualifiedColTypeWithPositionForAddContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForAdd; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedColTypeWithPositionSeqForAdd) {
			listener.enterQualifiedColTypeWithPositionSeqForAdd(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedColTypeWithPositionSeqForAdd) {
			listener.exitQualifiedColTypeWithPositionSeqForAdd(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedColTypeWithPositionSeqForAdd) {
			return visitor.visitQualifiedColTypeWithPositionSeqForAdd(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QualifiedColTypeWithPositionForAddContext extends ParserRuleContext {
	public _name!: ColumnNameCreateContext;
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public columnNameCreate(): ColumnNameCreateContext {
		return this.getRuleContext(0, ColumnNameCreateContext);
	}
	public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[];
	public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext;
	public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext | ColDefinitionDescriptorWithPositionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext);
		} else {
			return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedColTypeWithPositionForAdd; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedColTypeWithPositionForAdd) {
			listener.enterQualifiedColTypeWithPositionForAdd(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedColTypeWithPositionForAdd) {
			listener.exitQualifiedColTypeWithPositionForAdd(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedColTypeWithPositionForAdd) {
			return visitor.visitQualifiedColTypeWithPositionForAdd(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QualifiedColTypeWithPositionSeqForReplaceContext extends ParserRuleContext {
	public qualifiedColTypeWithPositionForReplace(): QualifiedColTypeWithPositionForReplaceContext[];
	public qualifiedColTypeWithPositionForReplace(i: number): QualifiedColTypeWithPositionForReplaceContext;
	public qualifiedColTypeWithPositionForReplace(i?: number): QualifiedColTypeWithPositionForReplaceContext | QualifiedColTypeWithPositionForReplaceContext[] {
		if (i === undefined) {
			return this.getRuleContexts(QualifiedColTypeWithPositionForReplaceContext);
		} else {
			return this.getRuleContext(i, QualifiedColTypeWithPositionForReplaceContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForReplace; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedColTypeWithPositionSeqForReplace) {
			listener.enterQualifiedColTypeWithPositionSeqForReplace(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedColTypeWithPositionSeqForReplace) {
			listener.exitQualifiedColTypeWithPositionSeqForReplace(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedColTypeWithPositionSeqForReplace) {
			return visitor.visitQualifiedColTypeWithPositionSeqForReplace(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QualifiedColTypeWithPositionForReplaceContext extends ParserRuleContext {
	public _name!: ColumnNameContext;
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public columnName(): ColumnNameContext {
		return this.getRuleContext(0, ColumnNameContext);
	}
	public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[];
	public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext;
	public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext | ColDefinitionDescriptorWithPositionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext);
		} else {
			return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedColTypeWithPositionForReplace; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedColTypeWithPositionForReplace) {
			listener.enterQualifiedColTypeWithPositionForReplace(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedColTypeWithPositionForReplace) {
			listener.exitQualifiedColTypeWithPositionForReplace(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedColTypeWithPositionForReplace) {
			return visitor.visitQualifiedColTypeWithPositionForReplace(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColDefinitionDescriptorWithPositionContext extends ParserRuleContext {
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public defaultExpression(): DefaultExpressionContext | undefined {
		return this.tryGetRuleContext(0, DefaultExpressionContext);
	}
	public commentSpec(): CommentSpecContext | undefined {
		return this.tryGetRuleContext(0, CommentSpecContext);
	}
	public colPosition(): ColPositionContext | undefined {
		return this.tryGetRuleContext(0, ColPositionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_colDefinitionDescriptorWithPosition; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColDefinitionDescriptorWithPosition) {
			listener.enterColDefinitionDescriptorWithPosition(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColDefinitionDescriptorWithPosition) {
			listener.exitColDefinitionDescriptorWithPosition(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColDefinitionDescriptorWithPosition) {
			return visitor.visitColDefinitionDescriptorWithPosition(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class DefaultExpressionContext extends ParserRuleContext {
	public KW_DEFAULT(): TerminalNode { return this.getToken(SparkSqlParser.KW_DEFAULT, 0); }
	public expression(): ExpressionContext {
		return this.getRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_defaultExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterDefaultExpression) {
			listener.enterDefaultExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitDefaultExpression) {
			listener.exitDefaultExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitDefaultExpression) {
			return visitor.visitDefaultExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class VariableDefaultExpressionContext extends ParserRuleContext {
	public expression(): ExpressionContext {
		return this.getRuleContext(0, ExpressionContext);
	}
	public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
	public EQ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EQ, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_variableDefaultExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterVariableDefaultExpression) {
			listener.enterVariableDefaultExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitVariableDefaultExpression) {
			listener.exitVariableDefaultExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitVariableDefaultExpression) {
			return visitor.visitVariableDefaultExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColTypeListContext extends ParserRuleContext {
	public colType(): ColTypeContext[];
	public colType(i: number): ColTypeContext;
	public colType(i?: number): ColTypeContext | ColTypeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ColTypeContext);
		} else {
			return this.getRuleContext(i, ColTypeContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_colTypeList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColTypeList) {
			listener.enterColTypeList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColTypeList) {
			listener.exitColTypeList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColTypeList) {
			return visitor.visitColTypeList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColTypeContext extends ParserRuleContext {
	public _colName!: ErrorCapturingIdentifierContext;
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierContext);
	}
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public commentSpec(): CommentSpecContext | undefined {
		return this.tryGetRuleContext(0, CommentSpecContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_colType; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColType) {
			listener.enterColType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColType) {
			listener.exitColType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColType) {
			return visitor.visitColType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CreateOrReplaceTableColTypeListContext extends ParserRuleContext {
	public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext[];
	public createOrReplaceTableColType(i: number): CreateOrReplaceTableColTypeContext;
	public createOrReplaceTableColType(i?: number): CreateOrReplaceTableColTypeContext | CreateOrReplaceTableColTypeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(CreateOrReplaceTableColTypeContext);
		} else {
			return this.getRuleContext(i, CreateOrReplaceTableColTypeContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_createOrReplaceTableColTypeList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCreateOrReplaceTableColTypeList) {
			listener.enterCreateOrReplaceTableColTypeList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCreateOrReplaceTableColTypeList) {
			listener.exitCreateOrReplaceTableColTypeList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCreateOrReplaceTableColTypeList) {
			return visitor.visitCreateOrReplaceTableColTypeList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CreateOrReplaceTableColTypeContext extends ParserRuleContext {
	public _colName!: ColumnNameCreateContext;
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public columnNameCreate(): ColumnNameCreateContext {
		return this.getRuleContext(0, ColumnNameCreateContext);
	}
	public colDefinitionOption(): ColDefinitionOptionContext[];
	public colDefinitionOption(i: number): ColDefinitionOptionContext;
	public colDefinitionOption(i?: number): ColDefinitionOptionContext | ColDefinitionOptionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ColDefinitionOptionContext);
		} else {
			return this.getRuleContext(i, ColDefinitionOptionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_createOrReplaceTableColType; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterCreateOrReplaceTableColType) {
			listener.enterCreateOrReplaceTableColType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitCreateOrReplaceTableColType) {
			listener.exitCreateOrReplaceTableColType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitCreateOrReplaceTableColType) {
			return visitor.visitCreateOrReplaceTableColType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ColDefinitionOptionContext extends ParserRuleContext {
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public defaultExpression(): DefaultExpressionContext | undefined {
		return this.tryGetRuleContext(0, DefaultExpressionContext);
	}
	public generationExpression(): GenerationExpressionContext | undefined {
		return this.tryGetRuleContext(0, GenerationExpressionContext);
	}
	public commentSpec(): CommentSpecContext | undefined {
		return this.tryGetRuleContext(0, CommentSpecContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_colDefinitionOption; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterColDefinitionOption) {
			listener.enterColDefinitionOption(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitColDefinitionOption) {
			listener.exitColDefinitionOption(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitColDefinitionOption) {
			return visitor.visitColDefinitionOption(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class GenerationExpressionContext extends ParserRuleContext {
	public KW_GENERATED(): TerminalNode { return this.getToken(SparkSqlParser.KW_GENERATED, 0); }
	public KW_ALWAYS(): TerminalNode { return this.getToken(SparkSqlParser.KW_ALWAYS, 0); }
	public KW_AS(): TerminalNode { return this.getToken(SparkSqlParser.KW_AS, 0); }
	public LEFT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.LEFT_PAREN, 0); }
	public expression(): ExpressionContext {
		return this.getRuleContext(0, ExpressionContext);
	}
	public RIGHT_PAREN(): TerminalNode { return this.getToken(SparkSqlParser.RIGHT_PAREN, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_generationExpression; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterGenerationExpression) {
			listener.enterGenerationExpression(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitGenerationExpression) {
			listener.exitGenerationExpression(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitGenerationExpression) {
			return visitor.visitGenerationExpression(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ComplexColTypeListContext extends ParserRuleContext {
	public complexColType(): ComplexColTypeContext[];
	public complexColType(i: number): ComplexColTypeContext;
	public complexColType(i?: number): ComplexColTypeContext | ComplexColTypeContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ComplexColTypeContext);
		} else {
			return this.getRuleContext(i, ComplexColTypeContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_complexColTypeList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterComplexColTypeList) {
			listener.enterComplexColTypeList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitComplexColTypeList) {
			listener.exitComplexColTypeList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitComplexColTypeList) {
			return visitor.visitComplexColTypeList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ComplexColTypeContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public COLON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.COLON, 0); }
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public commentSpec(): CommentSpecContext | undefined {
		return this.tryGetRuleContext(0, CommentSpecContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_complexColType; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterComplexColType) {
			listener.enterComplexColType(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitComplexColType) {
			listener.exitComplexColType(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitComplexColType) {
			return visitor.visitComplexColType(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class WhenClauseContext extends ParserRuleContext {
	public _condition!: ExpressionContext;
	public _result!: ExpressionContext;
	public KW_WHEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_WHEN, 0); }
	public KW_THEN(): TerminalNode { return this.getToken(SparkSqlParser.KW_THEN, 0); }
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_whenClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterWhenClause) {
			listener.enterWhenClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitWhenClause) {
			listener.exitWhenClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitWhenClause) {
			return visitor.visitWhenClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class WindowClauseContext extends ParserRuleContext {
	public KW_WINDOW(): TerminalNode { return this.getToken(SparkSqlParser.KW_WINDOW, 0); }
	public namedWindow(): NamedWindowContext[];
	public namedWindow(i: number): NamedWindowContext;
	public namedWindow(i?: number): NamedWindowContext | NamedWindowContext[] {
		if (i === undefined) {
			return this.getRuleContexts(NamedWindowContext);
		} else {
			return this.getRuleContext(i, NamedWindowContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_windowClause; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterWindowClause) {
			listener.enterWindowClause(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitWindowClause) {
			listener.exitWindowClause(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitWindowClause) {
			return visitor.visitWindowClause(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NamedWindowContext extends ParserRuleContext {
	public _name!: ErrorCapturingIdentifierContext;
	public KW_AS(): TerminalNode { return this.getToken(SparkSqlParser.KW_AS, 0); }
	public windowSpec(): WindowSpecContext {
		return this.getRuleContext(0, WindowSpecContext);
	}
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_namedWindow; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNamedWindow) {
			listener.enterNamedWindow(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNamedWindow) {
			listener.exitNamedWindow(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNamedWindow) {
			return visitor.visitNamedWindow(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class WindowSpecContext extends ParserRuleContext {
	public _name!: ErrorCapturingIdentifierContext;
	public _expression!: ExpressionContext;
	public _partition: ExpressionContext[] = [];
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | undefined {
		return this.tryGetRuleContext(0, ErrorCapturingIdentifierContext);
	}
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
	public KW_BY(): TerminalNode[];
	public KW_BY(i: number): TerminalNode;
	public KW_BY(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.KW_BY);
		} else {
			return this.getToken(SparkSqlParser.KW_BY, i);
		}
	}
	public expression(): ExpressionContext[];
	public expression(i: number): ExpressionContext;
	public expression(i?: number): ExpressionContext | ExpressionContext[] {
		if (i === undefined) {
			return this.getRuleContexts(ExpressionContext);
		} else {
			return this.getRuleContext(i, ExpressionContext);
		}
	}
	public windowFrame(): WindowFrameContext | undefined {
		return this.tryGetRuleContext(0, WindowFrameContext);
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	public sortItem(): SortItemContext[];
	public sortItem(i: number): SortItemContext;
	public sortItem(i?: number): SortItemContext | SortItemContext[] {
		if (i === undefined) {
			return this.getRuleContexts(SortItemContext);
		} else {
			return this.getRuleContext(i, SortItemContext);
		}
	}
	public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
	public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
	public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
	public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_windowSpec; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterWindowSpec) {
			listener.enterWindowSpec(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitWindowSpec) {
			listener.exitWindowSpec(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitWindowSpec) {
			return visitor.visitWindowSpec(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class WindowFrameContext extends ParserRuleContext {
	public _frameType!: Token;
	public _start_!: FrameBoundContext;
	public _end!: FrameBoundContext;
	public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RANGE, 0); }
	public frameBound(): FrameBoundContext[];
	public frameBound(i: number): FrameBoundContext;
	public frameBound(i?: number): FrameBoundContext | FrameBoundContext[] {
		if (i === undefined) {
			return this.getRuleContexts(FrameBoundContext);
		} else {
			return this.getRuleContext(i, FrameBoundContext);
		}
	}
	public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
	public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_windowFrame; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterWindowFrame) {
			listener.enterWindowFrame(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitWindowFrame) {
			listener.exitWindowFrame(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitWindowFrame) {
			return visitor.visitWindowFrame(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FrameBoundContext extends ParserRuleContext {
	public _boundType!: Token;
	public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNBOUNDED, 0); }
	public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRECEDING, 0); }
	public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOLLOWING, 0); }
	public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROW, 0); }
	public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_frameBound; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFrameBound) {
			listener.enterFrameBound(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFrameBound) {
			listener.exitFrameBound(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFrameBound) {
			return visitor.visitFrameBound(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QualifiedNameListContext extends ParserRuleContext {
	public qualifiedName(): QualifiedNameContext[];
	public qualifiedName(i: number): QualifiedNameContext;
	public qualifiedName(i?: number): QualifiedNameContext | QualifiedNameContext[] {
		if (i === undefined) {
			return this.getRuleContexts(QualifiedNameContext);
		} else {
			return this.getRuleContext(i, QualifiedNameContext);
		}
	}
	public COMMA(): TerminalNode[];
	public COMMA(i: number): TerminalNode;
	public COMMA(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.COMMA);
		} else {
			return this.getToken(SparkSqlParser.COMMA, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedNameList; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedNameList) {
			listener.enterQualifiedNameList(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedNameList) {
			listener.exitQualifiedNameList(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedNameList) {
			return visitor.visitQualifiedNameList(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionNameContext extends ParserRuleContext {
	public KW_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER, 0); }
	public LEFT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.LEFT_PAREN, 0); }
	public expression(): ExpressionContext | undefined {
		return this.tryGetRuleContext(0, ExpressionContext);
	}
	public RIGHT_PAREN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.RIGHT_PAREN, 0); }
	public qualifiedName(): QualifiedNameContext | undefined {
		return this.tryGetRuleContext(0, QualifiedNameContext);
	}
	public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILTER, 0); }
	public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEFT, 0); }
	public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RIGHT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionName) {
			listener.enterFunctionName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionName) {
			listener.exitFunctionName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionName) {
			return visitor.visitFunctionName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class FunctionNameCreateContext extends ParserRuleContext {
	public qualifiedName(): QualifiedNameContext {
		return this.getRuleContext(0, QualifiedNameContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_functionNameCreate; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterFunctionNameCreate) {
			listener.enterFunctionNameCreate(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitFunctionNameCreate) {
			listener.exitFunctionNameCreate(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitFunctionNameCreate) {
			return visitor.visitFunctionNameCreate(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QualifiedNameContext extends ParserRuleContext {
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	public DOT(): TerminalNode[];
	public DOT(i: number): TerminalNode;
	public DOT(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.DOT);
		} else {
			return this.getToken(SparkSqlParser.DOT, i);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_qualifiedName; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedName) {
			listener.enterQualifiedName(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedName) {
			listener.exitQualifiedName(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedName) {
			return visitor.visitQualifiedName(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ErrorCapturingIdentifierContext extends ParserRuleContext {
	public identifier(): IdentifierContext {
		return this.getRuleContext(0, IdentifierContext);
	}
	public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierExtraContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterErrorCapturingIdentifier) {
			listener.enterErrorCapturingIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitErrorCapturingIdentifier) {
			listener.exitErrorCapturingIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitErrorCapturingIdentifier) {
			return visitor.visitErrorCapturingIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class ErrorCapturingIdentifierExtraContext extends ParserRuleContext {
	public MINUS(): TerminalNode[];
	public MINUS(i: number): TerminalNode;
	public MINUS(i?: number): TerminalNode | TerminalNode[] {
		if (i === undefined) {
			return this.getTokens(SparkSqlParser.MINUS);
		} else {
			return this.getToken(SparkSqlParser.MINUS, i);
		}
	}
	public identifier(): IdentifierContext[];
	public identifier(i: number): IdentifierContext;
	public identifier(i?: number): IdentifierContext | IdentifierContext[] {
		if (i === undefined) {
			return this.getRuleContexts(IdentifierContext);
		} else {
			return this.getRuleContext(i, IdentifierContext);
		}
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_errorCapturingIdentifierExtra; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterErrorCapturingIdentifierExtra) {
			listener.enterErrorCapturingIdentifierExtra(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitErrorCapturingIdentifierExtra) {
			listener.exitErrorCapturingIdentifierExtra(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitErrorCapturingIdentifierExtra) {
			return visitor.visitErrorCapturingIdentifierExtra(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class IdentifierContext extends ParserRuleContext {
	public strictIdentifier(): StrictIdentifierContext | undefined {
		return this.tryGetRuleContext(0, StrictIdentifierContext);
	}
	public strictNonReserved(): StrictNonReservedContext | undefined {
		return this.tryGetRuleContext(0, StrictNonReservedContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_identifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterIdentifier) {
			listener.enterIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitIdentifier) {
			listener.exitIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitIdentifier) {
			return visitor.visitIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StrictIdentifierContext extends ParserRuleContext {
	public IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.IDENTIFIER, 0); }
	public quotedIdentifier(): QuotedIdentifierContext | undefined {
		return this.tryGetRuleContext(0, QuotedIdentifierContext);
	}
	public ansiNonReserved(): AnsiNonReservedContext | undefined {
		return this.tryGetRuleContext(0, AnsiNonReservedContext);
	}
	public nonReserved(): NonReservedContext | undefined {
		return this.tryGetRuleContext(0, NonReservedContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_strictIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterStrictIdentifier) {
			listener.enterStrictIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitStrictIdentifier) {
			listener.exitStrictIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitStrictIdentifier) {
			return visitor.visitStrictIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class QuotedIdentifierContext extends ParserRuleContext {
	public BACKQUOTED_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.BACKQUOTED_IDENTIFIER, 0); }
	public DOUBLEQUOTED_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOUBLEQUOTED_STRING, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_quotedIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQuotedIdentifier) {
			listener.enterQuotedIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQuotedIdentifier) {
			listener.exitQuotedIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQuotedIdentifier) {
			return visitor.visitQuotedIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class BackQuotedIdentifierContext extends ParserRuleContext {
	public BACKQUOTED_IDENTIFIER(): TerminalNode { return this.getToken(SparkSqlParser.BACKQUOTED_IDENTIFIER, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_backQuotedIdentifier; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterBackQuotedIdentifier) {
			listener.enterBackQuotedIdentifier(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitBackQuotedIdentifier) {
			listener.exitBackQuotedIdentifier(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitBackQuotedIdentifier) {
			return visitor.visitBackQuotedIdentifier(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NumberContext extends ParserRuleContext {
	public EXPONENT_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.EXPONENT_VALUE, 0); }
	public MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.MINUS, 0); }
	public DECIMAL_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DECIMAL_VALUE, 0); }
	public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
	public BIGINT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.BIGINT_LITERAL, 0); }
	public SMALLINT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.SMALLINT_LITERAL, 0); }
	public TINYINT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.TINYINT_LITERAL, 0); }
	public DOUBLE_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOUBLE_LITERAL, 0); }
	public FLOAT_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.FLOAT_LITERAL, 0); }
	public BIGDECIMAL_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.BIGDECIMAL_LITERAL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_number; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNumber) {
			listener.enterNumber(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNumber) {
			listener.exitNumber(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNumber) {
			return visitor.visitNumber(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AlterColumnActionContext extends ParserRuleContext {
	public _setOrDrop!: Token;
	public _dropDefault!: Token;
	public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TYPE, 0); }
	public dataType(): DataTypeContext | undefined {
		return this.tryGetRuleContext(0, DataTypeContext);
	}
	public commentSpec(): CommentSpecContext | undefined {
		return this.tryGetRuleContext(0, CommentSpecContext);
	}
	public colPosition(): ColPositionContext | undefined {
		return this.tryGetRuleContext(0, ColPositionContext);
	}
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
	public defaultExpression(): DefaultExpressionContext | undefined {
		return this.tryGetRuleContext(0, DefaultExpressionContext);
	}
	public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_alterColumnAction; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterAlterColumnAction) {
			listener.enterAlterColumnAction(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitAlterColumnAction) {
			listener.exitAlterColumnAction(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitAlterColumnAction) {
			return visitor.visitAlterColumnAction(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StringLitContext extends ParserRuleContext {
	public STRING_LITERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.STRING_LITERAL, 0); }
	public DOUBLEQUOTED_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.DOUBLEQUOTED_STRING, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_stringLit; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterStringLit) {
			listener.enterStringLit(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitStringLit) {
			listener.exitStringLit(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitStringLit) {
			return visitor.visitStringLit(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class CommentContext extends ParserRuleContext {
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_comment; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterComment) {
			listener.enterComment(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitComment) {
			listener.exitComment(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitComment) {
			return visitor.visitComment(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class VersionContext extends ParserRuleContext {
	public INTEGER_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.INTEGER_VALUE, 0); }
	public stringLit(): StringLitContext | undefined {
		return this.tryGetRuleContext(0, StringLitContext);
	}
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_version; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterVersion) {
			listener.enterVersion(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitVersion) {
			listener.exitVersion(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitVersion) {
			return visitor.visitVersion(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class AnsiNonReservedContext extends ParserRuleContext {
	public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ADD, 0); }
	public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AFTER, 0); }
	public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALTER, 0); }
	public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALWAYS, 0); }
	public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANALYZE, 0); }
	public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANTI, 0); }
	public KW_ANY_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY_VALUE, 0); }
	public KW_ARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARCHIVE, 0); }
	public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
	public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
	public KW_AT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AT, 0); }
	public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
	public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BIGINT, 0); }
	public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY, 0); }
	public KW_BINARY_HEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY_HEX, 0); }
	public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOOLEAN, 0); }
	public KW_BUCKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKET, 0); }
	public KW_BUCKETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKETS, 0); }
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public KW_BYTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BYTE, 0); }
	public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CACHE, 0); }
	public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASCADE, 0); }
	public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOG, 0); }
	public KW_CATALOGS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOGS, 0); }
	public KW_CHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHANGE, 0); }
	public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHAR, 0); }
	public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHARACTER, 0); }
	public KW_CLEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLEAR, 0); }
	public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
	public KW_CLUSTERED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTERED, 0); }
	public KW_CODEGEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CODEGEN, 0); }
	public KW_COLLECTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLECTION, 0); }
	public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
	public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMENT, 0); }
	public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMIT, 0); }
	public KW_COMPACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACT, 0); }
	public KW_COMPACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACTIONS, 0); }
	public KW_COMPUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPUTE, 0); }
	public KW_CONCATENATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONCATENATE, 0); }
	public KW_COST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COST, 0); }
	public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
	public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
	public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATA, 0); }
	public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
	public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASES, 0); }
	public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
	public KW_DATEADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEADD, 0); }
	public KW_DATE_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_ADD, 0); }
	public KW_DATEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEDIFF, 0); }
	public KW_DATE_DIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_DIFF, 0); }
	public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
	public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYS, 0); }
	public KW_DAYOFYEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYOFYEAR, 0); }
	public KW_DBPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DBPROPERTIES, 0); }
	public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEC, 0); }
	public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECIMAL, 0); }
	public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECLARE, 0); }
	public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
	public KW_DEFINED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFINED, 0); }
	public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
	public KW_DELIMITED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELIMITED, 0); }
	public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
	public KW_DESCRIBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESCRIBE, 0); }
	public KW_DFS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DFS, 0); }
	public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
	public KW_DIRECTORY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORY, 0); }
	public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
	public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
	public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DOUBLE, 0); }
	public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
	public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPED, 0); }
	public KW_EXCHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCHANGE, 0); }
	public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCLUDE, 0); }
	public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXISTS, 0); }
	public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPLAIN, 0); }
	public KW_EXPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPORT, 0); }
	public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTENDED, 0); }
	public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTERNAL, 0); }
	public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTRACT, 0); }
	public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIELDS, 0); }
	public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILEFORMAT, 0); }
	public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
	public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FLOAT, 0); }
	public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOLLOWING, 0); }
	public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMAT, 0); }
	public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMATTED, 0); }
	public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTION, 0); }
	public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTIONS, 0); }
	public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GENERATED, 0); }
	public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GLOBAL, 0); }
	public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
	public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
	public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOURS, 0); }
	public KW_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER, 0); }
	public KW_IF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IF, 0); }
	public KW_IGNORE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IGNORE, 0); }
	public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IMPORT, 0); }
	public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INCLUDE, 0); }
	public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
	public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEXES, 0); }
	public KW_INPATH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPATH, 0); }
	public KW_INPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPUTFORMAT, 0); }
	public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INSERT, 0); }
	public KW_INT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INT, 0); }
	public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTEGER, 0); }
	public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
	public KW_ITEMS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ITEMS, 0); }
	public KW_KEYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_KEYS, 0); }
	public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
	public KW_LAZY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAZY, 0); }
	public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
	public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ILIKE, 0); }
	public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIMIT, 0); }
	public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LINES, 0); }
	public KW_LIST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIST, 0); }
	public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOAD, 0); }
	public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
	public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCATION, 0); }
	public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCK, 0); }
	public KW_LOCKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCKS, 0); }
	public KW_LOGICAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOGICAL, 0); }
	public KW_LONG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LONG, 0); }
	public KW_MACRO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MACRO, 0); }
	public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
	public KW_MATCHED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MATCHED, 0); }
	public KW_MERGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MERGE, 0); }
	public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
	public KW_MICROSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECONDS, 0); }
	public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
	public KW_MILLISECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECONDS, 0); }
	public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
	public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTES, 0); }
	public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
	public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTHS, 0); }
	public KW_MSCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MSCK, 0); }
	public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAME, 0); }
	public KW_NAMESPACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACE, 0); }
	public KW_NAMESPACES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACES, 0); }
	public KW_NANOSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECOND, 0); }
	public KW_NANOSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECONDS, 0); }
	public KW_NO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NO, 0); }
	public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
	public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NUMERIC, 0); }
	public KW_OF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OF, 0); }
	public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTION, 0); }
	public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
	public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUT, 0); }
	public KW_OUTPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTPUTFORMAT, 0); }
	public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVER, 0); }
	public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAY, 0); }
	public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
	public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
	public KW_PARTITIONED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONED, 0); }
	public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONS, 0); }
	public KW_PERCENTLIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTLIT, 0); }
	public KW_PIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PIVOT, 0); }
	public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PLACING, 0); }
	public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_POSITION, 0); }
	public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRECEDING, 0); }
	public KW_PRINCIPALS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRINCIPALS, 0); }
	public KW_PROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PROPERTIES, 0); }
	public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PURGE, 0); }
	public KW_QUARTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUARTER, 0); }
	public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUERY, 0); }
	public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RANGE, 0); }
	public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REAL, 0); }
	public KW_RECORDREADER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDREADER, 0); }
	public KW_RECORDWRITER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDWRITER, 0); }
	public KW_RECOVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECOVER, 0); }
	public KW_REDUCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REDUCE, 0); }
	public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFRESH, 0); }
	public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RENAME, 0); }
	public KW_REPAIR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPAIR, 0); }
	public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPEATABLE, 0); }
	public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
	public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESET, 0); }
	public KW_RESPECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESPECT, 0); }
	public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESTRICT, 0); }
	public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REVOKE, 0); }
	public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RLIKE, 0); }
	public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REGEXP, 0); }
	public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
	public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLES, 0); }
	public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLBACK, 0); }
	public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
	public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROW, 0); }
	public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
	public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMA, 0); }
	public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMAS, 0); }
	public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
	public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECONDS, 0); }
	public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEMI, 0); }
	public KW_SEPARATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEPARATED, 0); }
	public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
	public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public KW_MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUS, 0); }
	public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
	public KW_SHORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHORT, 0); }
	public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
	public KW_SINGLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SINGLE, 0); }
	public KW_SKEWED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SKEWED, 0); }
	public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SMALLINT, 0); }
	public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
	public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
	public KW_SOURCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOURCE, 0); }
	public KW_START(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_START, 0); }
	public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STATISTICS, 0); }
	public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
	public KW_STRATIFY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRATIFY, 0); }
	public KW_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRING, 0); }
	public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
	public KW_SUBSTR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTR, 0); }
	public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTRING, 0); }
	public KW_SYNC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYNC, 0); }
	public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM, 0); }
	public KW_SYSTEM_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_TIME, 0); }
	public KW_SYSTEM_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_VERSION, 0); }
	public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLES, 0); }
	public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLESAMPLE, 0); }
	public KW_TARGET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TARGET, 0); }
	public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TBLPROPERTIES, 0); }
	public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
	public KW_TERMINATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TERMINATED, 0); }
	public KW_TIMEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMEDIFF, 0); }
	public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
	public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
	public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
	public KW_TIMESTAMPADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPADD, 0); }
	public KW_TIMESTAMPDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0); }
	public KW_TINYINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TINYINT, 0); }
	public KW_TOUCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TOUCH, 0); }
	public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTION, 0); }
	public KW_TRANSACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTIONS, 0); }
	public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSFORM, 0); }
	public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRIM, 0); }
	public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
	public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUNCATE, 0); }
	public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRY_CAST, 0); }
	public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TYPE, 0); }
	public KW_UNARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNARCHIVE, 0); }
	public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNBOUNDED, 0); }
	public KW_UNCACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNCACHE, 0); }
	public KW_UNLOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNLOCK, 0); }
	public KW_UNPIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNPIVOT, 0); }
	public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNSET, 0); }
	public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
	public KW_USE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USE, 0); }
	public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VALUES, 0); }
	public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARCHAR, 0); }
	public KW_VAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VAR, 0); }
	public KW_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARIABLE, 0); }
	public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VERSION, 0); }
	public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEW, 0); }
	public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEWS, 0); }
	public KW_VOID(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VOID, 0); }
	public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
	public KW_WEEKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEKS, 0); }
	public KW_WINDOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WINDOW, 0); }
	public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
	public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEARS, 0); }
	public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ZONE, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_ansiNonReserved; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterAnsiNonReserved) {
			listener.enterAnsiNonReserved(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitAnsiNonReserved) {
			listener.exitAnsiNonReserved(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitAnsiNonReserved) {
			return visitor.visitAnsiNonReserved(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class StrictNonReservedContext extends ParserRuleContext {
	public KW_ANTI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANTI, 0); }
	public KW_CROSS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CROSS, 0); }
	public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCEPT, 0); }
	public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FULL, 0); }
	public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INNER, 0); }
	public KW_INTERSECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERSECT, 0); }
	public KW_JOIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_JOIN, 0); }
	public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LATERAL, 0); }
	public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEFT, 0); }
	public KW_NATURAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NATURAL, 0); }
	public KW_ON(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ON, 0); }
	public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RIGHT, 0); }
	public KW_SEMI(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEMI, 0); }
	public KW_MINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUS, 0); }
	public KW_UNION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNION, 0); }
	public KW_USING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USING, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_strictNonReserved; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterStrictNonReserved) {
			listener.enterStrictNonReserved(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitStrictNonReserved) {
			listener.exitStrictNonReserved(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitStrictNonReserved) {
			return visitor.visitStrictNonReserved(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


export class NonReservedContext extends ParserRuleContext {
	public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ADD, 0); }
	public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AFTER, 0); }
	public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALL, 0); }
	public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALTER, 0); }
	public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ALWAYS, 0); }
	public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANALYZE, 0); }
	public KW_AND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AND, 0); }
	public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY, 0); }
	public KW_ANY_VALUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ANY_VALUE, 0); }
	public KW_ARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARCHIVE, 0); }
	public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ARRAY, 0); }
	public KW_AS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AS, 0); }
	public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ASC, 0); }
	public KW_AT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AT, 0); }
	public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_AUTHORIZATION, 0); }
	public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BETWEEN, 0); }
	public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BIGINT, 0); }
	public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY, 0); }
	public KW_BINARY_HEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BINARY_HEX, 0); }
	public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOOLEAN, 0); }
	public KW_BOTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BOTH, 0); }
	public KW_BUCKET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKET, 0); }
	public KW_BUCKETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BUCKETS, 0); }
	public KW_BY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BY, 0); }
	public KW_BYTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_BYTE, 0); }
	public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CACHE, 0); }
	public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASCADE, 0); }
	public KW_CASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CASE, 0); }
	public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CAST, 0); }
	public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOG, 0); }
	public KW_CATALOGS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CATALOGS, 0); }
	public KW_CHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHANGE, 0); }
	public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHAR, 0); }
	public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHARACTER, 0); }
	public KW_CHECK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CHECK, 0); }
	public KW_CLEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLEAR, 0); }
	public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTER, 0); }
	public KW_CLUSTERED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CLUSTERED, 0); }
	public KW_CODEGEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CODEGEN, 0); }
	public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLATE, 0); }
	public KW_COLLECTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLLECTION, 0); }
	public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMN, 0); }
	public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COLUMNS, 0); }
	public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMENT, 0); }
	public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMMIT, 0); }
	public KW_COMPACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACT, 0); }
	public KW_COMPACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPACTIONS, 0); }
	public KW_COMPUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COMPUTE, 0); }
	public KW_CONCATENATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONCATENATE, 0); }
	public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CONSTRAINT, 0); }
	public KW_COST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_COST, 0); }
	public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CREATE, 0); }
	public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CUBE, 0); }
	public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT, 0); }
	public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_DATE, 0); }
	public KW_CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_TIME, 0); }
	public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_TIMESTAMP, 0); }
	public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_CURRENT_USER, 0); }
	public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATA, 0); }
	public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASE, 0); }
	public KW_DATABASES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATABASES, 0); }
	public KW_DATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE, 0); }
	public KW_DATEADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEADD, 0); }
	public KW_DATE_ADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_ADD, 0); }
	public KW_DATEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATEDIFF, 0); }
	public KW_DATE_DIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DATE_DIFF, 0); }
	public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAY, 0); }
	public KW_DAYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYS, 0); }
	public KW_DAYOFYEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DAYOFYEAR, 0); }
	public KW_DBPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DBPROPERTIES, 0); }
	public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEC, 0); }
	public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECIMAL, 0); }
	public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DECLARE, 0); }
	public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFAULT, 0); }
	public KW_DEFINED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DEFINED, 0); }
	public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELETE, 0); }
	public KW_DELIMITED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DELIMITED, 0); }
	public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESC, 0); }
	public KW_DESCRIBE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DESCRIBE, 0); }
	public KW_DFS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DFS, 0); }
	public KW_DIRECTORIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORIES, 0); }
	public KW_DIRECTORY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIRECTORY, 0); }
	public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTINCT, 0); }
	public KW_DISTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DISTRIBUTE, 0); }
	public KW_DIV(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DIV, 0); }
	public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DOUBLE, 0); }
	public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_DROP, 0); }
	public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ELSE, 0); }
	public KW_END(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_END, 0); }
	public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPE, 0); }
	public KW_ESCAPED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ESCAPED, 0); }
	public KW_EXCHANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCHANGE, 0); }
	public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXCLUDE, 0); }
	public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXISTS, 0); }
	public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPLAIN, 0); }
	public KW_EXPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXPORT, 0); }
	public KW_EXTENDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTENDED, 0); }
	public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTERNAL, 0); }
	public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_EXTRACT, 0); }
	public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FALSE, 0); }
	public KW_FETCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FETCH, 0); }
	public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILTER, 0); }
	public KW_FIELDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIELDS, 0); }
	public KW_FILEFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FILEFORMAT, 0); }
	public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FIRST, 0); }
	public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FLOAT, 0); }
	public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOLLOWING, 0); }
	public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOR, 0); }
	public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FOREIGN, 0); }
	public KW_FORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMAT, 0); }
	public KW_FORMATTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FORMATTED, 0); }
	public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FROM, 0); }
	public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTION, 0); }
	public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_FUNCTIONS, 0); }
	public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GENERATED, 0); }
	public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GLOBAL, 0); }
	public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GRANT, 0); }
	public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUP, 0); }
	public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_GROUPING, 0); }
	public KW_HAVING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HAVING, 0); }
	public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOUR, 0); }
	public KW_HOURS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_HOURS, 0); }
	public KW_IDENTIFIER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER, 0); }
	public KW_IF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IF, 0); }
	public KW_IGNORE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IGNORE, 0); }
	public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IMPORT, 0); }
	public KW_IN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IN, 0); }
	public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INCLUDE, 0); }
	public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEX, 0); }
	public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INDEXES, 0); }
	public KW_INPATH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPATH, 0); }
	public KW_INPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INPUTFORMAT, 0); }
	public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INSERT, 0); }
	public KW_INT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INT, 0); }
	public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTEGER, 0); }
	public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTERVAL, 0); }
	public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_INTO, 0); }
	public KW_IS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IS, 0); }
	public KW_ITEMS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ITEMS, 0); }
	public KW_KEYS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_KEYS, 0); }
	public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAST, 0); }
	public KW_LAZY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LAZY, 0); }
	public KW_LEADING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LEADING, 0); }
	public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIKE, 0); }
	public KW_LONG(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LONG, 0); }
	public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ILIKE, 0); }
	public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIMIT, 0); }
	public KW_LINES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LINES, 0); }
	public KW_LIST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LIST, 0); }
	public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOAD, 0); }
	public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCAL, 0); }
	public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCATION, 0); }
	public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCK, 0); }
	public KW_LOCKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOCKS, 0); }
	public KW_LOGICAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_LOGICAL, 0); }
	public KW_MACRO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MACRO, 0); }
	public KW_MAP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MAP, 0); }
	public KW_MATCHED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MATCHED, 0); }
	public KW_MERGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MERGE, 0); }
	public KW_MICROSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECOND, 0); }
	public KW_MICROSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MICROSECONDS, 0); }
	public KW_MILLISECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECOND, 0); }
	public KW_MILLISECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MILLISECONDS, 0); }
	public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTE, 0); }
	public KW_MINUTES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MINUTES, 0); }
	public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTH, 0); }
	public KW_MONTHS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MONTHS, 0); }
	public KW_MSCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_MSCK, 0); }
	public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAME, 0); }
	public KW_NAMESPACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACE, 0); }
	public KW_NAMESPACES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NAMESPACES, 0); }
	public KW_NANOSECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECOND, 0); }
	public KW_NANOSECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NANOSECONDS, 0); }
	public KW_NO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NO, 0); }
	public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NOT, 0); }
	public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULL, 0); }
	public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NULLS, 0); }
	public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_NUMERIC, 0); }
	public KW_OF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OF, 0); }
	public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OFFSET, 0); }
	public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ONLY, 0); }
	public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTION, 0); }
	public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OPTIONS, 0); }
	public KW_OR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OR, 0); }
	public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ORDER, 0); }
	public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUT, 0); }
	public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTER, 0); }
	public KW_OUTPUTFORMAT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OUTPUTFORMAT, 0); }
	public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVER, 0); }
	public KW_OVERLAPS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAPS, 0); }
	public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERLAY, 0); }
	public KW_OVERWRITE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_OVERWRITE, 0); }
	public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITION, 0); }
	public KW_PARTITIONED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONED, 0); }
	public KW_PARTITIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PARTITIONS, 0); }
	public KW_PERCENTILE_CONT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_CONT, 0); }
	public KW_PERCENTILE_DISC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTILE_DISC, 0); }
	public KW_PERCENTLIT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PERCENTLIT, 0); }
	public KW_PIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PIVOT, 0); }
	public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PLACING, 0); }
	public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_POSITION, 0); }
	public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRECEDING, 0); }
	public KW_PRIMARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRIMARY, 0); }
	public KW_PRINCIPALS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PRINCIPALS, 0); }
	public KW_PROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PROPERTIES, 0); }
	public KW_PURGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_PURGE, 0); }
	public KW_QUARTER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUARTER, 0); }
	public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_QUERY, 0); }
	public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RANGE, 0); }
	public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REAL, 0); }
	public KW_RECORDREADER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDREADER, 0); }
	public KW_RECORDWRITER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECORDWRITER, 0); }
	public KW_RECOVER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RECOVER, 0); }
	public KW_REDUCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REDUCE, 0); }
	public KW_REFERENCES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFERENCES, 0); }
	public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REFRESH, 0); }
	public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RENAME, 0); }
	public KW_REPAIR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPAIR, 0); }
	public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPEATABLE, 0); }
	public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REPLACE, 0); }
	public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESET, 0); }
	public KW_RESPECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESPECT, 0); }
	public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RESTRICT, 0); }
	public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REVOKE, 0); }
	public KW_RLIKE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_RLIKE, 0); }
	public KW_REGEXP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_REGEXP, 0); }
	public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLE, 0); }
	public KW_ROLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLES, 0); }
	public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLBACK, 0); }
	public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROLLUP, 0); }
	public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROW, 0); }
	public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ROWS, 0); }
	public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMA, 0); }
	public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SCHEMAS, 0); }
	public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECOND, 0); }
	public KW_SECONDS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SECONDS, 0); }
	public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SELECT, 0); }
	public KW_SEPARATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SEPARATED, 0); }
	public KW_SERDE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDE, 0); }
	public KW_SERDEPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SERDEPROPERTIES, 0); }
	public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SESSION_USER, 0); }
	public KW_SET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SET, 0); }
	public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETS, 0); }
	public KW_SHORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHORT, 0); }
	public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SHOW, 0); }
	public KW_SINGLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SINGLE, 0); }
	public KW_SKEWED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SKEWED, 0); }
	public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SMALLINT, 0); }
	public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOME, 0); }
	public KW_SORT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORT, 0); }
	public KW_SORTED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SORTED, 0); }
	public KW_SOURCE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SOURCE, 0); }
	public KW_START(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_START, 0); }
	public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STATISTICS, 0); }
	public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STORED, 0); }
	public KW_STRATIFY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRATIFY, 0); }
	public KW_STRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRING, 0); }
	public KW_STRUCT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_STRUCT, 0); }
	public KW_SUBSTR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTR, 0); }
	public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SUBSTRING, 0); }
	public KW_SYNC(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYNC, 0); }
	public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM, 0); }
	public KW_SYSTEM_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_TIME, 0); }
	public KW_SYSTEM_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SYSTEM_VERSION, 0); }
	public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLE, 0); }
	public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLES, 0); }
	public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TABLESAMPLE, 0); }
	public KW_TARGET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TARGET, 0); }
	public KW_TBLPROPERTIES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TBLPROPERTIES, 0); }
	public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TEMPORARY, 0); }
	public KW_TERMINATED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TERMINATED, 0); }
	public KW_THEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_THEN, 0); }
	public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIME, 0); }
	public KW_TIMEDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMEDIFF, 0); }
	public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP, 0); }
	public KW_TIMESTAMP_LTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_LTZ, 0); }
	public KW_TIMESTAMP_NTZ(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMP_NTZ, 0); }
	public KW_TIMESTAMPADD(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPADD, 0); }
	public KW_TIMESTAMPDIFF(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0); }
	public KW_TINYINT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TINYINT, 0); }
	public KW_TO(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TO, 0); }
	public KW_TOUCH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TOUCH, 0); }
	public KW_TRAILING(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRAILING, 0); }
	public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTION, 0); }
	public KW_TRANSACTIONS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSACTIONS, 0); }
	public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRANSFORM, 0); }
	public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRIM, 0); }
	public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUE, 0); }
	public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRUNCATE, 0); }
	public KW_TRY_CAST(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TRY_CAST, 0); }
	public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_TYPE, 0); }
	public KW_UNARCHIVE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNARCHIVE, 0); }
	public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNBOUNDED, 0); }
	public KW_UNCACHE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNCACHE, 0); }
	public KW_UNIQUE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNIQUE, 0); }
	public KW_UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNKNOWN, 0); }
	public KW_UNLOCK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNLOCK, 0); }
	public KW_UNPIVOT(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNPIVOT, 0); }
	public KW_UNSET(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UNSET, 0); }
	public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_UPDATE, 0); }
	public KW_USE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USE, 0); }
	public KW_USER(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_USER, 0); }
	public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VALUES, 0); }
	public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARCHAR, 0); }
	public KW_VAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VAR, 0); }
	public KW_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VARIABLE, 0); }
	public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VERSION, 0); }
	public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEW, 0); }
	public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VIEWS, 0); }
	public KW_VOID(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_VOID, 0); }
	public KW_WEEK(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEK, 0); }
	public KW_WEEKS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WEEKS, 0); }
	public KW_WHEN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WHEN, 0); }
	public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WHERE, 0); }
	public KW_WINDOW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WINDOW, 0); }
	public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITH, 0); }
	public KW_WITHIN(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_WITHIN, 0); }
	public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEAR, 0); }
	public KW_YEARS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_YEARS, 0); }
	public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_ZONE, 0); }
	constructor(parent: ParserRuleContext | undefined, invokingState: number) {
		super(parent, invokingState);
	}
	// @Override
	public get ruleIndex(): number { return SparkSqlParser.RULE_nonReserved; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterNonReserved) {
			listener.enterNonReserved(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitNonReserved) {
			listener.exitNonReserved(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitNonReserved) {
			return visitor.visitNonReserved(this);
		} else {
			return visitor.visitChildren(this);
		}
	}
}


