// Generated from /Users/liuyi/Desktop/Projects/dtstack/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_KW = 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_NOT = 192;
	public static readonly KW_NULL = 193;
	public static readonly KW_NULLS = 194;
	public static readonly KW_NUMERIC = 195;
	public static readonly KW_OF = 196;
	public static readonly KW_OFFSET = 197;
	public static readonly KW_ON = 198;
	public static readonly KW_ONLY = 199;
	public static readonly KW_OPTION = 200;
	public static readonly KW_OPTIONS = 201;
	public static readonly KW_OR = 202;
	public static readonly KW_ORDER = 203;
	public static readonly KW_OUT = 204;
	public static readonly KW_OUTER = 205;
	public static readonly KW_OUTPUTFORMAT = 206;
	public static readonly KW_OVER = 207;
	public static readonly KW_OVERLAPS = 208;
	public static readonly KW_OVERLAY = 209;
	public static readonly KW_OVERWRITE = 210;
	public static readonly KW_PARTITION = 211;
	public static readonly KW_PARTITIONED = 212;
	public static readonly KW_PARTITIONS = 213;
	public static readonly KW_PERCENTILE_CONT = 214;
	public static readonly KW_PERCENTILE_DISC = 215;
	public static readonly KW_PERCENTLIT = 216;
	public static readonly KW_PIVOT = 217;
	public static readonly KW_PLACING = 218;
	public static readonly KW_POSITION = 219;
	public static readonly KW_PRECEDING = 220;
	public static readonly KW_PRIMARY = 221;
	public static readonly KW_PRINCIPALS = 222;
	public static readonly KW_PROPERTIES = 223;
	public static readonly KW_PURGE = 224;
	public static readonly KW_QUARTER = 225;
	public static readonly KW_QUERY = 226;
	public static readonly KW_RANGE = 227;
	public static readonly KW_REAL = 228;
	public static readonly KW_RECORDREADER = 229;
	public static readonly KW_RECORDWRITER = 230;
	public static readonly KW_RECOVER = 231;
	public static readonly KW_REDUCE = 232;
	public static readonly KW_REFERENCES = 233;
	public static readonly KW_REFRESH = 234;
	public static readonly KW_RENAME = 235;
	public static readonly KW_REPAIR = 236;
	public static readonly KW_REPEATABLE = 237;
	public static readonly KW_REPLACE = 238;
	public static readonly KW_RESET = 239;
	public static readonly KW_RESPECT = 240;
	public static readonly KW_RESTRICT = 241;
	public static readonly KW_REVOKE = 242;
	public static readonly KW_RIGHT = 243;
	public static readonly KW_RLIKE = 244;
	public static readonly KW_REGEXP = 245;
	public static readonly KW_ROLE = 246;
	public static readonly KW_ROLES = 247;
	public static readonly KW_ROLLBACK = 248;
	public static readonly KW_ROLLUP = 249;
	public static readonly KW_ROW = 250;
	public static readonly KW_ROWS = 251;
	public static readonly KW_SECOND = 252;
	public static readonly KW_SECONDS = 253;
	public static readonly KW_SCHEMA = 254;
	public static readonly KW_SCHEMAS = 255;
	public static readonly KW_SELECT = 256;
	public static readonly KW_SEMI = 257;
	public static readonly KW_SEPARATED = 258;
	public static readonly KW_SERDE = 259;
	public static readonly KW_SERDEPROPERTIES = 260;
	public static readonly KW_SESSION_USER = 261;
	public static readonly KW_SET = 262;
	public static readonly KW_SETMINUS = 263;
	public static readonly KW_SETS = 264;
	public static readonly KW_SHORT = 265;
	public static readonly KW_SHOW = 266;
	public static readonly KW_SINGLE = 267;
	public static readonly KW_SKEWED = 268;
	public static readonly KW_SMALLINT = 269;
	public static readonly KW_SOME = 270;
	public static readonly KW_SORT = 271;
	public static readonly KW_SORTED = 272;
	public static readonly KW_SOURCE = 273;
	public static readonly KW_START = 274;
	public static readonly KW_STATISTICS = 275;
	public static readonly KW_STORED = 276;
	public static readonly KW_STRATIFY = 277;
	public static readonly KW_STRING = 278;
	public static readonly KW_STRUCT = 279;
	public static readonly KW_SUBSTR = 280;
	public static readonly KW_SUBSTRING = 281;
	public static readonly KW_SYNC = 282;
	public static readonly KW_SYSTEM = 283;
	public static readonly KW_SYSTEM_TIME = 284;
	public static readonly KW_SYSTEM_VERSION = 285;
	public static readonly KW_TABLE = 286;
	public static readonly KW_TABLES = 287;
	public static readonly KW_TABLESAMPLE = 288;
	public static readonly KW_TARGET = 289;
	public static readonly KW_TBLPROPERTIES = 290;
	public static readonly KW_TEMPORARY = 291;
	public static readonly KW_TERMINATED = 292;
	public static readonly KW_THEN = 293;
	public static readonly KW_TIME = 294;
	public static readonly KW_TIMEDIFF = 295;
	public static readonly KW_TIMESTAMP = 296;
	public static readonly KW_TIMESTAMP_LTZ = 297;
	public static readonly KW_TIMESTAMP_NTZ = 298;
	public static readonly KW_TIMESTAMPADD = 299;
	public static readonly KW_TIMESTAMPDIFF = 300;
	public static readonly KW_TINYINT = 301;
	public static readonly KW_TO = 302;
	public static readonly KW_TOUCH = 303;
	public static readonly KW_TRAILING = 304;
	public static readonly KW_TRANSACTION = 305;
	public static readonly KW_TRANSACTIONS = 306;
	public static readonly KW_TRANSFORM = 307;
	public static readonly KW_TRIM = 308;
	public static readonly KW_TRUE = 309;
	public static readonly KW_TRUNCATE = 310;
	public static readonly KW_TRY_CAST = 311;
	public static readonly KW_TYPE = 312;
	public static readonly KW_UNARCHIVE = 313;
	public static readonly KW_UNBOUNDED = 314;
	public static readonly KW_UNCACHE = 315;
	public static readonly KW_UNION = 316;
	public static readonly KW_UNIQUE = 317;
	public static readonly KW_UNKNOWN = 318;
	public static readonly KW_UNLOCK = 319;
	public static readonly KW_UNPIVOT = 320;
	public static readonly KW_UNSET = 321;
	public static readonly KW_UPDATE = 322;
	public static readonly KW_USE = 323;
	public static readonly KW_USER = 324;
	public static readonly KW_USING = 325;
	public static readonly KW_VALUES = 326;
	public static readonly KW_VARCHAR = 327;
	public static readonly KW_VAR = 328;
	public static readonly KW_VARIABLE = 329;
	public static readonly KW_VERSION = 330;
	public static readonly KW_VIEW = 331;
	public static readonly KW_VIEWS = 332;
	public static readonly KW_VOID = 333;
	public static readonly KW_WEEK = 334;
	public static readonly KW_WEEKS = 335;
	public static readonly KW_WHEN = 336;
	public static readonly KW_WHERE = 337;
	public static readonly KW_WINDOW = 338;
	public static readonly KW_WITH = 339;
	public static readonly KW_WITHIN = 340;
	public static readonly KW_YEAR = 341;
	public static readonly KW_YEARS = 342;
	public static readonly KW_ZONE = 343;
	public static readonly EQ = 344;
	public static readonly NSEQ = 345;
	public static readonly NEQ = 346;
	public static readonly NEQJ = 347;
	public static readonly LT = 348;
	public static readonly LTE = 349;
	public static readonly GT = 350;
	public static readonly GTE = 351;
	public static readonly NOT = 352;
	public static readonly PLUS = 353;
	public static readonly MINUS = 354;
	public static readonly ASTERISK = 355;
	public static readonly SLASH = 356;
	public static readonly PERCENT = 357;
	public static readonly TILDE = 358;
	public static readonly AMPERSAND = 359;
	public static readonly PIPE = 360;
	public static readonly CONCAT_PIPE = 361;
	public static readonly HAT = 362;
	public static readonly COLON = 363;
	public static readonly ARROW = 364;
	public static readonly FAT_ARROW = 365;
	public static readonly HENT_START = 366;
	public static readonly HENT_END = 367;
	public static readonly QUESTION = 368;
	public static readonly STRING_LITERAL = 369;
	public static readonly DOUBLEQUOTED_STRING = 370;
	public static readonly BIGINT_LITERAL = 371;
	public static readonly SMALLINT_LITERAL = 372;
	public static readonly TINYINT_LITERAL = 373;
	public static readonly INTEGER_VALUE = 374;
	public static readonly EXPONENT_VALUE = 375;
	public static readonly DECIMAL_VALUE = 376;
	public static readonly FLOAT_LITERAL = 377;
	public static readonly DOUBLE_LITERAL = 378;
	public static readonly BIGDECIMAL_LITERAL = 379;
	public static readonly IDENTIFIER = 380;
	public static readonly BACKQUOTED_IDENTIFIER = 381;
	public static readonly SIMPLE_COMMENT = 382;
	public static readonly BRACKETED_COMMENT = 383;
	public static readonly WS = 384;
	public static readonly UNRECOGNIZED = 385;
	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_identifierReference = 45;
	public static readonly RULE_queryOrganization = 46;
	public static readonly RULE_multiInsertQueryBody = 47;
	public static readonly RULE_queryTerm = 48;
	public static readonly RULE_queryPrimary = 49;
	public static readonly RULE_sortItem = 50;
	public static readonly RULE_fromStatement = 51;
	public static readonly RULE_fromStatementBody = 52;
	public static readonly RULE_querySpecification = 53;
	public static readonly RULE_transformClause = 54;
	public static readonly RULE_selectClause = 55;
	public static readonly RULE_setClause = 56;
	public static readonly RULE_matchedClause = 57;
	public static readonly RULE_notMatchedClause = 58;
	public static readonly RULE_notMatchedBySourceClause = 59;
	public static readonly RULE_matchedAction = 60;
	public static readonly RULE_notMatchedAction = 61;
	public static readonly RULE_notMatchedBySourceAction = 62;
	public static readonly RULE_assignmentList = 63;
	public static readonly RULE_assignment = 64;
	public static readonly RULE_whereClause = 65;
	public static readonly RULE_havingClause = 66;
	public static readonly RULE_hint = 67;
	public static readonly RULE_hintStatement = 68;
	public static readonly RULE_fromClause = 69;
	public static readonly RULE_functionKind = 70;
	public static readonly RULE_temporalClause = 71;
	public static readonly RULE_aggregationClause = 72;
	public static readonly RULE_groupByClause = 73;
	public static readonly RULE_groupingAnalytics = 74;
	public static readonly RULE_groupingElement = 75;
	public static readonly RULE_groupingSet = 76;
	public static readonly RULE_pivotClause = 77;
	public static readonly RULE_pivotColumn = 78;
	public static readonly RULE_pivotValue = 79;
	public static readonly RULE_unpivotClause = 80;
	public static readonly RULE_unpivotNullClause = 81;
	public static readonly RULE_unpivotOperator = 82;
	public static readonly RULE_unpivotSingleValueColumnClause = 83;
	public static readonly RULE_unpivotMultiValueColumnClause = 84;
	public static readonly RULE_unpivotColumnSet = 85;
	public static readonly RULE_unpivotValueColumn = 86;
	public static readonly RULE_unpivotNameColumn = 87;
	public static readonly RULE_unpivotColumnAndAlias = 88;
	public static readonly RULE_unpivotColumn = 89;
	public static readonly RULE_unpivotAlias = 90;
	public static readonly RULE_ifNotExists = 91;
	public static readonly RULE_ifExists = 92;
	public static readonly RULE_lateralView = 93;
	public static readonly RULE_setQuantifier = 94;
	public static readonly RULE_relation = 95;
	public static readonly RULE_relationExtension = 96;
	public static readonly RULE_joinRelation = 97;
	public static readonly RULE_joinType = 98;
	public static readonly RULE_joinCriteria = 99;
	public static readonly RULE_sample = 100;
	public static readonly RULE_sampleMethod = 101;
	public static readonly RULE_identifierList = 102;
	public static readonly RULE_identifierSeq = 103;
	public static readonly RULE_orderedIdentifierList = 104;
	public static readonly RULE_orderedIdentifier = 105;
	public static readonly RULE_identifierCommentList = 106;
	public static readonly RULE_identifierComment = 107;
	public static readonly RULE_relationPrimary = 108;
	public static readonly RULE_inlineTable = 109;
	public static readonly RULE_functionTableSubqueryArgument = 110;
	public static readonly RULE_tableArgumentPartitioning = 111;
	public static readonly RULE_functionTableNamedArgumentExpression = 112;
	public static readonly RULE_functionTableReferenceArgument = 113;
	public static readonly RULE_functionTableArgument = 114;
	public static readonly RULE_functionTable = 115;
	public static readonly RULE_tableAlias = 116;
	public static readonly RULE_rowFormat = 117;
	public static readonly RULE_multipartIdentifierList = 118;
	public static readonly RULE_multipartIdentifier = 119;
	public static readonly RULE_multipartIdentifierPropertyList = 120;
	public static readonly RULE_multipartIdentifierProperty = 121;
	public static readonly RULE_tableIdentifier = 122;
	public static readonly RULE_viewIdentifier = 123;
	public static readonly RULE_namedExpression = 124;
	public static readonly RULE_namedExpressionSeq = 125;
	public static readonly RULE_partitionFieldList = 126;
	public static readonly RULE_partitionField = 127;
	public static readonly RULE_transform = 128;
	public static readonly RULE_transformArgument = 129;
	public static readonly RULE_expression = 130;
	public static readonly RULE_namedArgumentExpression = 131;
	public static readonly RULE_functionArgument = 132;
	public static readonly RULE_expressionSeq = 133;
	public static readonly RULE_booleanExpression = 134;
	public static readonly RULE_predicate = 135;
	public static readonly RULE_valueExpression = 136;
	public static readonly RULE_datetimeUnit = 137;
	public static readonly RULE_primaryExpression = 138;
	public static readonly RULE_literalType = 139;
	public static readonly RULE_constant = 140;
	public static readonly RULE_comparisonOperator = 141;
	public static readonly RULE_arithmeticOperator = 142;
	public static readonly RULE_predicateOperator = 143;
	public static readonly RULE_booleanValue = 144;
	public static readonly RULE_interval = 145;
	public static readonly RULE_errorCapturingMultiUnitsInterval = 146;
	public static readonly RULE_multiUnitsInterval = 147;
	public static readonly RULE_errorCapturingUnitToUnitInterval = 148;
	public static readonly RULE_unitToUnitInterval = 149;
	public static readonly RULE_intervalValue = 150;
	public static readonly RULE_unitInMultiUnits = 151;
	public static readonly RULE_unitInUnitToUnit = 152;
	public static readonly RULE_colPosition = 153;
	public static readonly RULE_type = 154;
	public static readonly RULE_dataType = 155;
	public static readonly RULE_qualifiedColTypeWithPositionList = 156;
	public static readonly RULE_qualifiedColTypeWithPosition = 157;
	public static readonly RULE_colDefinitionDescriptorWithPosition = 158;
	public static readonly RULE_defaultExpression = 159;
	public static readonly RULE_variableDefaultExpression = 160;
	public static readonly RULE_colTypeList = 161;
	public static readonly RULE_colType = 162;
	public static readonly RULE_createOrReplaceTableColTypeList = 163;
	public static readonly RULE_createOrReplaceTableColType = 164;
	public static readonly RULE_colDefinitionOption = 165;
	public static readonly RULE_generationExpression = 166;
	public static readonly RULE_complexColTypeList = 167;
	public static readonly RULE_complexColType = 168;
	public static readonly RULE_whenClause = 169;
	public static readonly RULE_windowClause = 170;
	public static readonly RULE_namedWindow = 171;
	public static readonly RULE_windowSpec = 172;
	public static readonly RULE_windowFrame = 173;
	public static readonly RULE_frameBound = 174;
	public static readonly RULE_qualifiedNameList = 175;
	public static readonly RULE_functionName = 176;
	public static readonly RULE_functionNameCreate = 177;
	public static readonly RULE_qualifiedName = 178;
	public static readonly RULE_errorCapturingIdentifier = 179;
	public static readonly RULE_errorCapturingIdentifierExtra = 180;
	public static readonly RULE_identifier = 181;
	public static readonly RULE_strictIdentifier = 182;
	public static readonly RULE_quotedIdentifier = 183;
	public static readonly RULE_backQuotedIdentifier = 184;
	public static readonly RULE_number = 185;
	public static readonly RULE_alterColumnAction = 186;
	public static readonly RULE_stringLit = 187;
	public static readonly RULE_comment = 188;
	public static readonly RULE_version = 189;
	public static readonly RULE_ansiNonReserved = 190;
	public static readonly RULE_strictNonReserved = 191;
	public static readonly RULE_nonReserved = 192;
	// 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", "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", "qualifiedColTypeWithPositionList", "qualifiedColTypeWithPosition", 
		"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'", "'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", "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_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_SETMINUS", "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);
	}


	  /**
	   * When false, KW_INTERSECT is given the greater precedence over the other set
	   * operations (KW_UNION, KW_EXCEPT and MINUS) as per the SQL standard.
	   */
	  public legacy_setops_precedence_enabled = false;

	  /**
	   * When false, a literal with an exponent would be converted into
	   * double type rather than decimal type.
	   */
	  public legacy_exponent_literal_as_decimal_enabled = false;

	  /**
	   * When true, the behavior of keywords follows ANSI SQL standard.
	   */
	  public SQL_standard_keyword_behavior = false;

	  /**
	   * When true, double quoted literals are identifiers rather than STRINGs.
	   */
	  public double_quoted_identifiers = false;

	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 = 389;
			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 - 232)) & ~0x1F) === 0 && ((1 << (_la - 232)) & ((1 << (SparkSqlParser.KW_REDUCE - 232)) | (1 << (SparkSqlParser.KW_REFRESH - 232)) | (1 << (SparkSqlParser.KW_REPAIR - 232)) | (1 << (SparkSqlParser.KW_REPLACE - 232)) | (1 << (SparkSqlParser.KW_RESET - 232)) | (1 << (SparkSqlParser.KW_REVOKE - 232)) | (1 << (SparkSqlParser.KW_ROLLBACK - 232)) | (1 << (SparkSqlParser.KW_SELECT - 232)) | (1 << (SparkSqlParser.KW_SET - 232)))) !== 0) || ((((_la - 266)) & ~0x1F) === 0 && ((1 << (_la - 266)) & ((1 << (SparkSqlParser.KW_SHOW - 266)) | (1 << (SparkSqlParser.KW_START - 266)) | (1 << (SparkSqlParser.KW_TABLE - 266)))) !== 0) || ((((_la - 310)) & ~0x1F) === 0 && ((1 << (_la - 310)) & ((1 << (SparkSqlParser.KW_TRUNCATE - 310)) | (1 << (SparkSqlParser.KW_UNCACHE - 310)) | (1 << (SparkSqlParser.KW_UNLOCK - 310)) | (1 << (SparkSqlParser.KW_UPDATE - 310)) | (1 << (SparkSqlParser.KW_USE - 310)) | (1 << (SparkSqlParser.KW_VALUES - 310)) | (1 << (SparkSqlParser.KW_WITH - 310)))) !== 0)) {
				{
				{
				this.state = 386;
				this.singleStatement();
				}
				}
				this.state = 391;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 392;
			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 = 394;
			this.statement();
			this.state = 396;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.SEMICOLON) {
				{
				this.state = 395;
				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 = 1237;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 133, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 398;
				this.query();
				}
				break;

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

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

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

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 405;
				this.match(SparkSqlParser.KW_USE);
				this.state = 406;
				this.dbSchema();
				this.state = 407;
				this.dbSchemaName();
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 409;
				this.match(SparkSqlParser.KW_SET);
				this.state = 410;
				this.match(SparkSqlParser.KW_CATALOG);
				this.state = 413;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 3, this._ctx) ) {
				case 1:
					{
					this.state = 411;
					this.identifier();
					}
					break;

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

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 415;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 416;
				this.dbSchema();
				this.state = 418;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 4, this._ctx) ) {
				case 1:
					{
					this.state = 417;
					this.ifNotExists();
					}
					break;
				}
				this.state = 420;
				this.dbSchemaNameCreate();
				this.state = 428;
				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 = 426;
						this._errHandler.sync(this);
						switch (this._input.LA(1)) {
						case SparkSqlParser.KW_COMMENT:
							{
							this.state = 421;
							this.commentSpec();
							}
							break;
						case SparkSqlParser.KW_LOCATION:
							{
							this.state = 422;
							this.locationSpec();
							}
							break;
						case SparkSqlParser.KW_WITH:
							{
							{
							this.state = 423;
							this.match(SparkSqlParser.KW_WITH);
							this.state = 424;
							_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 = 425;
							this.propertyList();
							}
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						}
					}
					this.state = 430;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
				}
				}
				break;

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 431;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 432;
				this.dbSchema();
				this.state = 433;
				this.dbSchemaName();
				this.state = 434;
				this.match(SparkSqlParser.KW_SET);
				this.state = 435;
				_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 = 436;
				this.propertyList();
				}
				break;

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 438;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 439;
				this.dbSchema();
				this.state = 440;
				this.dbSchemaName();
				this.state = 441;
				this.match(SparkSqlParser.KW_SET);
				this.state = 442;
				this.locationSpec();
				}
				break;

			case 9:
				this.enterOuterAlt(_localctx, 9);
				{
				this.state = 444;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 445;
				this.dbSchema();
				this.state = 447;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 7, this._ctx) ) {
				case 1:
					{
					this.state = 446;
					this.ifExists();
					}
					break;
				}
				this.state = 449;
				this.dbSchemaName();
				this.state = 451;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_CASCADE || _la === SparkSqlParser.KW_RESTRICT) {
					{
					this.state = 450;
					_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 = 453;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 454;
				this.dbSchemas();
				this.state = 457;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 9, this._ctx) ) {
				case 1:
					{
					this.state = 455;
					_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 = 456;
					this.multipartIdentifier();
					}
					break;
				}
				this.state = 463;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 11, this._ctx) ) {
				case 1:
					{
					this.state = 460;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 10, this._ctx) ) {
					case 1:
						{
						this.state = 459;
						this.match(SparkSqlParser.KW_LIKE);
						}
						break;
					}
					this.state = 462;
					_localctx._pattern = this.stringLit();
					}
					break;
				}
				}
				break;

			case 11:
				this.enterOuterAlt(_localctx, 11);
				{
				this.state = 465;
				this.createTableHeader();
				this.state = 470;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 12, this._ctx) ) {
				case 1:
					{
					this.state = 466;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 467;
					this.createOrReplaceTableColTypeList();
					this.state = 468;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 473;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 472;
					this.tableProvider();
					}
				}

				this.state = 475;
				this.createTableClauses();
				this.state = 480;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 15, this._ctx) ) {
				case 1:
					{
					this.state = 477;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_AS) {
						{
						this.state = 476;
						this.match(SparkSqlParser.KW_AS);
						}
					}

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

			case 12:
				this.enterOuterAlt(_localctx, 12);
				{
				this.state = 482;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 483;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 485;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) {
				case 1:
					{
					this.state = 484;
					this.ifNotExists();
					}
					break;
				}
				this.state = 487;
				_localctx._target = this.tableNameCreate();
				this.state = 488;
				this.match(SparkSqlParser.KW_LIKE);
				this.state = 489;
				_localctx._source = this.tableName();
				this.state = 498;
				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 = 496;
					this._errHandler.sync(this);
					switch (this._input.LA(1)) {
					case SparkSqlParser.KW_USING:
						{
						this.state = 490;
						this.tableProvider();
						}
						break;
					case SparkSqlParser.KW_ROW:
						{
						this.state = 491;
						this.rowFormat();
						}
						break;
					case SparkSqlParser.KW_STORED:
						{
						this.state = 492;
						this.createFileFormat();
						}
						break;
					case SparkSqlParser.KW_LOCATION:
						{
						this.state = 493;
						this.locationSpec();
						}
						break;
					case SparkSqlParser.KW_TBLPROPERTIES:
						{
						{
						this.state = 494;
						this.match(SparkSqlParser.KW_TBLPROPERTIES);
						this.state = 495;
						_localctx._tableProps = this.propertyList();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					this.state = 500;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;

			case 13:
				this.enterOuterAlt(_localctx, 13);
				{
				this.state = 501;
				this.replaceTableHeader();
				this.state = 506;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 19, this._ctx) ) {
				case 1:
					{
					this.state = 502;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 503;
					this.createOrReplaceTableColTypeList();
					this.state = 504;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 509;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 508;
					this.tableProvider();
					}
				}

				this.state = 511;
				this.createTableClauses();
				this.state = 516;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 22, this._ctx) ) {
				case 1:
					{
					this.state = 513;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_AS) {
						{
						this.state = 512;
						this.match(SparkSqlParser.KW_AS);
						}
					}

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

			case 14:
				this.enterOuterAlt(_localctx, 14);
				{
				this.state = 518;
				this.match(SparkSqlParser.KW_ANALYZE);
				this.state = 519;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 520;
				this.tableName();
				this.state = 522;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 521;
					this.partitionSpec();
					}
				}

				this.state = 524;
				this.match(SparkSqlParser.KW_COMPUTE);
				this.state = 525;
				this.match(SparkSqlParser.KW_STATISTICS);
				this.state = 533;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 24, this._ctx) ) {
				case 1:
					{
					this.state = 526;
					this.identifier();
					}
					break;

				case 2:
					{
					this.state = 527;
					this.match(SparkSqlParser.KW_FOR);
					this.state = 528;
					this.match(SparkSqlParser.KW_COLUMNS);
					this.state = 529;
					this.identifierSeq();
					}
					break;

				case 3:
					{
					this.state = 530;
					this.match(SparkSqlParser.KW_FOR);
					this.state = 531;
					this.match(SparkSqlParser.KW_ALL);
					this.state = 532;
					this.match(SparkSqlParser.KW_COLUMNS);
					}
					break;
				}
				}
				break;

			case 15:
				this.enterOuterAlt(_localctx, 15);
				{
				this.state = 535;
				this.match(SparkSqlParser.KW_ANALYZE);
				this.state = 536;
				this.match(SparkSqlParser.KW_TABLES);
				this.state = 539;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN) {
					{
					this.state = 537;
					_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 = 538;
					this.dbSchemaName();
					}
				}

				this.state = 541;
				this.match(SparkSqlParser.KW_COMPUTE);
				this.state = 542;
				this.match(SparkSqlParser.KW_STATISTICS);
				this.state = 544;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 26, this._ctx) ) {
				case 1:
					{
					this.state = 543;
					this.identifier();
					}
					break;
				}
				}
				break;

			case 16:
				this.enterOuterAlt(_localctx, 16);
				{
				this.state = 546;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 547;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 548;
				this.tableName();
				this.state = 549;
				this.match(SparkSqlParser.KW_ADD);
				this.state = 550;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 551;
				this.qualifiedColTypeWithPositionList();
				}
				break;

			case 17:
				this.enterOuterAlt(_localctx, 17);
				{
				this.state = 553;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 554;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 555;
				this.tableName();
				this.state = 556;
				this.match(SparkSqlParser.KW_ADD);
				this.state = 557;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 558;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 559;
				this.qualifiedColTypeWithPositionList();
				this.state = 560;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 18:
				this.enterOuterAlt(_localctx, 18);
				{
				this.state = 562;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 563;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 564;
				_localctx._table = this.tableName();
				this.state = 565;
				this.match(SparkSqlParser.KW_RENAME);
				this.state = 566;
				this.match(SparkSqlParser.KW_COLUMN);
				this.state = 567;
				this.multipartIdentifier();
				this.state = 568;
				this.match(SparkSqlParser.KW_TO);
				this.state = 569;
				this.errorCapturingIdentifier();
				}
				break;

			case 19:
				this.enterOuterAlt(_localctx, 19);
				{
				this.state = 571;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 572;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 573;
				this.tableName();
				this.state = 574;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 575;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 577;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 576;
					this.ifExists();
					}
				}

				this.state = 579;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 580;
				this.multipartIdentifierList();
				this.state = 581;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 20:
				this.enterOuterAlt(_localctx, 20);
				{
				this.state = 583;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 584;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 585;
				this.tableName();
				this.state = 586;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 587;
				_la = this._input.LA(1);
				if (!(_la === SparkSqlParser.KW_COLUMN || _la === SparkSqlParser.KW_COLUMNS)) {
				this._errHandler.recoverInline(this);
				} else {
					if (this._input.LA(1) === Token.EOF) {
						this.matchedEOF = true;
					}

					this._errHandler.reportMatch(this);
					this.consume();
				}
				this.state = 589;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 28, this._ctx) ) {
				case 1:
					{
					this.state = 588;
					this.ifExists();
					}
					break;
				}
				this.state = 591;
				this.multipartIdentifierList();
				}
				break;

			case 21:
				this.enterOuterAlt(_localctx, 21);
				{
				this.state = 593;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 598;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 594;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 595;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 596;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 597;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 600;
				this.match(SparkSqlParser.KW_RENAME);
				this.state = 601;
				this.match(SparkSqlParser.KW_TO);
				this.state = 602;
				this.multipartIdentifier();
				}
				break;

			case 22:
				this.enterOuterAlt(_localctx, 22);
				{
				this.state = 604;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 609;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 605;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 606;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 607;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 608;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 611;
				this.match(SparkSqlParser.KW_SET);
				this.state = 612;
				this.match(SparkSqlParser.KW_TBLPROPERTIES);
				this.state = 613;
				this.propertyList();
				}
				break;

			case 23:
				this.enterOuterAlt(_localctx, 23);
				{
				this.state = 615;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 620;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 616;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 617;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 618;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 619;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 622;
				this.match(SparkSqlParser.KW_UNSET);
				this.state = 623;
				this.match(SparkSqlParser.KW_TBLPROPERTIES);
				this.state = 625;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 624;
					this.ifExists();
					}
				}

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

			case 24:
				this.enterOuterAlt(_localctx, 24);
				{
				this.state = 629;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 630;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 631;
				_localctx._table = this.tableName();
				this.state = 632;
				_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 = 634;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 33, this._ctx) ) {
				case 1:
					{
					this.state = 633;
					this.match(SparkSqlParser.KW_COLUMN);
					}
					break;
				}
				this.state = 636;
				_localctx._column = this.multipartIdentifier();
				this.state = 638;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 34, this._ctx) ) {
				case 1:
					{
					this.state = 637;
					this.alterColumnAction();
					}
					break;
				}
				}
				break;

			case 25:
				this.enterOuterAlt(_localctx, 25);
				{
				this.state = 640;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 641;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 642;
				_localctx._table = this.tableName();
				this.state = 644;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 643;
					this.partitionSpec();
					}
				}

				this.state = 646;
				this.match(SparkSqlParser.KW_CHANGE);
				this.state = 648;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 36, this._ctx) ) {
				case 1:
					{
					this.state = 647;
					this.match(SparkSqlParser.KW_COLUMN);
					}
					break;
				}
				this.state = 650;
				_localctx._colName = this.multipartIdentifier();
				this.state = 651;
				this.colType();
				this.state = 653;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_AFTER || _la === SparkSqlParser.KW_FIRST) {
					{
					this.state = 652;
					this.colPosition();
					}
				}

				}
				break;

			case 26:
				this.enterOuterAlt(_localctx, 26);
				{
				this.state = 655;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 656;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 657;
				_localctx._table = this.tableName();
				this.state = 659;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 658;
					this.partitionSpec();
					}
				}

				this.state = 661;
				this.match(SparkSqlParser.KW_REPLACE);
				this.state = 662;
				this.match(SparkSqlParser.KW_COLUMNS);
				this.state = 663;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 664;
				this.qualifiedColTypeWithPositionList();
				this.state = 665;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

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

				this.state = 673;
				this.match(SparkSqlParser.KW_SET);
				this.state = 674;
				this.match(SparkSqlParser.KW_SERDE);
				this.state = 675;
				this.stringLit();
				this.state = 679;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 40, this._ctx) ) {
				case 1:
					{
					this.state = 676;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 677;
					this.match(SparkSqlParser.KW_SERDEPROPERTIES);
					this.state = 678;
					this.propertyList();
					}
					break;
				}
				}
				break;

			case 28:
				this.enterOuterAlt(_localctx, 28);
				{
				this.state = 681;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 682;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 683;
				this.tableName();
				this.state = 685;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 684;
					this.partitionSpec();
					}
				}

				this.state = 687;
				this.match(SparkSqlParser.KW_SET);
				this.state = 688;
				this.match(SparkSqlParser.KW_SERDEPROPERTIES);
				this.state = 689;
				this.propertyList();
				}
				break;

			case 29:
				this.enterOuterAlt(_localctx, 29);
				{
				this.state = 691;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 696;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 692;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 693;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 694;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 695;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 698;
				this.match(SparkSqlParser.KW_ADD);
				this.state = 700;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 699;
					this.ifNotExists();
					}
				}

				this.state = 703;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 702;
					this.partitionSpecLocation();
					}
					}
					this.state = 705;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.KW_PARTITION);
				}
				break;

			case 30:
				this.enterOuterAlt(_localctx, 30);
				{
				this.state = 707;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 708;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 709;
				this.tableName();
				this.state = 710;
				this.partitionSpec();
				this.state = 711;
				this.match(SparkSqlParser.KW_RENAME);
				this.state = 712;
				this.match(SparkSqlParser.KW_TO);
				this.state = 713;
				this.partitionSpec();
				}
				break;

			case 31:
				this.enterOuterAlt(_localctx, 31);
				{
				this.state = 715;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 720;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_TABLE:
					{
					this.state = 716;
					this.match(SparkSqlParser.KW_TABLE);
					this.state = 717;
					this.tableName();
					}
					break;
				case SparkSqlParser.KW_VIEW:
					{
					this.state = 718;
					this.match(SparkSqlParser.KW_VIEW);
					this.state = 719;
					this.viewName();
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 722;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 724;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IF) {
					{
					this.state = 723;
					this.ifExists();
					}
				}

				this.state = 726;
				this.partitionSpec();
				this.state = 731;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 727;
					this.match(SparkSqlParser.COMMA);
					this.state = 728;
					this.partitionSpec();
					}
					}
					this.state = 733;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 735;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PURGE) {
					{
					this.state = 734;
					this.match(SparkSqlParser.KW_PURGE);
					}
				}

				}
				break;

			case 32:
				this.enterOuterAlt(_localctx, 32);
				{
				this.state = 737;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 738;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 739;
				this.tableName();
				this.state = 741;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 740;
					this.partitionSpec();
					}
				}

				this.state = 743;
				this.match(SparkSqlParser.KW_SET);
				this.state = 744;
				this.locationSpec();
				}
				break;

			case 33:
				this.enterOuterAlt(_localctx, 33);
				{
				this.state = 746;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 747;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 748;
				this.tableName();
				this.state = 749;
				this.match(SparkSqlParser.KW_RECOVER);
				this.state = 750;
				this.match(SparkSqlParser.KW_PARTITIONS);
				}
				break;

			case 34:
				this.enterOuterAlt(_localctx, 34);
				{
				this.state = 752;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 753;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 755;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 50, this._ctx) ) {
				case 1:
					{
					this.state = 754;
					this.ifExists();
					}
					break;
				}
				this.state = 757;
				this.tableName();
				this.state = 759;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PURGE) {
					{
					this.state = 758;
					this.match(SparkSqlParser.KW_PURGE);
					}
				}

				}
				break;

			case 35:
				this.enterOuterAlt(_localctx, 35);
				{
				this.state = 761;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 762;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 764;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 52, this._ctx) ) {
				case 1:
					{
					this.state = 763;
					this.ifExists();
					}
					break;
				}
				this.state = 766;
				this.viewName();
				}
				break;

			case 36:
				this.enterOuterAlt(_localctx, 36);
				{
				this.state = 767;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 770;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OR) {
					{
					this.state = 768;
					this.match(SparkSqlParser.KW_OR);
					this.state = 769;
					this.match(SparkSqlParser.KW_REPLACE);
					}
				}

				this.state = 776;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_GLOBAL || _la === SparkSqlParser.KW_TEMPORARY) {
					{
					this.state = 773;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_GLOBAL) {
						{
						this.state = 772;
						this.match(SparkSqlParser.KW_GLOBAL);
						}
					}

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

				this.state = 778;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 780;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 56, this._ctx) ) {
				case 1:
					{
					this.state = 779;
					this.ifNotExists();
					}
					break;
				}
				this.state = 782;
				this.viewNameCreate();
				this.state = 784;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.LEFT_PAREN) {
					{
					this.state = 783;
					this.identifierCommentList();
					}
				}

				this.state = 794;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.KW_COMMENT || _la === SparkSqlParser.KW_PARTITIONED || _la === SparkSqlParser.KW_TBLPROPERTIES) {
					{
					this.state = 792;
					this._errHandler.sync(this);
					switch (this._input.LA(1)) {
					case SparkSqlParser.KW_COMMENT:
						{
						this.state = 786;
						this.commentSpec();
						}
						break;
					case SparkSqlParser.KW_PARTITIONED:
						{
						{
						this.state = 787;
						this.match(SparkSqlParser.KW_PARTITIONED);
						this.state = 788;
						this.match(SparkSqlParser.KW_ON);
						this.state = 789;
						this.identifierList();
						}
						}
						break;
					case SparkSqlParser.KW_TBLPROPERTIES:
						{
						{
						this.state = 790;
						this.match(SparkSqlParser.KW_TBLPROPERTIES);
						this.state = 791;
						this.propertyList();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					this.state = 796;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 797;
				this.match(SparkSqlParser.KW_AS);
				this.state = 798;
				this.query();
				}
				break;

			case 37:
				this.enterOuterAlt(_localctx, 37);
				{
				this.state = 800;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 803;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OR) {
					{
					this.state = 801;
					this.match(SparkSqlParser.KW_OR);
					this.state = 802;
					this.match(SparkSqlParser.KW_REPLACE);
					}
				}

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

				this.state = 808;
				this.match(SparkSqlParser.KW_TEMPORARY);
				this.state = 809;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 810;
				this.viewNameCreate();
				this.state = 815;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.LEFT_PAREN) {
					{
					this.state = 811;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 812;
					this.colTypeList();
					this.state = 813;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
				}

				this.state = 817;
				this.tableProvider();
				this.state = 820;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 818;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 819;
					this.propertyList();
					}
				}

				}
				break;

			case 38:
				this.enterOuterAlt(_localctx, 38);
				{
				this.state = 822;
				this.match(SparkSqlParser.KW_ALTER);
				this.state = 823;
				this.match(SparkSqlParser.KW_VIEW);
				this.state = 824;
				this.viewName();
				this.state = 826;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_AS) {
					{
					this.state = 825;
					this.match(SparkSqlParser.KW_AS);
					}
				}

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

			case 39:
				this.enterOuterAlt(_localctx, 39);
				{
				this.state = 830;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 833;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OR) {
					{
					this.state = 831;
					this.match(SparkSqlParser.KW_OR);
					this.state = 832;
					this.match(SparkSqlParser.KW_REPLACE);
					}
				}

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

				this.state = 838;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 840;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 67, this._ctx) ) {
				case 1:
					{
					this.state = 839;
					this.ifNotExists();
					}
					break;
				}
				this.state = 842;
				this.functionNameCreate();
				this.state = 843;
				this.match(SparkSqlParser.KW_AS);
				this.state = 844;
				_localctx._className = this.stringLit();
				this.state = 854;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 845;
					this.match(SparkSqlParser.KW_USING);
					this.state = 846;
					this.resource();
					this.state = 851;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 847;
						this.match(SparkSqlParser.COMMA);
						this.state = 848;
						this.resource();
						}
						}
						this.state = 853;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
				}

				}
				break;

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

				this.state = 860;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 862;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 71, this._ctx) ) {
				case 1:
					{
					this.state = 861;
					this.ifExists();
					}
					break;
				}
				this.state = 864;
				this.functionName();
				}
				break;

			case 41:
				this.enterOuterAlt(_localctx, 41);
				{
				this.state = 865;
				this.match(SparkSqlParser.KW_DECLARE);
				this.state = 868;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 72, this._ctx) ) {
				case 1:
					{
					this.state = 866;
					this.match(SparkSqlParser.KW_OR);
					this.state = 867;
					this.match(SparkSqlParser.KW_REPLACE);
					}
					break;
				}
				this.state = 871;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 73, this._ctx) ) {
				case 1:
					{
					this.state = 870;
					this.match(SparkSqlParser.KW_VARIABLE);
					}
					break;
				}
				this.state = 873;
				this.functionName();
				this.state = 875;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 74, this._ctx) ) {
				case 1:
					{
					this.state = 874;
					this.dataType();
					}
					break;
				}
				this.state = 878;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DEFAULT || _la === SparkSqlParser.EQ) {
					{
					this.state = 877;
					this.variableDefaultExpression();
					}
				}

				}
				break;

			case 42:
				this.enterOuterAlt(_localctx, 42);
				{
				this.state = 880;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 881;
				this.match(SparkSqlParser.KW_TEMPORARY);
				this.state = 882;
				this.match(SparkSqlParser.KW_VARIABLE);
				this.state = 884;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 76, this._ctx) ) {
				case 1:
					{
					this.state = 883;
					this.ifExists();
					}
					break;
				}
				this.state = 889;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 77, this._ctx) ) {
				case 1:
					{
					this.state = 886;
					this.tableName();
					}
					break;

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

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

			case 43:
				this.enterOuterAlt(_localctx, 43);
				{
				this.state = 891;
				this.match(SparkSqlParser.KW_EXPLAIN);
				this.state = 893;
				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 = 892;
					_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 = 895;
				this.statement();
				}
				break;

			case 44:
				this.enterOuterAlt(_localctx, 44);
				{
				this.state = 896;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 897;
				this.match(SparkSqlParser.KW_TABLES);
				this.state = 900;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 79, this._ctx) ) {
				case 1:
					{
					this.state = 898;
					_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 = 899;
					this.dbSchemaName();
					}
					break;
				}
				this.state = 906;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 81, this._ctx) ) {
				case 1:
					{
					this.state = 903;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 80, this._ctx) ) {
					case 1:
						{
						this.state = 902;
						this.match(SparkSqlParser.KW_LIKE);
						}
						break;
					}
					this.state = 905;
					_localctx._pattern = this.stringLit();
					}
					break;
				}
				}
				break;

			case 45:
				this.enterOuterAlt(_localctx, 45);
				{
				this.state = 908;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 909;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 910;
				this.match(SparkSqlParser.KW_EXTENDED);
				this.state = 913;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FROM || _la === SparkSqlParser.KW_IN) {
					{
					this.state = 911;
					_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 = 912;
					_localctx._ns = this.dbSchemaName();
					}
				}

				this.state = 915;
				this.match(SparkSqlParser.KW_LIKE);
				this.state = 916;
				_localctx._pattern = this.stringLit();
				this.state = 918;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 917;
					this.partitionSpec();
					}
				}

				}
				break;

			case 46:
				this.enterOuterAlt(_localctx, 46);
				{
				this.state = 920;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 921;
				this.match(SparkSqlParser.KW_TBLPROPERTIES);
				this.state = 922;
				_localctx._table = this.tableName();
				this.state = 927;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 84, this._ctx) ) {
				case 1:
					{
					this.state = 923;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 924;
					_localctx._key = this.propertyKey();
					this.state = 925;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				}
				break;

			case 47:
				this.enterOuterAlt(_localctx, 47);
				{
				this.state = 929;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 930;
				this.match(SparkSqlParser.KW_COLUMNS);
				this.state = 931;
				_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 = 932;
				_localctx._table = this.tableName();
				this.state = 935;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 85, this._ctx) ) {
				case 1:
					{
					this.state = 933;
					_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 = 934;
					this.multipartIdentifier();
					}
					break;
				}
				}
				break;

			case 48:
				this.enterOuterAlt(_localctx, 48);
				{
				this.state = 937;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 938;
				this.match(SparkSqlParser.KW_VIEWS);
				this.state = 941;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 86, this._ctx) ) {
				case 1:
					{
					this.state = 939;
					_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 = 940;
					this.dbSchemaName();
					}
					break;
				}
				this.state = 947;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 88, this._ctx) ) {
				case 1:
					{
					this.state = 944;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 87, this._ctx) ) {
					case 1:
						{
						this.state = 943;
						this.match(SparkSqlParser.KW_LIKE);
						}
						break;
					}
					this.state = 946;
					_localctx._pattern = this.stringLit();
					}
					break;
				}
				}
				break;

			case 49:
				this.enterOuterAlt(_localctx, 49);
				{
				this.state = 949;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 950;
				this.match(SparkSqlParser.KW_PARTITIONS);
				this.state = 951;
				this.tableName();
				this.state = 953;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 952;
					this.partitionSpec();
					}
				}

				}
				break;

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

				this.state = 959;
				this.match(SparkSqlParser.KW_FUNCTIONS);
				this.state = 962;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 91, this._ctx) ) {
				case 1:
					{
					this.state = 960;
					_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 = 961;
					_localctx._ns = this.dbSchemaName();
					}
					break;
				}
				this.state = 971;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 94, this._ctx) ) {
				case 1:
					{
					this.state = 965;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 92, this._ctx) ) {
					case 1:
						{
						this.state = 964;
						this.match(SparkSqlParser.KW_LIKE);
						}
						break;
					}
					this.state = 969;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 93, this._ctx) ) {
					case 1:
						{
						this.state = 967;
						_localctx._legacy = this.multipartIdentifier();
						}
						break;

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

			case 51:
				this.enterOuterAlt(_localctx, 51);
				{
				this.state = 973;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 974;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 975;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 976;
				this.tableName();
				this.state = 979;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_AS) {
					{
					this.state = 977;
					this.match(SparkSqlParser.KW_AS);
					this.state = 978;
					this.match(SparkSqlParser.KW_SERDE);
					}
				}

				}
				break;

			case 52:
				this.enterOuterAlt(_localctx, 52);
				{
				this.state = 981;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 982;
				this.match(SparkSqlParser.KW_CURRENT);
				this.state = 983;
				this.dbSchema();
				}
				break;

			case 53:
				this.enterOuterAlt(_localctx, 53);
				{
				this.state = 984;
				this.match(SparkSqlParser.KW_SHOW);
				this.state = 985;
				this.match(SparkSqlParser.KW_CATALOGS);
				this.state = 990;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 97, this._ctx) ) {
				case 1:
					{
					this.state = 987;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 96, this._ctx) ) {
					case 1:
						{
						this.state = 986;
						this.match(SparkSqlParser.KW_LIKE);
						}
						break;
					}
					this.state = 989;
					_localctx._pattern = this.stringLit();
					}
					break;
				}
				}
				break;

			case 54:
				this.enterOuterAlt(_localctx, 54);
				{
				this.state = 992;
				_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 = 993;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 995;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 98, this._ctx) ) {
				case 1:
					{
					this.state = 994;
					this.match(SparkSqlParser.KW_EXTENDED);
					}
					break;
				}
				this.state = 997;
				this.describeFuncName();
				}
				break;

			case 55:
				this.enterOuterAlt(_localctx, 55);
				{
				this.state = 998;
				_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 = 999;
				this.match(SparkSqlParser.KW_DATABASE);
				this.state = 1001;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 99, this._ctx) ) {
				case 1:
					{
					this.state = 1000;
					this.match(SparkSqlParser.KW_EXTENDED);
					}
					break;
				}
				this.state = 1003;
				this.dbSchemaName();
				}
				break;

			case 56:
				this.enterOuterAlt(_localctx, 56);
				{
				this.state = 1004;
				_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 = 1006;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 100, this._ctx) ) {
				case 1:
					{
					this.state = 1005;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1009;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 101, this._ctx) ) {
				case 1:
					{
					this.state = 1008;
					_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 = 1011;
				this.tableName();
				this.state = 1013;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 102, this._ctx) ) {
				case 1:
					{
					this.state = 1012;
					this.partitionSpec();
					}
					break;
				}
				this.state = 1016;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 103, this._ctx) ) {
				case 1:
					{
					this.state = 1015;
					this.describeColName();
					}
					break;
				}
				}
				break;

			case 57:
				this.enterOuterAlt(_localctx, 57);
				{
				this.state = 1018;
				_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 = 1020;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_QUERY) {
					{
					this.state = 1019;
					this.match(SparkSqlParser.KW_QUERY);
					}
				}

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

			case 58:
				this.enterOuterAlt(_localctx, 58);
				{
				this.state = 1023;
				this.match(SparkSqlParser.KW_COMMENT);
				this.state = 1024;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1025;
				this.dbSchema();
				this.state = 1026;
				this.dbSchemaName();
				this.state = 1027;
				this.match(SparkSqlParser.KW_IS);
				this.state = 1028;
				this.comment();
				}
				break;

			case 59:
				this.enterOuterAlt(_localctx, 59);
				{
				this.state = 1030;
				this.match(SparkSqlParser.KW_COMMENT);
				this.state = 1031;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1032;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1033;
				this.tableName();
				this.state = 1034;
				this.match(SparkSqlParser.KW_IS);
				this.state = 1035;
				this.comment();
				}
				break;

			case 60:
				this.enterOuterAlt(_localctx, 60);
				{
				this.state = 1037;
				this.match(SparkSqlParser.KW_REFRESH);
				this.state = 1038;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1039;
				this.tableName();
				}
				break;

			case 61:
				this.enterOuterAlt(_localctx, 61);
				{
				this.state = 1040;
				this.match(SparkSqlParser.KW_REFRESH);
				this.state = 1041;
				this.match(SparkSqlParser.KW_FUNCTION);
				this.state = 1042;
				this.functionName();
				}
				break;

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

				case 2:
					{
					this.state = 1048;
					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 = 1045;
							this.matchWildcard();
							}
							}
						}
						this.state = 1050;
						this._errHandler.sync(this);
						_alt = this.interpreter.adaptivePredict(this._input, 105, this._ctx);
					}
					}
					break;
				}
				}
				break;

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

				this.state = 1057;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1058;
				this.tableName();
				this.state = 1061;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 1059;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 1060;
					_localctx._options = this.propertyList();
					}
				}

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

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

			case 64:
				this.enterOuterAlt(_localctx, 64);
				{
				this.state = 1069;
				this.match(SparkSqlParser.KW_UNCACHE);
				this.state = 1070;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1072;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 111, this._ctx) ) {
				case 1:
					{
					this.state = 1071;
					this.ifExists();
					}
					break;
				}
				this.state = 1074;
				this.tableName();
				}
				break;

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

			case 66:
				this.enterOuterAlt(_localctx, 66);
				{
				this.state = 1077;
				this.match(SparkSqlParser.KW_LOAD);
				this.state = 1078;
				this.match(SparkSqlParser.KW_DATA);
				this.state = 1080;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LOCAL) {
					{
					this.state = 1079;
					this.match(SparkSqlParser.KW_LOCAL);
					}
				}

				this.state = 1082;
				this.match(SparkSqlParser.KW_INPATH);
				this.state = 1083;
				_localctx._path = this.stringLit();
				this.state = 1085;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OVERWRITE) {
					{
					this.state = 1084;
					this.match(SparkSqlParser.KW_OVERWRITE);
					}
				}

				this.state = 1087;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1088;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1089;
				this.tableName();
				this.state = 1091;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1090;
					this.partitionSpec();
					}
				}

				}
				break;

			case 67:
				this.enterOuterAlt(_localctx, 67);
				{
				this.state = 1093;
				this.match(SparkSqlParser.KW_TRUNCATE);
				this.state = 1094;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1095;
				this.tableName();
				this.state = 1097;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1096;
					this.partitionSpec();
					}
				}

				}
				break;

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

				this.state = 1102;
				this.match(SparkSqlParser.KW_REPAIR);
				this.state = 1103;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1104;
				this.tableName();
				this.state = 1107;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 117, this._ctx) ) {
				case 1:
					{
					this.state = 1105;
					_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 = 1106;
					this.match(SparkSqlParser.KW_PARTITIONS);
					}
					break;
				}
				}
				break;

			case 69:
				this.enterOuterAlt(_localctx, 69);
				{
				this.state = 1109;
				_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 = 1110;
				this.identifier();
				this.state = 1114;
				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 = 1111;
						this.matchWildcard();
						}
						}
					}
					this.state = 1116;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 118, this._ctx);
				}
				}
				break;

			case 70:
				this.enterOuterAlt(_localctx, 70);
				{
				this.state = 1117;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1118;
				this.match(SparkSqlParser.KW_ROLE);
				this.state = 1122;
				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 = 1119;
						this.matchWildcard();
						}
						}
					}
					this.state = 1124;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 119, this._ctx);
				}
				}
				break;

			case 71:
				this.enterOuterAlt(_localctx, 71);
				{
				this.state = 1125;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1126;
				this.match(SparkSqlParser.KW_TIME);
				this.state = 1127;
				this.match(SparkSqlParser.KW_ZONE);
				this.state = 1128;
				this.interval();
				}
				break;

			case 72:
				this.enterOuterAlt(_localctx, 72);
				{
				this.state = 1129;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1130;
				this.match(SparkSqlParser.KW_TIME);
				this.state = 1131;
				this.match(SparkSqlParser.KW_ZONE);
				this.state = 1132;
				this.timezone();
				}
				break;

			case 73:
				this.enterOuterAlt(_localctx, 73);
				{
				this.state = 1133;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1134;
				this.match(SparkSqlParser.KW_TIME);
				this.state = 1135;
				this.match(SparkSqlParser.KW_ZONE);
				this.state = 1139;
				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 = 1136;
						this.matchWildcard();
						}
						}
					}
					this.state = 1141;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 120, this._ctx);
				}
				}
				break;

			case 74:
				this.enterOuterAlt(_localctx, 74);
				{
				this.state = 1142;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1143;
				_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 = 1144;
				this.assignmentList();
				}
				break;

			case 75:
				this.enterOuterAlt(_localctx, 75);
				{
				this.state = 1145;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1146;
				_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 = 1147;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1148;
				this.multipartIdentifierList();
				this.state = 1149;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 1150;
				this.match(SparkSqlParser.EQ);
				this.state = 1151;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1152;
				this.query();
				this.state = 1153;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 76:
				this.enterOuterAlt(_localctx, 76);
				{
				this.state = 1155;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1156;
				this.configKey();
				this.state = 1157;
				this.match(SparkSqlParser.EQ);
				this.state = 1158;
				this.configValue();
				}
				break;

			case 77:
				this.enterOuterAlt(_localctx, 77);
				{
				this.state = 1160;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1161;
				this.configKey();
				this.state = 1169;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.EQ) {
					{
					this.state = 1162;
					this.match(SparkSqlParser.EQ);
					this.state = 1166;
					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 = 1163;
							this.matchWildcard();
							}
							}
						}
						this.state = 1168;
						this._errHandler.sync(this);
						_alt = this.interpreter.adaptivePredict(this._input, 121, this._ctx);
					}
					}
				}

				}
				break;

			case 78:
				this.enterOuterAlt(_localctx, 78);
				{
				this.state = 1171;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1175;
				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 = 1172;
						this.matchWildcard();
						}
						}
					}
					this.state = 1177;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 123, this._ctx);
				}
				this.state = 1178;
				this.match(SparkSqlParser.EQ);
				this.state = 1179;
				this.configValue();
				}
				break;

			case 79:
				this.enterOuterAlt(_localctx, 79);
				{
				this.state = 1180;
				this.match(SparkSqlParser.KW_SET);
				this.state = 1184;
				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 = 1181;
						this.matchWildcard();
						}
						}
					}
					this.state = 1186;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 124, this._ctx);
				}
				}
				break;

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

			case 81:
				this.enterOuterAlt(_localctx, 81);
				{
				this.state = 1189;
				this.match(SparkSqlParser.KW_RESET);
				this.state = 1193;
				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 = 1190;
						this.matchWildcard();
						}
						}
					}
					this.state = 1195;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 125, this._ctx);
				}
				}
				break;

			case 82:
				this.enterOuterAlt(_localctx, 82);
				{
				this.state = 1196;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 1197;
				this.match(SparkSqlParser.KW_INDEX);
				this.state = 1199;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 126, this._ctx) ) {
				case 1:
					{
					this.state = 1198;
					this.ifNotExists();
					}
					break;
				}
				this.state = 1201;
				this.identifier();
				this.state = 1202;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1204;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 127, this._ctx) ) {
				case 1:
					{
					this.state = 1203;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1206;
				this.tableName();
				this.state = 1209;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_USING) {
					{
					this.state = 1207;
					this.match(SparkSqlParser.KW_USING);
					this.state = 1208;
					_localctx._indexType = this.identifier();
					}
				}

				this.state = 1211;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1212;
				this.multipartIdentifierPropertyList();
				this.state = 1213;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 1216;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 1214;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 1215;
					_localctx._options = this.propertyList();
					}
				}

				}
				break;

			case 83:
				this.enterOuterAlt(_localctx, 83);
				{
				this.state = 1218;
				this.match(SparkSqlParser.KW_DROP);
				this.state = 1219;
				this.match(SparkSqlParser.KW_INDEX);
				this.state = 1221;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 130, this._ctx) ) {
				case 1:
					{
					this.state = 1220;
					this.ifExists();
					}
					break;
				}
				this.state = 1223;
				this.identifier();
				this.state = 1224;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1226;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 131, this._ctx) ) {
				case 1:
					{
					this.state = 1225;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1228;
				this.tableName();
				}
				break;

			case 84:
				this.enterOuterAlt(_localctx, 84);
				{
				this.state = 1230;
				this.unsupportedHiveNativeCommands();
				this.state = 1234;
				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 = 1231;
						this.matchWildcard();
						}
						}
					}
					this.state = 1236;
					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 = 1241;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 134, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1239;
				this.stringLit();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1240;
				this.match(SparkSqlParser.KW_LOCAL);
				}
				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 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 = 1243;
			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 = 1245;
			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 = 1415;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 142, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1247;
				_localctx._kw1 = this.match(SparkSqlParser.KW_CREATE);
				this.state = 1248;
				_localctx._kw2 = this.match(SparkSqlParser.KW_ROLE);
				}
				break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case 26:
				this.enterOuterAlt(_localctx, 26);
				{
				this.state = 1308;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1309;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1310;
				this.tableName();
				this.state = 1311;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1312;
				_localctx._kw4 = this.match(SparkSqlParser.KW_CLUSTERED);
				}
				break;

			case 27:
				this.enterOuterAlt(_localctx, 27);
				{
				this.state = 1314;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1315;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1316;
				this.tableName();
				this.state = 1317;
				_localctx._kw3 = this.match(SparkSqlParser.KW_CLUSTERED);
				this.state = 1318;
				_localctx._kw4 = this.match(SparkSqlParser.KW_BY);
				}
				break;

			case 28:
				this.enterOuterAlt(_localctx, 28);
				{
				this.state = 1320;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1321;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1322;
				this.tableName();
				this.state = 1323;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1324;
				_localctx._kw4 = this.match(SparkSqlParser.KW_SORTED);
				}
				break;

			case 29:
				this.enterOuterAlt(_localctx, 29);
				{
				this.state = 1326;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1327;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1328;
				this.tableName();
				this.state = 1329;
				_localctx._kw3 = this.match(SparkSqlParser.KW_SKEWED);
				this.state = 1330;
				_localctx._kw4 = this.match(SparkSqlParser.KW_BY);
				}
				break;

			case 30:
				this.enterOuterAlt(_localctx, 30);
				{
				this.state = 1332;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1333;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1334;
				this.tableName();
				this.state = 1335;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1336;
				_localctx._kw4 = this.match(SparkSqlParser.KW_SKEWED);
				}
				break;

			case 31:
				this.enterOuterAlt(_localctx, 31);
				{
				this.state = 1338;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1339;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1340;
				this.tableName();
				this.state = 1341;
				_localctx._kw3 = this.match(SparkSqlParser.KW_NOT);
				this.state = 1342;
				_localctx._kw4 = this.match(SparkSqlParser.KW_STORED);
				this.state = 1343;
				_localctx._kw5 = this.match(SparkSqlParser.KW_AS);
				this.state = 1344;
				_localctx._kw6 = this.match(SparkSqlParser.KW_DIRECTORIES);
				}
				break;

			case 32:
				this.enterOuterAlt(_localctx, 32);
				{
				this.state = 1346;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1347;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1348;
				this.tableName();
				this.state = 1349;
				_localctx._kw3 = this.match(SparkSqlParser.KW_SET);
				this.state = 1350;
				_localctx._kw4 = this.match(SparkSqlParser.KW_SKEWED);
				this.state = 1351;
				_localctx._kw5 = this.match(SparkSqlParser.KW_LOCATION);
				}
				break;

			case 33:
				this.enterOuterAlt(_localctx, 33);
				{
				this.state = 1353;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1354;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1355;
				this.tableName();
				this.state = 1356;
				_localctx._kw3 = this.match(SparkSqlParser.KW_EXCHANGE);
				this.state = 1357;
				_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
				}
				break;

			case 34:
				this.enterOuterAlt(_localctx, 34);
				{
				this.state = 1359;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1360;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1361;
				this.tableName();
				this.state = 1362;
				_localctx._kw3 = this.match(SparkSqlParser.KW_ARCHIVE);
				this.state = 1363;
				_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
				}
				break;

			case 35:
				this.enterOuterAlt(_localctx, 35);
				{
				this.state = 1365;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1366;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1367;
				this.tableName();
				this.state = 1368;
				_localctx._kw3 = this.match(SparkSqlParser.KW_UNARCHIVE);
				this.state = 1369;
				_localctx._kw4 = this.match(SparkSqlParser.KW_PARTITION);
				}
				break;

			case 36:
				this.enterOuterAlt(_localctx, 36);
				{
				this.state = 1371;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1372;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1373;
				this.tableName();
				this.state = 1374;
				_localctx._kw3 = this.match(SparkSqlParser.KW_TOUCH);
				}
				break;

			case 37:
				this.enterOuterAlt(_localctx, 37);
				{
				this.state = 1376;
				_localctx._kw1 = this.match(SparkSqlParser.KW_ALTER);
				this.state = 1377;
				_localctx._kw2 = this.match(SparkSqlParser.KW_TABLE);
				this.state = 1378;
				this.tableName();
				this.state = 1380;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1379;
					this.partitionSpec();
					}
				}

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

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

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

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

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

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

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

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

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

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

			case 44:
				this.enterOuterAlt(_localctx, 44);
				{
				this.state = 1414;
				_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 = 1417;
			this.match(SparkSqlParser.KW_CREATE);
			this.state = 1419;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_TEMPORARY) {
				{
				this.state = 1418;
				this.match(SparkSqlParser.KW_TEMPORARY);
				}
			}

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

			this.state = 1424;
			this.match(SparkSqlParser.KW_TABLE);
			this.state = 1426;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 145, this._ctx) ) {
			case 1:
				{
				this.state = 1425;
				this.ifNotExists();
				}
				break;
			}
			this.state = 1428;
			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 = 1432;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_CREATE) {
				{
				this.state = 1430;
				this.match(SparkSqlParser.KW_CREATE);
				this.state = 1431;
				this.match(SparkSqlParser.KW_OR);
				}
			}

			this.state = 1434;
			this.match(SparkSqlParser.KW_REPLACE);
			this.state = 1435;
			this.match(SparkSqlParser.KW_TABLE);
			this.state = 1436;
			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 = 1438;
			this.match(SparkSqlParser.KW_CLUSTERED);
			this.state = 1439;
			this.match(SparkSqlParser.KW_BY);
			this.state = 1440;
			this.identifierList();
			this.state = 1444;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_SORTED) {
				{
				this.state = 1441;
				this.match(SparkSqlParser.KW_SORTED);
				this.state = 1442;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1443;
				this.orderedIdentifierList();
				}
			}

			this.state = 1446;
			this.match(SparkSqlParser.KW_INTO);
			this.state = 1447;
			this.match(SparkSqlParser.INTEGER_VALUE);
			this.state = 1448;
			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 = 1450;
			this.match(SparkSqlParser.KW_SKEWED);
			this.state = 1451;
			this.match(SparkSqlParser.KW_BY);
			this.state = 1452;
			this.identifierList();
			this.state = 1453;
			this.match(SparkSqlParser.KW_ON);
			this.state = 1456;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 148, this._ctx) ) {
			case 1:
				{
				this.state = 1454;
				this.constantList();
				}
				break;

			case 2:
				{
				this.state = 1455;
				this.nestedConstantList();
				}
				break;
			}
			this.state = 1461;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 149, this._ctx) ) {
			case 1:
				{
				this.state = 1458;
				this.match(SparkSqlParser.KW_STORED);
				this.state = 1459;
				this.match(SparkSqlParser.KW_AS);
				this.state = 1460;
				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 = 1463;
			this.match(SparkSqlParser.KW_LOCATION);
			this.state = 1464;
			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 = 1466;
			this.match(SparkSqlParser.KW_COMMENT);
			this.state = 1467;
			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 = 1470;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_WITH) {
				{
				this.state = 1469;
				this.ctes();
				}
			}

			this.state = 1472;
			this.queryTerm(0);
			this.state = 1473;
			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 = 1545;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 166, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1475;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1476;
				this.match(SparkSqlParser.KW_OVERWRITE);
				this.state = 1478;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 151, this._ctx) ) {
				case 1:
					{
					this.state = 1477;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1480;
				this.tableName();
				this.state = 1485;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1481;
					this.partitionSpec();
					this.state = 1483;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_IF) {
						{
						this.state = 1482;
						this.ifNotExists();
						}
					}

					}
				}

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

				case 2:
					{
					this.state = 1489;
					this.identifierList();
					}
					break;
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1492;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1493;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1495;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 155, this._ctx) ) {
				case 1:
					{
					this.state = 1494;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1497;
				this.tableName();
				this.state = 1499;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_PARTITION) {
					{
					this.state = 1498;
					this.partitionSpec();
					}
				}

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

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

				case 2:
					{
					this.state = 1506;
					this.identifierList();
					}
					break;
				}
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1509;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1510;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1512;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 159, this._ctx) ) {
				case 1:
					{
					this.state = 1511;
					this.match(SparkSqlParser.KW_TABLE);
					}
					break;
				}
				this.state = 1514;
				this.tableName();
				this.state = 1515;
				this.match(SparkSqlParser.KW_REPLACE);
				this.state = 1516;
				this.whereClause();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1518;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1519;
				this.match(SparkSqlParser.KW_OVERWRITE);
				this.state = 1521;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LOCAL) {
					{
					this.state = 1520;
					this.match(SparkSqlParser.KW_LOCAL);
					}
				}

				this.state = 1523;
				this.match(SparkSqlParser.KW_DIRECTORY);
				this.state = 1524;
				_localctx._path = this.stringLit();
				this.state = 1526;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ROW) {
					{
					this.state = 1525;
					this.rowFormat();
					}
				}

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

				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1531;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 1532;
				this.match(SparkSqlParser.KW_OVERWRITE);
				this.state = 1534;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_LOCAL) {
					{
					this.state = 1533;
					this.match(SparkSqlParser.KW_LOCAL);
					}
				}

				this.state = 1536;
				this.match(SparkSqlParser.KW_DIRECTORY);
				this.state = 1538;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 164, this._ctx) ) {
				case 1:
					{
					this.state = 1537;
					_localctx._path = this.stringLit();
					}
					break;
				}
				this.state = 1540;
				this.tableProvider();
				this.state = 1543;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_OPTIONS) {
					{
					this.state = 1541;
					this.match(SparkSqlParser.KW_OPTIONS);
					this.state = 1542;
					_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 = 1547;
			this.partitionSpec();
			this.state = 1549;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_LOCATION) {
				{
				this.state = 1548;
				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 = 1551;
			this.match(SparkSqlParser.KW_PARTITION);
			this.state = 1552;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1553;
			this.partitionVal();
			this.state = 1558;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1554;
				this.match(SparkSqlParser.COMMA);
				this.state = 1555;
				this.partitionVal();
				}
				}
				this.state = 1560;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1561;
			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 = 1572;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 170, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1563;
				this.identifier();
				this.state = 1566;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.EQ) {
					{
					this.state = 1564;
					this.match(SparkSqlParser.EQ);
					this.state = 1565;
					this.constant();
					}
				}

				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1568;
				this.identifier();
				this.state = 1569;
				this.match(SparkSqlParser.EQ);
				this.state = 1570;
				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 = 1574;
			_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 = 1576;
			_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 = 1583;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 171, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1578;
				this.identifierReference();
				}
				break;

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

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

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

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1582;
				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 = 1585;
			_localctx._identifier = this.identifier();
			_localctx._nameParts.push(_localctx._identifier);
			this.state = 1590;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.DOT) {
				{
				{
				this.state = 1586;
				this.match(SparkSqlParser.DOT);
				this.state = 1587;
				_localctx._identifier = this.identifier();
				_localctx._nameParts.push(_localctx._identifier);
				}
				}
				this.state = 1592;
				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 = 1593;
			this.match(SparkSqlParser.KW_WITH);
			this.state = 1594;
			this.namedQuery();
			this.state = 1599;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1595;
				this.match(SparkSqlParser.COMMA);
				this.state = 1596;
				this.namedQuery();
				}
				}
				this.state = 1601;
				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 = 1602;
			_localctx._name = this.errorCapturingIdentifier();
			this.state = 1604;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 174, this._ctx) ) {
			case 1:
				{
				this.state = 1603;
				_localctx._columnAliases = this.identifierList();
				}
				break;
			}
			this.state = 1607;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AS) {
				{
				this.state = 1606;
				this.match(SparkSqlParser.KW_AS);
				}
			}

			this.state = 1609;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1610;
			this.query();
			this.state = 1611;
			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 = 1613;
			this.match(SparkSqlParser.KW_USING);
			this.state = 1614;
			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 = 1631;
			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 = 1629;
					this._errHandler.sync(this);
					switch (this._input.LA(1)) {
					case SparkSqlParser.KW_OPTIONS:
						{
						{
						this.state = 1616;
						this.match(SparkSqlParser.KW_OPTIONS);
						this.state = 1617;
						_localctx._options = this.expressionPropertyList();
						}
						}
						break;
					case SparkSqlParser.KW_PARTITIONED:
						{
						{
						this.state = 1618;
						this.match(SparkSqlParser.KW_PARTITIONED);
						this.state = 1619;
						this.match(SparkSqlParser.KW_BY);
						this.state = 1620;
						_localctx._partitioning = this.partitionFieldList();
						}
						}
						break;
					case SparkSqlParser.KW_SKEWED:
						{
						this.state = 1621;
						this.skewSpec();
						}
						break;
					case SparkSqlParser.KW_CLUSTERED:
						{
						this.state = 1622;
						this.bucketSpec();
						}
						break;
					case SparkSqlParser.KW_ROW:
						{
						this.state = 1623;
						this.rowFormat();
						}
						break;
					case SparkSqlParser.KW_STORED:
						{
						this.state = 1624;
						this.createFileFormat();
						}
						break;
					case SparkSqlParser.KW_LOCATION:
						{
						this.state = 1625;
						this.locationSpec();
						}
						break;
					case SparkSqlParser.KW_COMMENT:
						{
						this.state = 1626;
						this.commentSpec();
						}
						break;
					case SparkSqlParser.KW_TBLPROPERTIES:
						{
						{
						this.state = 1627;
						this.match(SparkSqlParser.KW_TBLPROPERTIES);
						this.state = 1628;
						_localctx._tableProps = this.propertyList();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
				}
				this.state = 1633;
				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 = 1634;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1635;
			this.property();
			this.state = 1640;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1636;
				this.match(SparkSqlParser.COMMA);
				this.state = 1637;
				this.property();
				}
				}
				this.state = 1642;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1643;
			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);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1645;
			_localctx._key = this.propertyKey();
			this.state = 1650;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 180, this._ctx) ) {
			case 1:
				{
				this.state = 1647;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 179, this._ctx) ) {
				case 1:
					{
					this.state = 1646;
					this.match(SparkSqlParser.EQ);
					}
					break;
				}
				this.state = 1649;
				_localctx._value = this.propertyValue();
				}
				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 propertyKey(): PropertyKeyContext {
		let _localctx: PropertyKeyContext = new PropertyKeyContext(this._ctx, this.state);
		this.enterRule(_localctx, 56, SparkSqlParser.RULE_propertyKey);
		try {
			let _alt: number;
			this.state = 1661;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 182, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1652;
				this.identifier();
				this.state = 1657;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 181, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1653;
						this.match(SparkSqlParser.DOT);
						this.state = 1654;
						this.identifier();
						}
						}
					}
					this.state = 1659;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 181, this._ctx);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1660;
				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 = 1667;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 183, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1663;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;

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

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

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1666;
				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 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 = 1669;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1670;
			this.expressionProperty();
			this.state = 1675;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1671;
				this.match(SparkSqlParser.COMMA);
				this.state = 1672;
				this.expressionProperty();
				}
				}
				this.state = 1677;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1678;
			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);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1680;
			_localctx._key = this.propertyKey();
			this.state = 1685;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 186, this._ctx) ) {
			case 1:
				{
				this.state = 1682;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 185, this._ctx) ) {
				case 1:
					{
					this.state = 1681;
					this.match(SparkSqlParser.EQ);
					}
					break;
				}
				this.state = 1684;
				_localctx._value = 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 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 = 1687;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1688;
			this.constant();
			this.state = 1693;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1689;
				this.match(SparkSqlParser.COMMA);
				this.state = 1690;
				this.constant();
				}
				}
				this.state = 1695;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1696;
			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 = 1698;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 1699;
			this.constantList();
			this.state = 1704;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 1700;
				this.match(SparkSqlParser.COMMA);
				this.state = 1701;
				this.constantList();
				}
				}
				this.state = 1706;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 1707;
			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 = 1715;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 189, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1709;
				this.match(SparkSqlParser.KW_STORED);
				this.state = 1710;
				this.match(SparkSqlParser.KW_AS);
				this.state = 1711;
				this.fileFormat();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1712;
				this.match(SparkSqlParser.KW_STORED);
				this.state = 1713;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1714;
				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 = 1723;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 190, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1717;
				this.match(SparkSqlParser.KW_INPUTFORMAT);
				this.state = 1718;
				_localctx._inFmt = this.stringLit();
				this.state = 1719;
				this.match(SparkSqlParser.KW_OUTPUTFORMAT);
				this.state = 1720;
				_localctx._outFmt = this.stringLit();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1722;
				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 = 1725;
			this.stringLit();
			this.state = 1729;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 191, this._ctx) ) {
			case 1:
				{
				this.state = 1726;
				this.match(SparkSqlParser.KW_WITH);
				this.state = 1727;
				this.match(SparkSqlParser.KW_SERDEPROPERTIES);
				this.state = 1728;
				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 = 1731;
			this.identifier();
			this.state = 1732;
			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 = 1790;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_INSERT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1734;
				this.insertInto();
				this.state = 1735;
				this.query();
				}
				break;
			case SparkSqlParser.KW_FROM:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1737;
				this.fromClause();
				this.state = 1739;
				this._errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						this.state = 1738;
						this.multiInsertQueryBody();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					this.state = 1741;
					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 = 1743;
				this.match(SparkSqlParser.KW_DELETE);
				this.state = 1744;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 1745;
				this.tableName();
				this.state = 1746;
				this.tableAlias();
				this.state = 1748;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_WHERE) {
					{
					this.state = 1747;
					this.whereClause();
					}
				}

				}
				break;
			case SparkSqlParser.KW_UPDATE:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1750;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 1751;
				this.tableName();
				this.state = 1752;
				this.tableAlias();
				this.state = 1753;
				this.setClause();
				this.state = 1755;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_WHERE) {
					{
					this.state = 1754;
					this.whereClause();
					}
				}

				}
				break;
			case SparkSqlParser.KW_MERGE:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1757;
				this.match(SparkSqlParser.KW_MERGE);
				this.state = 1758;
				this.match(SparkSqlParser.KW_INTO);
				this.state = 1759;
				_localctx._target = this.tableName();
				this.state = 1760;
				_localctx._targetAlias = this.tableAlias();
				this.state = 1761;
				this.match(SparkSqlParser.KW_USING);
				this.state = 1767;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 195, this._ctx) ) {
				case 1:
					{
					this.state = 1762;
					_localctx._source = this.identifierReference();
					}
					break;

				case 2:
					{
					this.state = 1763;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 1764;
					_localctx._sourceQuery = this.query();
					this.state = 1765;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 1769;
				_localctx._sourceAlias = this.tableAlias();
				this.state = 1770;
				this.match(SparkSqlParser.KW_ON);
				this.state = 1771;
				_localctx._mergeCondition = this.booleanExpression(0);
				this.state = 1775;
				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 = 1772;
						this.matchedClause();
						}
						}
					}
					this.state = 1777;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 196, this._ctx);
				}
				this.state = 1781;
				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 = 1778;
						this.notMatchedClause();
						}
						}
					}
					this.state = 1783;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 197, this._ctx);
				}
				this.state = 1787;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.KW_WHEN) {
					{
					{
					this.state = 1784;
					this.notMatchedBySourceClause();
					}
					}
					this.state = 1789;
					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 = 1792;
			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 = 1794;
			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 = 1796;
			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 = 1798;
			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 = 1800;
			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 = 1802;
			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 identifierReference(): IdentifierReferenceContext {
		let _localctx: IdentifierReferenceContext = new IdentifierReferenceContext(this._ctx, this.state);
		this.enterRule(_localctx, 90, SparkSqlParser.RULE_identifierReference);
		try {
			this.state = 1810;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 200, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1804;
				this.match(SparkSqlParser.KW_IDENTIFIER_KW);
				this.state = 1805;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1806;
				this.expression();
				this.state = 1807;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1809;
				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, 92, SparkSqlParser.RULE_queryOrganization);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1822;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 202, this._ctx) ) {
			case 1:
				{
				this.state = 1812;
				this.match(SparkSqlParser.KW_ORDER);
				this.state = 1813;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1814;
				_localctx._sortItem = this.sortItem();
				_localctx._order.push(_localctx._sortItem);
				this.state = 1819;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 201, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1815;
						this.match(SparkSqlParser.COMMA);
						this.state = 1816;
						_localctx._sortItem = this.sortItem();
						_localctx._order.push(_localctx._sortItem);
						}
						}
					}
					this.state = 1821;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 201, this._ctx);
				}
				}
				break;
			}
			this.state = 1834;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 204, this._ctx) ) {
			case 1:
				{
				this.state = 1824;
				this.match(SparkSqlParser.KW_CLUSTER);
				this.state = 1825;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1826;
				_localctx._expression = this.expression();
				_localctx._clusterBy.push(_localctx._expression);
				this.state = 1831;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 203, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1827;
						this.match(SparkSqlParser.COMMA);
						this.state = 1828;
						_localctx._expression = this.expression();
						_localctx._clusterBy.push(_localctx._expression);
						}
						}
					}
					this.state = 1833;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 203, this._ctx);
				}
				}
				break;
			}
			this.state = 1846;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 206, this._ctx) ) {
			case 1:
				{
				this.state = 1836;
				this.match(SparkSqlParser.KW_DISTRIBUTE);
				this.state = 1837;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1838;
				_localctx._expression = this.expression();
				_localctx._distributeBy.push(_localctx._expression);
				this.state = 1843;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 205, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1839;
						this.match(SparkSqlParser.COMMA);
						this.state = 1840;
						_localctx._expression = this.expression();
						_localctx._distributeBy.push(_localctx._expression);
						}
						}
					}
					this.state = 1845;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 205, this._ctx);
				}
				}
				break;
			}
			this.state = 1858;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 208, this._ctx) ) {
			case 1:
				{
				this.state = 1848;
				this.match(SparkSqlParser.KW_SORT);
				this.state = 1849;
				this.match(SparkSqlParser.KW_BY);
				this.state = 1850;
				_localctx._sortItem = this.sortItem();
				_localctx._sort.push(_localctx._sortItem);
				this.state = 1855;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 207, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1851;
						this.match(SparkSqlParser.COMMA);
						this.state = 1852;
						_localctx._sortItem = this.sortItem();
						_localctx._sort.push(_localctx._sortItem);
						}
						}
					}
					this.state = 1857;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 207, this._ctx);
				}
				}
				break;
			}
			this.state = 1861;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 209, this._ctx) ) {
			case 1:
				{
				this.state = 1860;
				this.windowClause();
				}
				break;
			}
			this.state = 1868;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 211, this._ctx) ) {
			case 1:
				{
				this.state = 1863;
				this.match(SparkSqlParser.KW_LIMIT);
				this.state = 1866;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 210, this._ctx) ) {
				case 1:
					{
					this.state = 1864;
					this.match(SparkSqlParser.KW_ALL);
					}
					break;

				case 2:
					{
					this.state = 1865;
					_localctx._limit = this.expression();
					}
					break;
				}
				}
				break;
			}
			this.state = 1872;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 212, this._ctx) ) {
			case 1:
				{
				this.state = 1870;
				this.match(SparkSqlParser.KW_OFFSET);
				this.state = 1871;
				_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, 94, SparkSqlParser.RULE_multiInsertQueryBody);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1874;
			this.insertInto();
			this.state = 1875;
			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 = 96;
		this.enterRecursionRule(_localctx, 96, SparkSqlParser.RULE_queryTerm, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			{
			this.state = 1878;
			this.queryPrimary();
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 1903;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 217, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 1901;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 216, this._ctx) ) {
					case 1:
						{
						_localctx = new QueryTermContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_queryTerm);
						this.state = 1880;
						if (!(this.precpred(this._ctx, 3))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
						}
						this.state = 1881;
						if (!(this.legacy_setops_precedence_enabled)) {
							throw this.createFailedPredicateException("this.legacy_setops_precedence_enabled");
						}
						this.state = 1882;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_INTERSECT || _la === SparkSqlParser.KW_SETMINUS || _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 = 1884;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
							{
							this.state = 1883;
							this.setQuantifier();
							}
						}

						this.state = 1886;
						_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 = 1887;
						if (!(this.precpred(this._ctx, 2))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
						}
						this.state = 1888;
						if (!(!this.legacy_setops_precedence_enabled)) {
							throw this.createFailedPredicateException("!this.legacy_setops_precedence_enabled");
						}
						this.state = 1889;
						_localctx._operator = this.match(SparkSqlParser.KW_INTERSECT);
						this.state = 1891;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
							{
							this.state = 1890;
							this.setQuantifier();
							}
						}

						this.state = 1893;
						_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 = 1894;
						if (!(this.precpred(this._ctx, 1))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
						}
						this.state = 1895;
						if (!(!this.legacy_setops_precedence_enabled)) {
							throw this.createFailedPredicateException("!this.legacy_setops_precedence_enabled");
						}
						this.state = 1896;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_EXCEPT || _la === SparkSqlParser.KW_SETMINUS || _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 = 1898;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						if (_la === SparkSqlParser.KW_ALL || _la === SparkSqlParser.KW_DISTINCT) {
							{
							this.state = 1897;
							this.setQuantifier();
							}
						}

						this.state = 1900;
						_localctx._right = this.queryTerm(2);
						}
						break;
					}
					}
				}
				this.state = 1905;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 217, 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, 98, SparkSqlParser.RULE_queryPrimary);
		try {
			this.state = 1915;
			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 = 1906;
				this.querySpecification();
				}
				break;
			case SparkSqlParser.KW_FROM:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1907;
				this.fromStatement();
				}
				break;
			case SparkSqlParser.KW_TABLE:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 1908;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 1909;
				this.tableName();
				}
				break;
			case SparkSqlParser.KW_VALUES:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 1910;
				this.inlineTable();
				}
				break;
			case SparkSqlParser.LEFT_PAREN:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 1911;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 1912;
				this.query();
				this.state = 1913;
				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, 100, SparkSqlParser.RULE_sortItem);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1917;
			this.expression();
			this.state = 1919;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 219, this._ctx) ) {
			case 1:
				{
				this.state = 1918;
				_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 = 1923;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 220, this._ctx) ) {
			case 1:
				{
				this.state = 1921;
				this.match(SparkSqlParser.KW_NULLS);
				this.state = 1922;
				_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, 102, SparkSqlParser.RULE_fromStatement);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 1925;
			this.fromClause();
			this.state = 1927;
			this._errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					this.state = 1926;
					this.fromStatementBody();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 1929;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 221, 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, 104, SparkSqlParser.RULE_fromStatementBody);
		try {
			let _alt: number;
			this.state = 1958;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 228, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1931;
				this.transformClause();
				this.state = 1933;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 222, this._ctx) ) {
				case 1:
					{
					this.state = 1932;
					this.whereClause();
					}
					break;
				}
				this.state = 1935;
				this.queryOrganization();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1937;
				this.selectClause();
				this.state = 1941;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 223, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1938;
						this.lateralView();
						}
						}
					}
					this.state = 1943;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 223, this._ctx);
				}
				this.state = 1945;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 224, this._ctx) ) {
				case 1:
					{
					this.state = 1944;
					this.whereClause();
					}
					break;
				}
				this.state = 1948;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 225, this._ctx) ) {
				case 1:
					{
					this.state = 1947;
					this.aggregationClause();
					}
					break;
				}
				this.state = 1951;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 226, this._ctx) ) {
				case 1:
					{
					this.state = 1950;
					this.havingClause();
					}
					break;
				}
				this.state = 1954;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 227, this._ctx) ) {
				case 1:
					{
					this.state = 1953;
					this.windowClause();
					}
					break;
				}
				this.state = 1956;
				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, 106, SparkSqlParser.RULE_querySpecification);
		try {
			let _alt: number;
			this.state = 2004;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 241, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 1960;
				this.transformClause();
				this.state = 1962;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 229, this._ctx) ) {
				case 1:
					{
					this.state = 1961;
					this.fromClause();
					}
					break;
				}
				this.state = 1967;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1964;
						this.lateralView();
						}
						}
					}
					this.state = 1969;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx);
				}
				this.state = 1971;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 231, this._ctx) ) {
				case 1:
					{
					this.state = 1970;
					this.whereClause();
					}
					break;
				}
				this.state = 1974;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 232, this._ctx) ) {
				case 1:
					{
					this.state = 1973;
					this.aggregationClause();
					}
					break;
				}
				this.state = 1977;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 233, this._ctx) ) {
				case 1:
					{
					this.state = 1976;
					this.havingClause();
					}
					break;
				}
				this.state = 1980;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 234, this._ctx) ) {
				case 1:
					{
					this.state = 1979;
					this.windowClause();
					}
					break;
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 1982;
				this.selectClause();
				this.state = 1984;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 235, this._ctx) ) {
				case 1:
					{
					this.state = 1983;
					this.fromClause();
					}
					break;
				}
				this.state = 1989;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 1986;
						this.lateralView();
						}
						}
					}
					this.state = 1991;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx);
				}
				this.state = 1993;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 237, this._ctx) ) {
				case 1:
					{
					this.state = 1992;
					this.whereClause();
					}
					break;
				}
				this.state = 1996;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 238, this._ctx) ) {
				case 1:
					{
					this.state = 1995;
					this.aggregationClause();
					}
					break;
				}
				this.state = 1999;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 239, this._ctx) ) {
				case 1:
					{
					this.state = 1998;
					this.havingClause();
					}
					break;
				}
				this.state = 2002;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 240, this._ctx) ) {
				case 1:
					{
					this.state = 2001;
					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, 108, SparkSqlParser.RULE_transformClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2025;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_SELECT:
				{
				this.state = 2006;
				this.match(SparkSqlParser.KW_SELECT);
				this.state = 2007;
				_localctx._kind = this.match(SparkSqlParser.KW_TRANSFORM);
				this.state = 2008;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2010;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 242, this._ctx) ) {
				case 1:
					{
					this.state = 2009;
					this.setQuantifier();
					}
					break;
				}
				this.state = 2012;
				this.expressionSeq();
				this.state = 2013;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			case SparkSqlParser.KW_MAP:
				{
				this.state = 2015;
				_localctx._kind = this.match(SparkSqlParser.KW_MAP);
				this.state = 2017;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 243, this._ctx) ) {
				case 1:
					{
					this.state = 2016;
					this.setQuantifier();
					}
					break;
				}
				this.state = 2019;
				this.expressionSeq();
				}
				break;
			case SparkSqlParser.KW_REDUCE:
				{
				this.state = 2020;
				_localctx._kind = this.match(SparkSqlParser.KW_REDUCE);
				this.state = 2022;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 244, this._ctx) ) {
				case 1:
					{
					this.state = 2021;
					this.setQuantifier();
					}
					break;
				}
				this.state = 2024;
				this.expressionSeq();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			this.state = 2028;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_ROW) {
				{
				this.state = 2027;
				_localctx._inRowFormat = this.rowFormat();
				}
			}

			this.state = 2032;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_RECORDWRITER) {
				{
				this.state = 2030;
				this.match(SparkSqlParser.KW_RECORDWRITER);
				this.state = 2031;
				_localctx._recordWriter = this.stringLit();
				}
			}

			this.state = 2034;
			this.match(SparkSqlParser.KW_USING);
			this.state = 2035;
			_localctx._script = this.stringLit();
			this.state = 2048;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 250, this._ctx) ) {
			case 1:
				{
				this.state = 2036;
				this.match(SparkSqlParser.KW_AS);
				this.state = 2046;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 249, this._ctx) ) {
				case 1:
					{
					this.state = 2037;
					this.identifierSeq();
					}
					break;

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

				case 3:
					{
					{
					this.state = 2039;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2042;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 248, this._ctx) ) {
					case 1:
						{
						this.state = 2040;
						this.identifierSeq();
						}
						break;

					case 2:
						{
						this.state = 2041;
						this.colTypeList();
						}
						break;
					}
					this.state = 2044;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					break;
				}
				}
				break;
			}
			this.state = 2051;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 251, this._ctx) ) {
			case 1:
				{
				this.state = 2050;
				_localctx._outRowFormat = this.rowFormat();
				}
				break;
			}
			this.state = 2055;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 252, this._ctx) ) {
			case 1:
				{
				this.state = 2053;
				this.match(SparkSqlParser.KW_RECORDREADER);
				this.state = 2054;
				_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, 110, SparkSqlParser.RULE_selectClause);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2057;
			this.match(SparkSqlParser.KW_SELECT);
			this.state = 2061;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 253, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2058;
					_localctx._hint = this.hint();
					_localctx._hints.push(_localctx._hint);
					}
					}
				}
				this.state = 2063;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 253, this._ctx);
			}
			this.state = 2065;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 254, this._ctx) ) {
			case 1:
				{
				this.state = 2064;
				this.setQuantifier();
				}
				break;
			}
			this.state = 2067;
			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, 112, SparkSqlParser.RULE_setClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2069;
			this.match(SparkSqlParser.KW_SET);
			this.state = 2070;
			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, 114, SparkSqlParser.RULE_matchedClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2072;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 2073;
			this.match(SparkSqlParser.KW_MATCHED);
			this.state = 2076;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AND) {
				{
				this.state = 2074;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2075;
				_localctx._matchedCond = this.booleanExpression(0);
				}
			}

			this.state = 2078;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 2079;
			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, 116, SparkSqlParser.RULE_notMatchedClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2081;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 2082;
			this.match(SparkSqlParser.KW_NOT);
			this.state = 2083;
			this.match(SparkSqlParser.KW_MATCHED);
			this.state = 2086;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_BY) {
				{
				this.state = 2084;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2085;
				this.match(SparkSqlParser.KW_TARGET);
				}
			}

			this.state = 2090;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AND) {
				{
				this.state = 2088;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2089;
				_localctx._notMatchedCond = this.booleanExpression(0);
				}
			}

			this.state = 2092;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 2093;
			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, 118, SparkSqlParser.RULE_notMatchedBySourceClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2095;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 2096;
			this.match(SparkSqlParser.KW_NOT);
			this.state = 2097;
			this.match(SparkSqlParser.KW_MATCHED);
			this.state = 2098;
			this.match(SparkSqlParser.KW_BY);
			this.state = 2099;
			this.match(SparkSqlParser.KW_SOURCE);
			this.state = 2102;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_AND) {
				{
				this.state = 2100;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2101;
				_localctx._notMatchedBySourceCond = this.booleanExpression(0);
				}
			}

			this.state = 2104;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 2105;
			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, 120, SparkSqlParser.RULE_matchedAction);
		try {
			this.state = 2114;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 259, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2107;
				this.match(SparkSqlParser.KW_DELETE);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2108;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 2109;
				this.match(SparkSqlParser.KW_SET);
				this.state = 2110;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2111;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 2112;
				this.match(SparkSqlParser.KW_SET);
				this.state = 2113;
				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, 122, SparkSqlParser.RULE_notMatchedAction);
		let _la: number;
		try {
			this.state = 2134;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 261, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2116;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 2117;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2118;
				this.match(SparkSqlParser.KW_INSERT);
				this.state = 2119;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2120;
				this.multipartIdentifierList();
				this.state = 2121;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2122;
				this.match(SparkSqlParser.KW_VALUES);
				this.state = 2123;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2124;
				this.expression();
				this.state = 2129;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2125;
					this.match(SparkSqlParser.COMMA);
					this.state = 2126;
					this.expression();
					}
					}
					this.state = 2131;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2132;
				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, 124, SparkSqlParser.RULE_notMatchedBySourceAction);
		try {
			this.state = 2140;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_DELETE:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2136;
				this.match(SparkSqlParser.KW_DELETE);
				}
				break;
			case SparkSqlParser.KW_UPDATE:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2137;
				this.match(SparkSqlParser.KW_UPDATE);
				this.state = 2138;
				this.match(SparkSqlParser.KW_SET);
				this.state = 2139;
				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, 126, SparkSqlParser.RULE_assignmentList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2142;
			this.assignment();
			this.state = 2147;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2143;
				this.match(SparkSqlParser.COMMA);
				this.state = 2144;
				this.assignment();
				}
				}
				this.state = 2149;
				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, 128, SparkSqlParser.RULE_assignment);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2150;
			_localctx._key = this.multipartIdentifier();
			this.state = 2151;
			this.match(SparkSqlParser.EQ);
			this.state = 2152;
			_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, 130, SparkSqlParser.RULE_whereClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2154;
			this.match(SparkSqlParser.KW_WHERE);
			this.state = 2155;
			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, 132, SparkSqlParser.RULE_havingClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2157;
			this.match(SparkSqlParser.KW_HAVING);
			this.state = 2158;
			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, 134, SparkSqlParser.RULE_hint);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2160;
			this.match(SparkSqlParser.HENT_START);
			this.state = 2161;
			_localctx._hintStatement = this.hintStatement();
			_localctx._hintStatements.push(_localctx._hintStatement);
			this.state = 2168;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 265, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2163;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 264, this._ctx) ) {
					case 1:
						{
						this.state = 2162;
						this.match(SparkSqlParser.COMMA);
						}
						break;
					}
					this.state = 2165;
					_localctx._hintStatement = this.hintStatement();
					_localctx._hintStatements.push(_localctx._hintStatement);
					}
					}
				}
				this.state = 2170;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 265, this._ctx);
			}
			this.state = 2171;
			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, 136, SparkSqlParser.RULE_hintStatement);
		let _la: number;
		try {
			this.state = 2186;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 267, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2173;
				_localctx._hintName = this.identifier();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2174;
				_localctx._hintName = this.identifier();
				this.state = 2175;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2176;
				_localctx._primaryExpression = this.primaryExpression(0);
				_localctx._parameters.push(_localctx._primaryExpression);
				this.state = 2181;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2177;
					this.match(SparkSqlParser.COMMA);
					this.state = 2178;
					_localctx._primaryExpression = this.primaryExpression(0);
					_localctx._parameters.push(_localctx._primaryExpression);
					}
					}
					this.state = 2183;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2184;
				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, 138, SparkSqlParser.RULE_fromClause);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2188;
			this.match(SparkSqlParser.KW_FROM);
			this.state = 2189;
			this.relation();
			this.state = 2194;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 268, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2190;
					this.match(SparkSqlParser.COMMA);
					this.state = 2191;
					this.relation();
					}
					}
				}
				this.state = 2196;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 268, this._ctx);
			}
			this.state = 2200;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 269, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2197;
					this.lateralView();
					}
					}
				}
				this.state = 2202;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 269, this._ctx);
			}
			this.state = 2204;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 270, this._ctx) ) {
			case 1:
				{
				this.state = 2203;
				this.pivotClause();
				}
				break;
			}
			this.state = 2207;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 271, this._ctx) ) {
			case 1:
				{
				this.state = 2206;
				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, 140, SparkSqlParser.RULE_functionKind);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2209;
			_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, 142, SparkSqlParser.RULE_temporalClause);
		let _la: number;
		try {
			this.state = 2225;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 274, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2212;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FOR) {
					{
					this.state = 2211;
					this.match(SparkSqlParser.KW_FOR);
					}
				}

				this.state = 2214;
				_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 = 2215;
				this.match(SparkSqlParser.KW_AS);
				this.state = 2216;
				this.match(SparkSqlParser.KW_OF);
				this.state = 2217;
				this.version();
				}
				break;

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

				this.state = 2221;
				_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 = 2222;
				this.match(SparkSqlParser.KW_AS);
				this.state = 2223;
				this.match(SparkSqlParser.KW_OF);
				this.state = 2224;
				_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, 144, SparkSqlParser.RULE_aggregationClause);
		let _la: number;
		try {
			let _alt: number;
			this.state = 2266;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 279, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2227;
				this.match(SparkSqlParser.KW_GROUP);
				this.state = 2228;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2229;
				_localctx._groupByClause = this.groupByClause();
				_localctx._groupingExpressionsWithGroupingAnalytics.push(_localctx._groupByClause);
				this.state = 2234;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 275, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2230;
						this.match(SparkSqlParser.COMMA);
						this.state = 2231;
						_localctx._groupByClause = this.groupByClause();
						_localctx._groupingExpressionsWithGroupingAnalytics.push(_localctx._groupByClause);
						}
						}
					}
					this.state = 2236;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 275, this._ctx);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2237;
				this.match(SparkSqlParser.KW_GROUP);
				this.state = 2238;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2239;
				_localctx._expression = this.expression();
				_localctx._groupingExpressions.push(_localctx._expression);
				this.state = 2244;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 276, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2240;
						this.match(SparkSqlParser.COMMA);
						this.state = 2241;
						_localctx._expression = this.expression();
						_localctx._groupingExpressions.push(_localctx._expression);
						}
						}
					}
					this.state = 2246;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 276, this._ctx);
				}
				this.state = 2264;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 278, this._ctx) ) {
				case 1:
					{
					this.state = 2247;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 2248;
					_localctx._kind = this.match(SparkSqlParser.KW_ROLLUP);
					}
					break;

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

				case 3:
					{
					this.state = 2251;
					_localctx._kind = this.match(SparkSqlParser.KW_GROUPING);
					this.state = 2252;
					this.match(SparkSqlParser.KW_SETS);
					this.state = 2253;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2254;
					this.groupingSet();
					this.state = 2259;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2255;
						this.match(SparkSqlParser.COMMA);
						this.state = 2256;
						this.groupingSet();
						}
						}
						this.state = 2261;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 2262;
					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, 146, SparkSqlParser.RULE_groupByClause);
		try {
			this.state = 2270;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 280, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2268;
				this.groupingAnalytics();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2269;
				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, 148, SparkSqlParser.RULE_groupingAnalytics);
		let _la: number;
		try {
			this.state = 2297;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_CUBE:
			case SparkSqlParser.KW_ROLLUP:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2272;
				_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 = 2273;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2274;
				this.groupingSet();
				this.state = 2279;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2275;
					this.match(SparkSqlParser.COMMA);
					this.state = 2276;
					this.groupingSet();
					}
					}
					this.state = 2281;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2282;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;
			case SparkSqlParser.KW_GROUPING:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2284;
				this.match(SparkSqlParser.KW_GROUPING);
				this.state = 2285;
				this.match(SparkSqlParser.KW_SETS);
				this.state = 2286;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2287;
				this.groupingElement();
				this.state = 2292;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2288;
					this.match(SparkSqlParser.COMMA);
					this.state = 2289;
					this.groupingElement();
					}
					}
					this.state = 2294;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2295;
				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, 150, SparkSqlParser.RULE_groupingElement);
		try {
			this.state = 2301;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 284, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2299;
				this.groupingAnalytics();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2300;
				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, 152, SparkSqlParser.RULE_groupingSet);
		let _la: number;
		try {
			this.state = 2316;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 287, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2303;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2312;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 286, this._ctx) ) {
				case 1:
					{
					this.state = 2304;
					this.expression();
					this.state = 2309;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2305;
						this.match(SparkSqlParser.COMMA);
						this.state = 2306;
						this.expression();
						}
						}
						this.state = 2311;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
					break;
				}
				this.state = 2314;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2315;
				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 pivotClause(): PivotClauseContext {
		let _localctx: PivotClauseContext = new PivotClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 154, SparkSqlParser.RULE_pivotClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2318;
			this.match(SparkSqlParser.KW_PIVOT);
			this.state = 2319;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2320;
			_localctx._aggregates = this.namedExpressionSeq();
			this.state = 2321;
			this.match(SparkSqlParser.KW_FOR);
			this.state = 2322;
			this.pivotColumn();
			this.state = 2323;
			this.match(SparkSqlParser.KW_IN);
			this.state = 2324;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2325;
			_localctx._pivotValue = this.pivotValue();
			_localctx._pivotValues.push(_localctx._pivotValue);
			this.state = 2330;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2326;
				this.match(SparkSqlParser.COMMA);
				this.state = 2327;
				_localctx._pivotValue = this.pivotValue();
				_localctx._pivotValues.push(_localctx._pivotValue);
				}
				}
				this.state = 2332;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2333;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2334;
			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, 156, SparkSqlParser.RULE_pivotColumn);
		let _la: number;
		try {
			this.state = 2348;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 290, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2336;
				_localctx._identifier = this.identifier();
				_localctx._identifiers.push(_localctx._identifier);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2337;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2338;
				_localctx._identifier = this.identifier();
				_localctx._identifiers.push(_localctx._identifier);
				this.state = 2343;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2339;
					this.match(SparkSqlParser.COMMA);
					this.state = 2340;
					_localctx._identifier = this.identifier();
					_localctx._identifiers.push(_localctx._identifier);
					}
					}
					this.state = 2345;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2346;
				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 pivotValue(): PivotValueContext {
		let _localctx: PivotValueContext = new PivotValueContext(this._ctx, this.state);
		this.enterRule(_localctx, 158, SparkSqlParser.RULE_pivotValue);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2350;
			this.expression();
			this.state = 2355;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 292, this._ctx) ) {
			case 1:
				{
				this.state = 2352;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 291, this._ctx) ) {
				case 1:
					{
					this.state = 2351;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2354;
				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 unpivotClause(): UnpivotClauseContext {
		let _localctx: UnpivotClauseContext = new UnpivotClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 160, SparkSqlParser.RULE_unpivotClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2357;
			this.match(SparkSqlParser.KW_UNPIVOT);
			this.state = 2359;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_EXCLUDE || _la === SparkSqlParser.KW_INCLUDE) {
				{
				this.state = 2358;
				_localctx._nullOperator = this.unpivotNullClause();
				}
			}

			this.state = 2361;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2362;
			_localctx._operator = this.unpivotOperator();
			this.state = 2363;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2368;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 295, this._ctx) ) {
			case 1:
				{
				this.state = 2365;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 294, this._ctx) ) {
				case 1:
					{
					this.state = 2364;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2367;
				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, 162, SparkSqlParser.RULE_unpivotNullClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2370;
			_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 = 2371;
			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, 164, SparkSqlParser.RULE_unpivotOperator);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2375;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 296, this._ctx) ) {
			case 1:
				{
				this.state = 2373;
				this.unpivotSingleValueColumnClause();
				}
				break;

			case 2:
				{
				this.state = 2374;
				this.unpivotMultiValueColumnClause();
				}
				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 unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext {
		let _localctx: UnpivotSingleValueColumnClauseContext = new UnpivotSingleValueColumnClauseContext(this._ctx, this.state);
		this.enterRule(_localctx, 166, SparkSqlParser.RULE_unpivotSingleValueColumnClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2377;
			this.unpivotValueColumn();
			this.state = 2378;
			this.match(SparkSqlParser.KW_FOR);
			this.state = 2379;
			this.unpivotNameColumn();
			this.state = 2380;
			this.match(SparkSqlParser.KW_IN);
			this.state = 2381;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2382;
			_localctx._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
			_localctx._unpivotColumns.push(_localctx._unpivotColumnAndAlias);
			this.state = 2387;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2383;
				this.match(SparkSqlParser.COMMA);
				this.state = 2384;
				_localctx._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
				_localctx._unpivotColumns.push(_localctx._unpivotColumnAndAlias);
				}
				}
				this.state = 2389;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2390;
			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, 168, SparkSqlParser.RULE_unpivotMultiValueColumnClause);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2392;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2393;
			_localctx._unpivotValueColumn = this.unpivotValueColumn();
			_localctx._unpivotValueColumns.push(_localctx._unpivotValueColumn);
			this.state = 2398;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2394;
				this.match(SparkSqlParser.COMMA);
				this.state = 2395;
				_localctx._unpivotValueColumn = this.unpivotValueColumn();
				_localctx._unpivotValueColumns.push(_localctx._unpivotValueColumn);
				}
				}
				this.state = 2400;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2401;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2402;
			this.match(SparkSqlParser.KW_FOR);
			this.state = 2403;
			this.unpivotNameColumn();
			this.state = 2404;
			this.match(SparkSqlParser.KW_IN);
			this.state = 2405;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2406;
			_localctx._unpivotColumnSet = this.unpivotColumnSet();
			_localctx._unpivotColumnSets.push(_localctx._unpivotColumnSet);
			this.state = 2411;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2407;
				this.match(SparkSqlParser.COMMA);
				this.state = 2408;
				_localctx._unpivotColumnSet = this.unpivotColumnSet();
				_localctx._unpivotColumnSets.push(_localctx._unpivotColumnSet);
				}
				}
				this.state = 2413;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2414;
			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, 170, SparkSqlParser.RULE_unpivotColumnSet);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2416;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2417;
			_localctx._unpivotColumn = this.unpivotColumn();
			_localctx._unpivotColumns.push(_localctx._unpivotColumn);
			this.state = 2422;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2418;
				this.match(SparkSqlParser.COMMA);
				this.state = 2419;
				_localctx._unpivotColumn = this.unpivotColumn();
				_localctx._unpivotColumns.push(_localctx._unpivotColumn);
				}
				}
				this.state = 2424;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2425;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2427;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 301, this._ctx) ) {
			case 1:
				{
				this.state = 2426;
				this.unpivotAlias();
				}
				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 unpivotValueColumn(): UnpivotValueColumnContext {
		let _localctx: UnpivotValueColumnContext = new UnpivotValueColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 172, SparkSqlParser.RULE_unpivotValueColumn);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2429;
			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, 174, SparkSqlParser.RULE_unpivotNameColumn);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2431;
			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, 176, SparkSqlParser.RULE_unpivotColumnAndAlias);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2433;
			this.unpivotColumn();
			this.state = 2435;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 302, this._ctx) ) {
			case 1:
				{
				this.state = 2434;
				this.unpivotAlias();
				}
				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 unpivotColumn(): UnpivotColumnContext {
		let _localctx: UnpivotColumnContext = new UnpivotColumnContext(this._ctx, this.state);
		this.enterRule(_localctx, 178, SparkSqlParser.RULE_unpivotColumn);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2437;
			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, 180, SparkSqlParser.RULE_unpivotAlias);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2440;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 303, this._ctx) ) {
			case 1:
				{
				this.state = 2439;
				this.match(SparkSqlParser.KW_AS);
				}
				break;
			}
			this.state = 2442;
			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, 182, SparkSqlParser.RULE_ifNotExists);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2444;
			this.match(SparkSqlParser.KW_IF);
			this.state = 2445;
			this.match(SparkSqlParser.KW_NOT);
			this.state = 2446;
			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, 184, SparkSqlParser.RULE_ifExists);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2448;
			this.match(SparkSqlParser.KW_IF);
			this.state = 2449;
			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, 186, SparkSqlParser.RULE_lateralView);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2451;
			this.match(SparkSqlParser.KW_LATERAL);
			this.state = 2452;
			this.match(SparkSqlParser.KW_VIEW);
			this.state = 2454;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 304, this._ctx) ) {
			case 1:
				{
				this.state = 2453;
				this.match(SparkSqlParser.KW_OUTER);
				}
				break;
			}
			this.state = 2456;
			this.viewName();
			this.state = 2457;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2466;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 306, this._ctx) ) {
			case 1:
				{
				this.state = 2458;
				this.expression();
				this.state = 2463;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2459;
					this.match(SparkSqlParser.COMMA);
					this.state = 2460;
					this.expression();
					}
					}
					this.state = 2465;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;
			}
			this.state = 2468;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2469;
			this.tableAlias();
			this.state = 2481;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 309, this._ctx) ) {
			case 1:
				{
				this.state = 2471;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 307, this._ctx) ) {
				case 1:
					{
					this.state = 2470;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2473;
				_localctx._identifier = this.identifier();
				_localctx._colName.push(_localctx._identifier);
				this.state = 2478;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 308, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2474;
						this.match(SparkSqlParser.COMMA);
						this.state = 2475;
						_localctx._identifier = this.identifier();
						_localctx._colName.push(_localctx._identifier);
						}
						}
					}
					this.state = 2480;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 308, 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, 188, SparkSqlParser.RULE_setQuantifier);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2483;
			_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, 190, SparkSqlParser.RULE_relation);
		try {
			let _alt: number;
			this.state = 2496;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 312, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2486;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 310, this._ctx) ) {
				case 1:
					{
					this.state = 2485;
					this.match(SparkSqlParser.KW_LATERAL);
					}
					break;
				}
				this.state = 2488;
				this.relationPrimary();
				this.state = 2492;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 311, this._ctx);
				while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
					if (_alt === 1) {
						{
						{
						this.state = 2489;
						this.relationExtension();
						}
						}
					}
					this.state = 2494;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 311, this._ctx);
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2495;
				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, 192, SparkSqlParser.RULE_relationExtension);
		try {
			this.state = 2501;
			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 = 2498;
				this.joinRelation();
				}
				break;
			case SparkSqlParser.KW_PIVOT:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2499;
				this.pivotClause();
				}
				break;
			case SparkSqlParser.KW_UNPIVOT:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2500;
				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, 194, SparkSqlParser.RULE_joinRelation);
		try {
			this.state = 2520;
			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 = 2503;
				this.joinType();
				}
				this.state = 2504;
				this.match(SparkSqlParser.KW_JOIN);
				this.state = 2506;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 314, this._ctx) ) {
				case 1:
					{
					this.state = 2505;
					this.match(SparkSqlParser.KW_LATERAL);
					}
					break;
				}
				this.state = 2508;
				_localctx._right = this.relationPrimary();
				this.state = 2510;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 315, this._ctx) ) {
				case 1:
					{
					this.state = 2509;
					this.joinCriteria();
					}
					break;
				}
				}
				break;
			case SparkSqlParser.KW_NATURAL:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2512;
				this.match(SparkSqlParser.KW_NATURAL);
				this.state = 2513;
				this.joinType();
				this.state = 2514;
				this.match(SparkSqlParser.KW_JOIN);
				this.state = 2516;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 316, this._ctx) ) {
				case 1:
					{
					this.state = 2515;
					this.match(SparkSqlParser.KW_LATERAL);
					}
					break;
				}
				this.state = 2518;
				_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, 196, SparkSqlParser.RULE_joinType);
		let _la: number;
		try {
			this.state = 2546;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 324, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2523;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_INNER) {
					{
					this.state = 2522;
					this.match(SparkSqlParser.KW_INNER);
					}
				}

				}
				break;

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

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

				}
				break;

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

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

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

				}
				break;

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

				}
				break;

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

				this.state = 2545;
				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, 198, SparkSqlParser.RULE_joinCriteria);
		try {
			this.state = 2552;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_ON:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2548;
				this.match(SparkSqlParser.KW_ON);
				this.state = 2549;
				this.booleanExpression(0);
				}
				break;
			case SparkSqlParser.KW_USING:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2550;
				this.match(SparkSqlParser.KW_USING);
				this.state = 2551;
				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, 200, SparkSqlParser.RULE_sample);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2554;
			this.match(SparkSqlParser.KW_TABLESAMPLE);
			this.state = 2555;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2557;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 326, this._ctx) ) {
			case 1:
				{
				this.state = 2556;
				this.sampleMethod();
				}
				break;
			}
			this.state = 2559;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2564;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 327, this._ctx) ) {
			case 1:
				{
				this.state = 2560;
				this.match(SparkSqlParser.KW_REPEATABLE);
				this.state = 2561;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2562;
				_localctx._seed = this.match(SparkSqlParser.INTEGER_VALUE);
				this.state = 2563;
				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, 202, SparkSqlParser.RULE_sampleMethod);
		let _la: number;
		try {
			this.state = 2590;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 331, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2567;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 2566;
					_localctx._negativeSign = this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 2569;
				_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 = 2570;
				this.match(SparkSqlParser.KW_PERCENTLIT);
				}
				break;

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

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2574;
				_localctx._sampleType = this.match(SparkSqlParser.KW_BUCKET);
				this.state = 2575;
				_localctx._numerator = this.match(SparkSqlParser.INTEGER_VALUE);
				this.state = 2576;
				this.match(SparkSqlParser.KW_OUT);
				this.state = 2577;
				this.match(SparkSqlParser.KW_OF);
				this.state = 2578;
				_localctx._denominator = this.match(SparkSqlParser.INTEGER_VALUE);
				this.state = 2587;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ON) {
					{
					this.state = 2579;
					this.match(SparkSqlParser.KW_ON);
					this.state = 2585;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 329, this._ctx) ) {
					case 1:
						{
						this.state = 2580;
						this.identifier();
						}
						break;

					case 2:
						{
						this.state = 2581;
						this.qualifiedName();
						this.state = 2582;
						this.match(SparkSqlParser.LEFT_PAREN);
						this.state = 2583;
						this.match(SparkSqlParser.RIGHT_PAREN);
						}
						break;
					}
					}
				}

				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 2589;
				_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, 204, SparkSqlParser.RULE_identifierList);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2592;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2593;
			this.identifierSeq();
			this.state = 2594;
			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, 206, SparkSqlParser.RULE_identifierSeq);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2596;
			_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
			_localctx._ident.push(_localctx._errorCapturingIdentifier);
			this.state = 2601;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 332, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2597;
					this.match(SparkSqlParser.COMMA);
					this.state = 2598;
					_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
					_localctx._ident.push(_localctx._errorCapturingIdentifier);
					}
					}
				}
				this.state = 2603;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 332, 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, 208, SparkSqlParser.RULE_orderedIdentifierList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2604;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2605;
			this.orderedIdentifier();
			this.state = 2610;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2606;
				this.match(SparkSqlParser.COMMA);
				this.state = 2607;
				this.orderedIdentifier();
				}
				}
				this.state = 2612;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2613;
			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, 210, SparkSqlParser.RULE_orderedIdentifier);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2615;
			_localctx._ident = this.errorCapturingIdentifier();
			this.state = 2617;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_ASC || _la === SparkSqlParser.KW_DESC) {
				{
				this.state = 2616;
				_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, 212, SparkSqlParser.RULE_identifierCommentList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2619;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2620;
			this.identifierComment();
			this.state = 2625;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2621;
				this.match(SparkSqlParser.COMMA);
				this.state = 2622;
				this.identifierComment();
				}
				}
				this.state = 2627;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2628;
			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, 214, SparkSqlParser.RULE_identifierComment);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2630;
			this.identifier();
			this.state = 2632;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_COMMENT) {
				{
				this.state = 2631;
				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, 216, SparkSqlParser.RULE_relationPrimary);
		try {
			this.state = 2661;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 341, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2634;
				this.identifierReference();
				this.state = 2636;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 337, this._ctx) ) {
				case 1:
					{
					this.state = 2635;
					this.temporalClause();
					}
					break;
				}
				this.state = 2639;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 338, this._ctx) ) {
				case 1:
					{
					this.state = 2638;
					this.sample();
					}
					break;
				}
				this.state = 2641;
				this.tableAlias();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2643;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2644;
				this.query();
				this.state = 2645;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2647;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 339, this._ctx) ) {
				case 1:
					{
					this.state = 2646;
					this.sample();
					}
					break;
				}
				this.state = 2649;
				this.tableAlias();
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2651;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2652;
				this.relation();
				this.state = 2653;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2655;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 340, this._ctx) ) {
				case 1:
					{
					this.state = 2654;
					this.sample();
					}
					break;
				}
				this.state = 2657;
				this.tableAlias();
				}
				break;

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

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 2660;
				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, 218, SparkSqlParser.RULE_inlineTable);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2663;
			this.match(SparkSqlParser.KW_VALUES);
			this.state = 2664;
			this.expression();
			this.state = 2669;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 342, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2665;
					this.match(SparkSqlParser.COMMA);
					this.state = 2666;
					this.expression();
					}
					}
				}
				this.state = 2671;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 342, this._ctx);
			}
			this.state = 2672;
			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, 220, SparkSqlParser.RULE_functionTableSubqueryArgument);
		let _la: number;
		try {
			this.state = 2693;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 346, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2674;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 2675;
				this.tableName();
				this.state = 2677;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
					{
					this.state = 2676;
					this.tableArgumentPartitioning();
					}
				}

				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2679;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 2680;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2681;
				this.tableName();
				this.state = 2682;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2684;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
					{
					this.state = 2683;
					this.tableArgumentPartitioning();
					}
				}

				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 2686;
				this.match(SparkSqlParser.KW_TABLE);
				this.state = 2687;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2688;
				this.query();
				this.state = 2689;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 2691;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION || _la === SparkSqlParser.KW_WITH) {
					{
					this.state = 2690;
					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, 222, SparkSqlParser.RULE_tableArgumentPartitioning);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2714;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_WITH:
				{
				{
				this.state = 2695;
				this.match(SparkSqlParser.KW_WITH);
				this.state = 2696;
				this.match(SparkSqlParser.KW_SINGLE);
				this.state = 2697;
				this.match(SparkSqlParser.KW_PARTITION);
				}
				}
				break;
			case SparkSqlParser.KW_DISTRIBUTE:
			case SparkSqlParser.KW_PARTITION:
				{
				{
				this.state = 2698;
				_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 = 2699;
				this.match(SparkSqlParser.KW_BY);
				this.state = 2712;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 348, this._ctx) ) {
				case 1:
					{
					{
					{
					this.state = 2700;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2701;
					_localctx._expression = this.expression();
					_localctx._partition.push(_localctx._expression);
					this.state = 2706;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2702;
						this.match(SparkSqlParser.COMMA);
						this.state = 2703;
						_localctx._expression = this.expression();
						_localctx._partition.push(_localctx._expression);
						}
						}
						this.state = 2708;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 2709;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					}
					break;

				case 2:
					{
					this.state = 2711;
					_localctx._expression = this.expression();
					_localctx._partition.push(_localctx._expression);
					}
					break;
				}
				}
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			this.state = 2732;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT) {
				{
				this.state = 2716;
				_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 = 2717;
				this.match(SparkSqlParser.KW_BY);
				{
				this.state = 2730;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 351, this._ctx) ) {
				case 1:
					{
					{
					this.state = 2718;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 2719;
					this.sortItem();
					this.state = 2724;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 2720;
						this.match(SparkSqlParser.COMMA);
						this.state = 2721;
						this.sortItem();
						}
						}
						this.state = 2726;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 2727;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					}
					break;

				case 2:
					{
					this.state = 2729;
					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, 224, SparkSqlParser.RULE_functionTableNamedArgumentExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2734;
			_localctx._key = this.identifier();
			this.state = 2735;
			this.match(SparkSqlParser.FAT_ARROW);
			this.state = 2736;
			_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, 226, SparkSqlParser.RULE_functionTableReferenceArgument);
		try {
			this.state = 2740;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 353, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2738;
				this.functionTableSubqueryArgument();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2739;
				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, 228, SparkSqlParser.RULE_functionTableArgument);
		try {
			this.state = 2744;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 354, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2742;
				this.functionTableReferenceArgument();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2743;
				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, 230, SparkSqlParser.RULE_functionTable);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2746;
			this.functionName();
			this.state = 2747;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2756;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 356, this._ctx) ) {
			case 1:
				{
				this.state = 2748;
				this.functionTableArgument();
				this.state = 2753;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2749;
					this.match(SparkSqlParser.COMMA);
					this.state = 2750;
					this.functionTableArgument();
					}
					}
					this.state = 2755;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				}
				break;
			}
			this.state = 2758;
			this.match(SparkSqlParser.RIGHT_PAREN);
			this.state = 2759;
			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, 232, SparkSqlParser.RULE_tableAlias);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2768;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 359, this._ctx) ) {
			case 1:
				{
				this.state = 2762;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 357, this._ctx) ) {
				case 1:
					{
					this.state = 2761;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2764;
				this.strictIdentifier();
				this.state = 2766;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 358, this._ctx) ) {
				case 1:
					{
					this.state = 2765;
					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, 234, SparkSqlParser.RULE_rowFormat);
		try {
			this.state = 2819;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 367, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2770;
				this.match(SparkSqlParser.KW_ROW);
				this.state = 2771;
				this.match(SparkSqlParser.KW_FORMAT);
				this.state = 2772;
				this.match(SparkSqlParser.KW_SERDE);
				this.state = 2773;
				_localctx._name = this.stringLit();
				this.state = 2777;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 360, this._ctx) ) {
				case 1:
					{
					this.state = 2774;
					this.match(SparkSqlParser.KW_WITH);
					this.state = 2775;
					this.match(SparkSqlParser.KW_SERDEPROPERTIES);
					this.state = 2776;
					_localctx._props = this.propertyList();
					}
					break;
				}
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2779;
				this.match(SparkSqlParser.KW_ROW);
				this.state = 2780;
				this.match(SparkSqlParser.KW_FORMAT);
				this.state = 2781;
				this.match(SparkSqlParser.KW_DELIMITED);
				this.state = 2791;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 362, this._ctx) ) {
				case 1:
					{
					this.state = 2782;
					this.match(SparkSqlParser.KW_FIELDS);
					this.state = 2783;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2784;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2785;
					_localctx._fieldsTerminatedBy = this.stringLit();
					this.state = 2789;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 361, this._ctx) ) {
					case 1:
						{
						this.state = 2786;
						this.match(SparkSqlParser.KW_ESCAPED);
						this.state = 2787;
						this.match(SparkSqlParser.KW_BY);
						this.state = 2788;
						_localctx._escapedBy = this.stringLit();
						}
						break;
					}
					}
					break;
				}
				this.state = 2798;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 363, this._ctx) ) {
				case 1:
					{
					this.state = 2793;
					this.match(SparkSqlParser.KW_COLLECTION);
					this.state = 2794;
					this.match(SparkSqlParser.KW_ITEMS);
					this.state = 2795;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2796;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2797;
					_localctx._collectionItemsTerminatedBy = this.stringLit();
					}
					break;
				}
				this.state = 2805;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 364, this._ctx) ) {
				case 1:
					{
					this.state = 2800;
					this.match(SparkSqlParser.KW_MAP);
					this.state = 2801;
					this.match(SparkSqlParser.KW_KEYS);
					this.state = 2802;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2803;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2804;
					_localctx._keysTerminatedBy = this.stringLit();
					}
					break;
				}
				this.state = 2811;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 365, this._ctx) ) {
				case 1:
					{
					this.state = 2807;
					this.match(SparkSqlParser.KW_LINES);
					this.state = 2808;
					this.match(SparkSqlParser.KW_TERMINATED);
					this.state = 2809;
					this.match(SparkSqlParser.KW_BY);
					this.state = 2810;
					_localctx._linesSeparatedBy = this.stringLit();
					}
					break;
				}
				this.state = 2817;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 366, this._ctx) ) {
				case 1:
					{
					this.state = 2813;
					this.match(SparkSqlParser.KW_NULL);
					this.state = 2814;
					this.match(SparkSqlParser.KW_DEFINED);
					this.state = 2815;
					this.match(SparkSqlParser.KW_AS);
					this.state = 2816;
					_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, 236, SparkSqlParser.RULE_multipartIdentifierList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2821;
			this.multipartIdentifier();
			this.state = 2826;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2822;
				this.match(SparkSqlParser.COMMA);
				this.state = 2823;
				this.multipartIdentifier();
				}
				}
				this.state = 2828;
				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, 238, SparkSqlParser.RULE_multipartIdentifier);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2829;
			_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
			_localctx._parts.push(_localctx._errorCapturingIdentifier);
			this.state = 2834;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 369, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2830;
					this.match(SparkSqlParser.DOT);
					this.state = 2831;
					_localctx._errorCapturingIdentifier = this.errorCapturingIdentifier();
					_localctx._parts.push(_localctx._errorCapturingIdentifier);
					}
					}
				}
				this.state = 2836;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 369, 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, 240, SparkSqlParser.RULE_multipartIdentifierPropertyList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2837;
			this.multipartIdentifierProperty();
			this.state = 2842;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2838;
				this.match(SparkSqlParser.COMMA);
				this.state = 2839;
				this.multipartIdentifierProperty();
				}
				}
				this.state = 2844;
				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, 242, SparkSqlParser.RULE_multipartIdentifierProperty);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2845;
			this.multipartIdentifier();
			this.state = 2848;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_OPTIONS) {
				{
				this.state = 2846;
				this.match(SparkSqlParser.KW_OPTIONS);
				this.state = 2847;
				_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, 244, SparkSqlParser.RULE_tableIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2853;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 372, this._ctx) ) {
			case 1:
				{
				this.state = 2850;
				_localctx._db = this.errorCapturingIdentifier();
				this.state = 2851;
				this.match(SparkSqlParser.DOT);
				}
				break;
			}
			this.state = 2855;
			_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, 246, SparkSqlParser.RULE_viewIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2860;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 373, this._ctx) ) {
			case 1:
				{
				this.state = 2857;
				_localctx._db = this.errorCapturingIdentifier();
				this.state = 2858;
				this.match(SparkSqlParser.DOT);
				}
				break;
			}
			this.state = 2862;
			_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, 248, SparkSqlParser.RULE_namedExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2864;
			this.expression();
			this.state = 2872;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 376, this._ctx) ) {
			case 1:
				{
				this.state = 2866;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 374, this._ctx) ) {
				case 1:
					{
					this.state = 2865;
					this.match(SparkSqlParser.KW_AS);
					}
					break;
				}
				this.state = 2870;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 375, this._ctx) ) {
				case 1:
					{
					this.state = 2868;
					_localctx._name = this.errorCapturingIdentifier();
					}
					break;

				case 2:
					{
					this.state = 2869;
					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 namedExpressionSeq(): NamedExpressionSeqContext {
		let _localctx: NamedExpressionSeqContext = new NamedExpressionSeqContext(this._ctx, this.state);
		this.enterRule(_localctx, 250, SparkSqlParser.RULE_namedExpressionSeq);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2874;
			this.namedExpression();
			this.state = 2879;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 377, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 2875;
					this.match(SparkSqlParser.COMMA);
					this.state = 2876;
					this.namedExpression();
					}
					}
				}
				this.state = 2881;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 377, 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, 252, SparkSqlParser.RULE_partitionFieldList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2882;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 2883;
			_localctx._partitionField = this.partitionField();
			_localctx._fields.push(_localctx._partitionField);
			this.state = 2888;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2884;
				this.match(SparkSqlParser.COMMA);
				this.state = 2885;
				_localctx._partitionField = this.partitionField();
				_localctx._fields.push(_localctx._partitionField);
				}
				}
				this.state = 2890;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
			}
			this.state = 2891;
			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, 254, SparkSqlParser.RULE_partitionField);
		try {
			this.state = 2895;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 379, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2893;
				this.transform();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2894;
				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, 256, SparkSqlParser.RULE_transform);
		let _la: number;
		try {
			this.state = 2910;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 381, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2897;
				this.qualifiedName();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2898;
				_localctx._transformName = this.identifier();
				this.state = 2899;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2900;
				this.transformArgument();
				this.state = 2905;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2901;
					this.match(SparkSqlParser.COMMA);
					this.state = 2902;
					this.transformArgument();
					}
					}
					this.state = 2907;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2908;
				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, 258, SparkSqlParser.RULE_transformArgument);
		try {
			this.state = 2914;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 382, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2912;
				this.qualifiedName();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2913;
				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, 260, SparkSqlParser.RULE_expression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2916;
			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, 262, SparkSqlParser.RULE_namedArgumentExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2918;
			_localctx._key = this.identifier();
			this.state = 2919;
			this.match(SparkSqlParser.FAT_ARROW);
			this.state = 2920;
			_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, 264, SparkSqlParser.RULE_functionArgument);
		try {
			this.state = 2924;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 383, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2922;
				this.expression();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 2923;
				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, 266, SparkSqlParser.RULE_expressionSeq);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2926;
			this.expression();
			this.state = 2931;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 2927;
				this.match(SparkSqlParser.COMMA);
				this.state = 2928;
				this.expression();
				}
				}
				this.state = 2933;
				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 = 268;
		this.enterRecursionRule(_localctx, 268, SparkSqlParser.RULE_booleanExpression, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 2946;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 386, this._ctx) ) {
			case 1:
				{
				this.state = 2935;
				_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 = 2936;
				this.booleanExpression(5);
				}
				break;

			case 2:
				{
				this.state = 2937;
				this.match(SparkSqlParser.KW_EXISTS);
				this.state = 2938;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2939;
				this.query();
				this.state = 2940;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				{
				this.state = 2942;
				this.valueExpression(0);
				this.state = 2944;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 385, this._ctx) ) {
				case 1:
					{
					this.state = 2943;
					this.predicate();
					}
					break;
				}
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 2956;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 388, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 2954;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 387, this._ctx) ) {
					case 1:
						{
						_localctx = new BooleanExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_booleanExpression);
						this.state = 2948;
						if (!(this.precpred(this._ctx, 2))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
						}
						this.state = 2949;
						_localctx._operator = this.match(SparkSqlParser.KW_AND);
						this.state = 2950;
						_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 = 2951;
						if (!(this.precpred(this._ctx, 1))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
						}
						this.state = 2952;
						_localctx._operator = this.match(SparkSqlParser.KW_OR);
						this.state = 2953;
						_localctx._right = this.booleanExpression(2);
						}
						break;
					}
					}
				}
				this.state = 2958;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 388, 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, 270, SparkSqlParser.RULE_predicate);
		let _la: number;
		try {
			this.state = 3041;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 402, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 2960;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 2959;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 2962;
				_localctx._kind = this.match(SparkSqlParser.KW_BETWEEN);
				this.state = 2963;
				_localctx._lower = this.valueExpression(0);
				this.state = 2964;
				this.match(SparkSqlParser.KW_AND);
				this.state = 2965;
				_localctx._upper = this.valueExpression(0);
				}
				break;

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

				this.state = 2970;
				_localctx._kind = this.match(SparkSqlParser.KW_IN);
				this.state = 2971;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2972;
				this.expression();
				this.state = 2977;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				while (_la === SparkSqlParser.COMMA) {
					{
					{
					this.state = 2973;
					this.match(SparkSqlParser.COMMA);
					this.state = 2974;
					this.expression();
					}
					}
					this.state = 2979;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				}
				this.state = 2980;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

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

				this.state = 2985;
				_localctx._kind = this.match(SparkSqlParser.KW_IN);
				this.state = 2986;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 2987;
				this.query();
				this.state = 2988;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

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

				this.state = 2993;
				_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 = 2994;
				_localctx._pattern = this.valueExpression(0);
				}
				break;

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

				this.state = 2998;
				_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 = 2999;
				_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 = 3013;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 396, this._ctx) ) {
				case 1:
					{
					this.state = 3000;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3001;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;

				case 2:
					{
					this.state = 3002;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3003;
					this.expression();
					this.state = 3008;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3004;
						this.match(SparkSqlParser.COMMA);
						this.state = 3005;
						this.expression();
						}
						}
						this.state = 3010;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 3011;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				}
				break;

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

				this.state = 3018;
				_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 = 3019;
				_localctx._pattern = this.valueExpression(0);
				this.state = 3022;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 398, this._ctx) ) {
				case 1:
					{
					this.state = 3020;
					this.match(SparkSqlParser.KW_ESCAPE);
					this.state = 3021;
					_localctx._escapeChar = this.stringLit();
					}
					break;
				}
				}
				break;

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

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

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

				this.state = 3033;
				_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 = 3034;
				this.match(SparkSqlParser.KW_IS);
				this.state = 3036;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_NOT) {
					{
					this.state = 3035;
					this.match(SparkSqlParser.KW_NOT);
					}
				}

				this.state = 3038;
				_localctx._kind = this.match(SparkSqlParser.KW_DISTINCT);
				this.state = 3039;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3040;
				_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 = 272;
		this.enterRecursionRule(_localctx, 272, SparkSqlParser.RULE_valueExpression, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3047;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 403, this._ctx) ) {
			case 1:
				{
				this.state = 3044;
				this.primaryExpression(0);
				}
				break;

			case 2:
				{
				this.state = 3045;
				_localctx._operator = this._input.LT(1);
				_la = this._input.LA(1);
				if (!(((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.TILDE - 353)))) !== 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 = 3046;
				this.valueExpression(7);
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 3070;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 405, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 3068;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 404, this._ctx) ) {
					case 1:
						{
						_localctx = new ValueExpressionContext(_parentctx, _parentState);
						_localctx._left = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_valueExpression);
						this.state = 3049;
						if (!(this.precpred(this._ctx, 6))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 6)");
						}
						this.state = 3050;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(_la === SparkSqlParser.KW_DIV || ((((_la - 355)) & ~0x1F) === 0 && ((1 << (_la - 355)) & ((1 << (SparkSqlParser.ASTERISK - 355)) | (1 << (SparkSqlParser.SLASH - 355)) | (1 << (SparkSqlParser.PERCENT - 355)))) !== 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 = 3051;
						_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 = 3052;
						if (!(this.precpred(this._ctx, 5))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 5)");
						}
						this.state = 3053;
						_localctx._operator = this._input.LT(1);
						_la = this._input.LA(1);
						if (!(((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.CONCAT_PIPE - 353)))) !== 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 = 3054;
						_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 = 3055;
						if (!(this.precpred(this._ctx, 4))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 4)");
						}
						this.state = 3056;
						_localctx._operator = this.match(SparkSqlParser.AMPERSAND);
						this.state = 3057;
						_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 = 3058;
						if (!(this.precpred(this._ctx, 3))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 3)");
						}
						this.state = 3059;
						_localctx._operator = this.match(SparkSqlParser.HAT);
						this.state = 3060;
						_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 = 3061;
						if (!(this.precpred(this._ctx, 2))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
						}
						this.state = 3062;
						_localctx._operator = this.match(SparkSqlParser.PIPE);
						this.state = 3063;
						_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 = 3064;
						if (!(this.precpred(this._ctx, 1))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
						}
						this.state = 3065;
						this.comparisonOperator();
						this.state = 3066;
						_localctx._right = this.valueExpression(2);
						}
						break;
					}
					}
				}
				this.state = 3072;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 405, 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, 274, SparkSqlParser.RULE_datetimeUnit);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3073;
			_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 = 276;
		this.enterRecursionRule(_localctx, 276, SparkSqlParser.RULE_primaryExpression, _p);
		let _la: number;
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3324;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 431, this._ctx) ) {
			case 1:
				{
				this.state = 3076;
				_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 = 3077;
				_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 = 3078;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3081;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 406, this._ctx) ) {
				case 1:
					{
					this.state = 3079;
					_localctx._unit = this.datetimeUnit();
					}
					break;

				case 2:
					{
					this.state = 3080;
					_localctx._invalidUnit = this.stringLit();
					}
					break;
				}
				this.state = 3083;
				this.match(SparkSqlParser.COMMA);
				this.state = 3084;
				_localctx._unitsAmount = this.valueExpression(0);
				this.state = 3085;
				this.match(SparkSqlParser.COMMA);
				this.state = 3086;
				_localctx._timestamp = this.valueExpression(0);
				this.state = 3087;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				{
				this.state = 3089;
				_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 = 3090;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3093;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 407, this._ctx) ) {
				case 1:
					{
					this.state = 3091;
					_localctx._unit = this.datetimeUnit();
					}
					break;

				case 2:
					{
					this.state = 3092;
					_localctx._invalidUnit = this.stringLit();
					}
					break;
				}
				this.state = 3095;
				this.match(SparkSqlParser.COMMA);
				this.state = 3096;
				_localctx._startTimestamp = this.valueExpression(0);
				this.state = 3097;
				this.match(SparkSqlParser.COMMA);
				this.state = 3098;
				_localctx._endTimestamp = this.valueExpression(0);
				this.state = 3099;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 4:
				{
				this.state = 3101;
				this.match(SparkSqlParser.KW_CASE);
				this.state = 3103;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3102;
					this.whenClause();
					}
					}
					this.state = 3105;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.KW_WHEN);
				this.state = 3109;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ELSE) {
					{
					this.state = 3107;
					this.match(SparkSqlParser.KW_ELSE);
					this.state = 3108;
					_localctx._elseExpression = this.expression();
					}
				}

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

			case 5:
				{
				this.state = 3113;
				this.match(SparkSqlParser.KW_CASE);
				this.state = 3114;
				this.expression();
				this.state = 3116;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3115;
					this.whenClause();
					}
					}
					this.state = 3118;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.KW_WHEN);
				this.state = 3122;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_ELSE) {
					{
					this.state = 3120;
					this.match(SparkSqlParser.KW_ELSE);
					this.state = 3121;
					_localctx._elseExpression = this.expression();
					}
				}

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

			case 6:
				{
				this.state = 3126;
				_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 = 3127;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3128;
				this.expression();
				this.state = 3129;
				this.match(SparkSqlParser.KW_AS);
				this.state = 3130;
				this.dataType();
				this.state = 3131;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 7:
				{
				this.state = 3133;
				this.match(SparkSqlParser.KW_STRUCT);
				this.state = 3134;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3143;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 413, this._ctx) ) {
				case 1:
					{
					this.state = 3135;
					this.namedExpression();
					this.state = 3140;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3136;
						this.match(SparkSqlParser.COMMA);
						this.state = 3137;
						this.namedExpression();
						}
						}
						this.state = 3142;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
					break;
				}
				this.state = 3145;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 8:
				{
				this.state = 3146;
				this.match(SparkSqlParser.KW_FIRST);
				this.state = 3147;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3148;
				this.expression();
				this.state = 3151;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IGNORE) {
					{
					this.state = 3149;
					this.match(SparkSqlParser.KW_IGNORE);
					this.state = 3150;
					this.match(SparkSqlParser.KW_NULLS);
					}
				}

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

			case 9:
				{
				this.state = 3155;
				this.match(SparkSqlParser.KW_ANY_VALUE);
				this.state = 3156;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3157;
				this.expression();
				this.state = 3160;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IGNORE) {
					{
					this.state = 3158;
					this.match(SparkSqlParser.KW_IGNORE);
					this.state = 3159;
					this.match(SparkSqlParser.KW_NULLS);
					}
				}

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

			case 10:
				{
				this.state = 3164;
				this.match(SparkSqlParser.KW_LAST);
				this.state = 3165;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3166;
				this.expression();
				this.state = 3169;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_IGNORE) {
					{
					this.state = 3167;
					this.match(SparkSqlParser.KW_IGNORE);
					this.state = 3168;
					this.match(SparkSqlParser.KW_NULLS);
					}
				}

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

			case 11:
				{
				this.state = 3173;
				this.match(SparkSqlParser.KW_POSITION);
				this.state = 3174;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3175;
				_localctx._substr = this.valueExpression(0);
				this.state = 3176;
				this.match(SparkSqlParser.KW_IN);
				this.state = 3177;
				_localctx._str = this.valueExpression(0);
				this.state = 3178;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

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

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

			case 14:
				{
				this.state = 3182;
				this.qualifiedName();
				this.state = 3183;
				this.match(SparkSqlParser.DOT);
				this.state = 3184;
				this.match(SparkSqlParser.ASTERISK);
				}
				break;

			case 15:
				{
				this.state = 3186;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3187;
				this.namedExpression();
				this.state = 3190;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3188;
					this.match(SparkSqlParser.COMMA);
					this.state = 3189;
					this.namedExpression();
					}
					}
					this.state = 3192;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.COMMA);
				this.state = 3194;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 16:
				{
				this.state = 3196;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3197;
				this.query();
				this.state = 3198;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 17:
				{
				this.state = 3200;
				this.match(SparkSqlParser.KW_IDENTIFIER_KW);
				this.state = 3201;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3202;
				this.expression();
				this.state = 3203;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 18:
				{
				this.state = 3205;
				this.functionName();
				this.state = 3206;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3218;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 420, this._ctx) ) {
				case 1:
					{
					this.state = 3208;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 418, this._ctx) ) {
					case 1:
						{
						this.state = 3207;
						this.setQuantifier();
						}
						break;
					}
					this.state = 3210;
					this.functionArgument();
					this.state = 3215;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3211;
						this.match(SparkSqlParser.COMMA);
						this.state = 3212;
						this.functionArgument();
						}
						}
						this.state = 3217;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					}
					break;
				}
				this.state = 3220;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3227;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 421, this._ctx) ) {
				case 1:
					{
					this.state = 3221;
					this.match(SparkSqlParser.KW_FILTER);
					this.state = 3222;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3223;
					this.match(SparkSqlParser.KW_WHERE);
					this.state = 3224;
					_localctx._where = this.booleanExpression(0);
					this.state = 3225;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 3231;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 422, this._ctx) ) {
				case 1:
					{
					this.state = 3229;
					_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 = 3230;
					this.match(SparkSqlParser.KW_NULLS);
					}
					break;
				}
				this.state = 3235;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 423, this._ctx) ) {
				case 1:
					{
					this.state = 3233;
					this.match(SparkSqlParser.KW_OVER);
					this.state = 3234;
					this.windowSpec();
					}
					break;
				}
				}
				break;

			case 19:
				{
				this.state = 3237;
				this.identifier();
				this.state = 3238;
				this.match(SparkSqlParser.ARROW);
				this.state = 3239;
				this.expression();
				}
				break;

			case 20:
				{
				this.state = 3241;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3242;
				this.identifier();
				this.state = 3245;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				do {
					{
					{
					this.state = 3243;
					this.match(SparkSqlParser.COMMA);
					this.state = 3244;
					this.identifier();
					}
					}
					this.state = 3247;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
				} while (_la === SparkSqlParser.COMMA);
				this.state = 3249;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3250;
				this.match(SparkSqlParser.ARROW);
				this.state = 3251;
				this.expression();
				}
				break;

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

			case 22:
				{
				this.state = 3254;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3255;
				this.expression();
				this.state = 3256;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 23:
				{
				this.state = 3258;
				this.match(SparkSqlParser.KW_EXTRACT);
				this.state = 3259;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3260;
				_localctx._field = this.identifier();
				this.state = 3261;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3262;
				_localctx._source = this.valueExpression(0);
				this.state = 3263;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 24:
				{
				this.state = 3265;
				_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 = 3266;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3267;
				_localctx._str = this.valueExpression(0);
				this.state = 3268;
				_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 = 3269;
				_localctx._pos = this.valueExpression(0);
				this.state = 3272;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.COMMA || _la === SparkSqlParser.KW_FOR) {
					{
					this.state = 3270;
					_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 = 3271;
					_localctx._len = this.valueExpression(0);
					}
				}

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

			case 25:
				{
				this.state = 3276;
				this.match(SparkSqlParser.KW_TRIM);
				this.state = 3277;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3279;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 426, this._ctx) ) {
				case 1:
					{
					this.state = 3278;
					_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 = 3282;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 427, this._ctx) ) {
				case 1:
					{
					this.state = 3281;
					_localctx._trimStr = this.valueExpression(0);
					}
					break;
				}
				this.state = 3284;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3285;
				_localctx._srcStr = this.valueExpression(0);
				this.state = 3286;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 26:
				{
				this.state = 3288;
				this.match(SparkSqlParser.KW_OVERLAY);
				this.state = 3289;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3290;
				_localctx._input = this.valueExpression(0);
				this.state = 3291;
				this.match(SparkSqlParser.KW_PLACING);
				this.state = 3292;
				_localctx._replace = this.valueExpression(0);
				this.state = 3293;
				this.match(SparkSqlParser.KW_FROM);
				this.state = 3294;
				_localctx._position = this.valueExpression(0);
				this.state = 3297;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.KW_FOR) {
					{
					this.state = 3295;
					this.match(SparkSqlParser.KW_FOR);
					this.state = 3296;
					_localctx._length = this.valueExpression(0);
					}
				}

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

			case 27:
				{
				this.state = 3301;
				_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 = 3302;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3303;
				_localctx._percentage = this.valueExpression(0);
				this.state = 3304;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3305;
				this.match(SparkSqlParser.KW_WITHIN);
				this.state = 3306;
				this.match(SparkSqlParser.KW_GROUP);
				this.state = 3307;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3308;
				this.match(SparkSqlParser.KW_ORDER);
				this.state = 3309;
				this.match(SparkSqlParser.KW_BY);
				this.state = 3310;
				this.sortItem();
				this.state = 3311;
				this.match(SparkSqlParser.RIGHT_PAREN);
				this.state = 3318;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 429, this._ctx) ) {
				case 1:
					{
					this.state = 3312;
					this.match(SparkSqlParser.KW_FILTER);
					this.state = 3313;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3314;
					this.match(SparkSqlParser.KW_WHERE);
					this.state = 3315;
					_localctx._where = this.booleanExpression(0);
					this.state = 3316;
					this.match(SparkSqlParser.RIGHT_PAREN);
					}
					break;
				}
				this.state = 3322;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 430, this._ctx) ) {
				case 1:
					{
					this.state = 3320;
					this.match(SparkSqlParser.KW_OVER);
					this.state = 3321;
					this.windowSpec();
					}
					break;
				}
				}
				break;
			}
			this._ctx._stop = this._input.tryLT(-1);
			this.state = 3336;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 433, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					if (this._parseListeners != null) {
						this.triggerExitRuleEvent();
					}
					_prevctx = _localctx;
					{
					this.state = 3334;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 432, this._ctx) ) {
					case 1:
						{
						_localctx = new PrimaryExpressionContext(_parentctx, _parentState);
						_localctx._value = _prevctx;
						this.pushNewRecursionContext(_localctx, _startState, SparkSqlParser.RULE_primaryExpression);
						this.state = 3326;
						if (!(this.precpred(this._ctx, 9))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 9)");
						}
						this.state = 3327;
						this.match(SparkSqlParser.LEFT_BRACKET);
						this.state = 3328;
						_localctx._index = this.valueExpression(0);
						this.state = 3329;
						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 = 3331;
						if (!(this.precpred(this._ctx, 7))) {
							throw this.createFailedPredicateException("this.precpred(this._ctx, 7)");
						}
						this.state = 3332;
						this.match(SparkSqlParser.DOT);
						this.state = 3333;
						_localctx._fieldName = this.identifier();
						}
						break;
					}
					}
				}
				this.state = 3338;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 433, 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, 278, SparkSqlParser.RULE_literalType);
		try {
			this.state = 3346;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 434, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3339;
				this.match(SparkSqlParser.KW_DATE);
				}
				break;

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

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

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

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

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

			case 7:
				this.enterOuterAlt(_localctx, 7);
				{
				this.state = 3345;
				_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, 280, SparkSqlParser.RULE_constant);
		try {
			let _alt: number;
			this.state = 3363;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 436, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3348;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;

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

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

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

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

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

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

			case 8:
				this.enterOuterAlt(_localctx, 8);
				{
				this.state = 3359;
				this._errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						this.state = 3358;
						this.stringLit();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					this.state = 3361;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 435, 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, 282, SparkSqlParser.RULE_comparisonOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3365;
			_la = this._input.LA(1);
			if (!(((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (SparkSqlParser.EQ - 344)) | (1 << (SparkSqlParser.NSEQ - 344)) | (1 << (SparkSqlParser.NEQ - 344)) | (1 << (SparkSqlParser.NEQJ - 344)) | (1 << (SparkSqlParser.LT - 344)) | (1 << (SparkSqlParser.LTE - 344)) | (1 << (SparkSqlParser.GT - 344)) | (1 << (SparkSqlParser.GTE - 344)))) !== 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, 284, SparkSqlParser.RULE_arithmeticOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3367;
			_la = this._input.LA(1);
			if (!(_la === SparkSqlParser.KW_DIV || ((((_la - 353)) & ~0x1F) === 0 && ((1 << (_la - 353)) & ((1 << (SparkSqlParser.PLUS - 353)) | (1 << (SparkSqlParser.MINUS - 353)) | (1 << (SparkSqlParser.ASTERISK - 353)) | (1 << (SparkSqlParser.SLASH - 353)) | (1 << (SparkSqlParser.PERCENT - 353)) | (1 << (SparkSqlParser.TILDE - 353)) | (1 << (SparkSqlParser.AMPERSAND - 353)) | (1 << (SparkSqlParser.PIPE - 353)) | (1 << (SparkSqlParser.CONCAT_PIPE - 353)) | (1 << (SparkSqlParser.HAT - 353)))) !== 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, 286, SparkSqlParser.RULE_predicateOperator);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3369;
			_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, 288, SparkSqlParser.RULE_booleanValue);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3371;
			_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, 290, SparkSqlParser.RULE_interval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3373;
			this.match(SparkSqlParser.KW_INTERVAL);
			this.state = 3376;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 437, this._ctx) ) {
			case 1:
				{
				this.state = 3374;
				this.errorCapturingMultiUnitsInterval();
				}
				break;

			case 2:
				{
				this.state = 3375;
				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, 292, SparkSqlParser.RULE_errorCapturingMultiUnitsInterval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3378;
			_localctx._body = this.multiUnitsInterval();
			this.state = 3380;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 438, this._ctx) ) {
			case 1:
				{
				this.state = 3379;
				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, 294, SparkSqlParser.RULE_multiUnitsInterval);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3385;
			this._errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					this.state = 3382;
					this.intervalValue();
					this.state = 3383;
					_localctx._unitInMultiUnits = this.unitInMultiUnits();
					_localctx._unit.push(_localctx._unitInMultiUnits);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				this.state = 3387;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 439, 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, 296, SparkSqlParser.RULE_errorCapturingUnitToUnitInterval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3389;
			_localctx._body = this.unitToUnitInterval();
			this.state = 3392;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 440, this._ctx) ) {
			case 1:
				{
				this.state = 3390;
				_localctx._error1 = this.multiUnitsInterval();
				}
				break;

			case 2:
				{
				this.state = 3391;
				_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, 298, SparkSqlParser.RULE_unitToUnitInterval);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3394;
			_localctx._value = this.intervalValue();
			this.state = 3395;
			this.unitInUnitToUnit();
			this.state = 3396;
			this.match(SparkSqlParser.KW_TO);
			this.state = 3397;
			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, 300, SparkSqlParser.RULE_intervalValue);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3400;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 441, this._ctx) ) {
			case 1:
				{
				this.state = 3399;
				_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();
				}
				}
				break;
			}
			this.state = 3405;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 442, this._ctx) ) {
			case 1:
				{
				this.state = 3402;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;

			case 2:
				{
				this.state = 3403;
				this.match(SparkSqlParser.DECIMAL_VALUE);
				}
				break;

			case 3:
				{
				this.state = 3404;
				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 unitInMultiUnits(): UnitInMultiUnitsContext {
		let _localctx: UnitInMultiUnitsContext = new UnitInMultiUnitsContext(this._ctx, this.state);
		this.enterRule(_localctx, 302, SparkSqlParser.RULE_unitInMultiUnits);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3407;
			_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 - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (SparkSqlParser.KW_WEEK - 334)) | (1 << (SparkSqlParser.KW_WEEKS - 334)) | (1 << (SparkSqlParser.KW_YEAR - 334)) | (1 << (SparkSqlParser.KW_YEARS - 334)))) !== 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, 304, SparkSqlParser.RULE_unitInUnitToUnit);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3409;
			_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, 306, SparkSqlParser.RULE_colPosition);
		try {
			this.state = 3414;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_FIRST:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3411;
				_localctx._position = this.match(SparkSqlParser.KW_FIRST);
				}
				break;
			case SparkSqlParser.KW_AFTER:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3412;
				_localctx._position = this.match(SparkSqlParser.KW_AFTER);
				this.state = 3413;
				_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, 308, SparkSqlParser.RULE_type);
		try {
			this.state = 3446;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 444, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3416;
				this.match(SparkSqlParser.KW_BOOLEAN);
				}
				break;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

			case 30:
				this.enterOuterAlt(_localctx, 30);
				{
				this.state = 3445;
				_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, 310, SparkSqlParser.RULE_dataType);
		let _la: number;
		try {
			this.state = 3494;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 451, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3448;
				_localctx._complex = this.match(SparkSqlParser.KW_ARRAY);
				this.state = 3449;
				this.match(SparkSqlParser.LT);
				this.state = 3450;
				this.dataType();
				this.state = 3451;
				this.match(SparkSqlParser.GT);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3453;
				_localctx._complex = this.match(SparkSqlParser.KW_MAP);
				this.state = 3454;
				this.match(SparkSqlParser.LT);
				this.state = 3455;
				this.dataType();
				this.state = 3456;
				this.match(SparkSqlParser.COMMA);
				this.state = 3457;
				this.dataType();
				this.state = 3458;
				this.match(SparkSqlParser.GT);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3460;
				_localctx._complex = this.match(SparkSqlParser.KW_STRUCT);
				this.state = 3467;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.LT:
					{
					this.state = 3461;
					this.match(SparkSqlParser.LT);
					this.state = 3463;
					this._errHandler.sync(this);
					switch ( this.interpreter.adaptivePredict(this._input, 445, this._ctx) ) {
					case 1:
						{
						this.state = 3462;
						this.complexColTypeList();
						}
						break;
					}
					this.state = 3465;
					this.match(SparkSqlParser.GT);
					}
					break;
				case SparkSqlParser.NEQ:
					{
					this.state = 3466;
					this.match(SparkSqlParser.NEQ);
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3469;
				this.match(SparkSqlParser.KW_INTERVAL);
				this.state = 3470;
				_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 = 3473;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 447, this._ctx) ) {
				case 1:
					{
					this.state = 3471;
					this.match(SparkSqlParser.KW_TO);
					this.state = 3472;
					this.match(SparkSqlParser.KW_MONTH);
					}
					break;
				}
				}
				break;

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3475;
				this.match(SparkSqlParser.KW_INTERVAL);
				this.state = 3476;
				_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 = 3479;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 448, this._ctx) ) {
				case 1:
					{
					this.state = 3477;
					this.match(SparkSqlParser.KW_TO);
					this.state = 3478;
					_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 = 3481;
				this.type();
				this.state = 3492;
				this._errHandler.sync(this);
				switch ( this.interpreter.adaptivePredict(this._input, 450, this._ctx) ) {
				case 1:
					{
					this.state = 3482;
					this.match(SparkSqlParser.LEFT_PAREN);
					this.state = 3483;
					this.match(SparkSqlParser.INTEGER_VALUE);
					this.state = 3488;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3484;
						this.match(SparkSqlParser.COMMA);
						this.state = 3485;
						this.match(SparkSqlParser.INTEGER_VALUE);
						}
						}
						this.state = 3490;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
					}
					this.state = 3491;
					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 qualifiedColTypeWithPositionList(): QualifiedColTypeWithPositionListContext {
		let _localctx: QualifiedColTypeWithPositionListContext = new QualifiedColTypeWithPositionListContext(this._ctx, this.state);
		this.enterRule(_localctx, 312, SparkSqlParser.RULE_qualifiedColTypeWithPositionList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3496;
			this.qualifiedColTypeWithPosition();
			this.state = 3501;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3497;
				this.match(SparkSqlParser.COMMA);
				this.state = 3498;
				this.qualifiedColTypeWithPosition();
				}
				}
				this.state = 3503;
				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 qualifiedColTypeWithPosition(): QualifiedColTypeWithPositionContext {
		let _localctx: QualifiedColTypeWithPositionContext = new QualifiedColTypeWithPositionContext(this._ctx, this.state);
		this.enterRule(_localctx, 314, SparkSqlParser.RULE_qualifiedColTypeWithPosition);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3504;
			_localctx._name = this.multipartIdentifier();
			this.state = 3505;
			this.dataType();
			this.state = 3509;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 453, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3506;
					this.colDefinitionDescriptorWithPosition();
					}
					}
				}
				this.state = 3511;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 453, 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 colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext {
		let _localctx: ColDefinitionDescriptorWithPositionContext = new ColDefinitionDescriptorWithPositionContext(this._ctx, this.state);
		this.enterRule(_localctx, 316, SparkSqlParser.RULE_colDefinitionDescriptorWithPosition);
		try {
			this.state = 3517;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_NOT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3512;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3513;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			case SparkSqlParser.KW_DEFAULT:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3514;
				this.defaultExpression();
				}
				break;
			case SparkSqlParser.KW_COMMENT:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3515;
				this.commentSpec();
				}
				break;
			case SparkSqlParser.KW_AFTER:
			case SparkSqlParser.KW_FIRST:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3516;
				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, 318, SparkSqlParser.RULE_defaultExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3519;
			this.match(SparkSqlParser.KW_DEFAULT);
			this.state = 3520;
			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, 320, SparkSqlParser.RULE_variableDefaultExpression);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3522;
			_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 = 3523;
			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, 322, SparkSqlParser.RULE_colTypeList);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3525;
			this.colType();
			this.state = 3530;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 455, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3526;
					this.match(SparkSqlParser.COMMA);
					this.state = 3527;
					this.colType();
					}
					}
				}
				this.state = 3532;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 455, 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, 324, SparkSqlParser.RULE_colType);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3533;
			_localctx._colName = this.errorCapturingIdentifier();
			this.state = 3534;
			this.dataType();
			this.state = 3537;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 456, this._ctx) ) {
			case 1:
				{
				this.state = 3535;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3536;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			}
			this.state = 3540;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 457, this._ctx) ) {
			case 1:
				{
				this.state = 3539;
				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, 326, SparkSqlParser.RULE_createOrReplaceTableColTypeList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3542;
			this.createOrReplaceTableColType();
			this.state = 3547;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3543;
				this.match(SparkSqlParser.COMMA);
				this.state = 3544;
				this.createOrReplaceTableColType();
				}
				}
				this.state = 3549;
				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, 328, SparkSqlParser.RULE_createOrReplaceTableColType);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3550;
			_localctx._colName = this.errorCapturingIdentifier();
			this.state = 3551;
			this.dataType();
			this.state = 3555;
			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 = 3552;
				this.colDefinitionOption();
				}
				}
				this.state = 3557;
				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, 330, SparkSqlParser.RULE_colDefinitionOption);
		try {
			this.state = 3563;
			this._errHandler.sync(this);
			switch (this._input.LA(1)) {
			case SparkSqlParser.KW_NOT:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3558;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3559;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;
			case SparkSqlParser.KW_DEFAULT:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3560;
				this.defaultExpression();
				}
				break;
			case SparkSqlParser.KW_GENERATED:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3561;
				this.generationExpression();
				}
				break;
			case SparkSqlParser.KW_COMMENT:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3562;
				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, 332, SparkSqlParser.RULE_generationExpression);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3565;
			this.match(SparkSqlParser.KW_GENERATED);
			this.state = 3566;
			this.match(SparkSqlParser.KW_ALWAYS);
			this.state = 3567;
			this.match(SparkSqlParser.KW_AS);
			this.state = 3568;
			this.match(SparkSqlParser.LEFT_PAREN);
			this.state = 3569;
			this.expression();
			this.state = 3570;
			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, 334, SparkSqlParser.RULE_complexColTypeList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3572;
			this.complexColType();
			this.state = 3577;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3573;
				this.match(SparkSqlParser.COMMA);
				this.state = 3574;
				this.complexColType();
				}
				}
				this.state = 3579;
				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, 336, SparkSqlParser.RULE_complexColType);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3580;
			this.identifier();
			this.state = 3582;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 462, this._ctx) ) {
			case 1:
				{
				this.state = 3581;
				this.match(SparkSqlParser.COLON);
				}
				break;
			}
			this.state = 3584;
			this.dataType();
			this.state = 3587;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_NOT) {
				{
				this.state = 3585;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3586;
				this.match(SparkSqlParser.KW_NULL);
				}
			}

			this.state = 3590;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			if (_la === SparkSqlParser.KW_COMMENT) {
				{
				this.state = 3589;
				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, 338, SparkSqlParser.RULE_whenClause);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3592;
			this.match(SparkSqlParser.KW_WHEN);
			this.state = 3593;
			_localctx._condition = this.expression();
			this.state = 3594;
			this.match(SparkSqlParser.KW_THEN);
			this.state = 3595;
			_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, 340, SparkSqlParser.RULE_windowClause);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3597;
			this.match(SparkSqlParser.KW_WINDOW);
			this.state = 3598;
			this.namedWindow();
			this.state = 3603;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 465, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3599;
					this.match(SparkSqlParser.COMMA);
					this.state = 3600;
					this.namedWindow();
					}
					}
				}
				this.state = 3605;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 465, 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, 342, SparkSqlParser.RULE_namedWindow);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3606;
			_localctx._name = this.errorCapturingIdentifier();
			this.state = 3607;
			this.match(SparkSqlParser.KW_AS);
			this.state = 3608;
			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, 344, SparkSqlParser.RULE_windowSpec);
		let _la: number;
		try {
			this.state = 3656;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 473, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3610;
				_localctx._name = this.errorCapturingIdentifier();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3611;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3612;
				_localctx._name = this.errorCapturingIdentifier();
				this.state = 3613;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3615;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3650;
				this._errHandler.sync(this);
				switch (this._input.LA(1)) {
				case SparkSqlParser.KW_CLUSTER:
					{
					this.state = 3616;
					this.match(SparkSqlParser.KW_CLUSTER);
					this.state = 3617;
					this.match(SparkSqlParser.KW_BY);
					this.state = 3618;
					_localctx._expression = this.expression();
					_localctx._partition.push(_localctx._expression);
					this.state = 3623;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					while (_la === SparkSqlParser.COMMA) {
						{
						{
						this.state = 3619;
						this.match(SparkSqlParser.COMMA);
						this.state = 3620;
						_localctx._expression = this.expression();
						_localctx._partition.push(_localctx._expression);
						}
						}
						this.state = 3625;
						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 = 3636;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_DISTRIBUTE || _la === SparkSqlParser.KW_PARTITION) {
						{
						this.state = 3626;
						_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 = 3627;
						this.match(SparkSqlParser.KW_BY);
						this.state = 3628;
						_localctx._expression = this.expression();
						_localctx._partition.push(_localctx._expression);
						this.state = 3633;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						while (_la === SparkSqlParser.COMMA) {
							{
							{
							this.state = 3629;
							this.match(SparkSqlParser.COMMA);
							this.state = 3630;
							_localctx._expression = this.expression();
							_localctx._partition.push(_localctx._expression);
							}
							}
							this.state = 3635;
							this._errHandler.sync(this);
							_la = this._input.LA(1);
						}
						}
					}

					this.state = 3648;
					this._errHandler.sync(this);
					_la = this._input.LA(1);
					if (_la === SparkSqlParser.KW_ORDER || _la === SparkSqlParser.KW_SORT) {
						{
						this.state = 3638;
						_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 = 3639;
						this.match(SparkSqlParser.KW_BY);
						this.state = 3640;
						this.sortItem();
						this.state = 3645;
						this._errHandler.sync(this);
						_la = this._input.LA(1);
						while (_la === SparkSqlParser.COMMA) {
							{
							{
							this.state = 3641;
							this.match(SparkSqlParser.COMMA);
							this.state = 3642;
							this.sortItem();
							}
							}
							this.state = 3647;
							this._errHandler.sync(this);
							_la = this._input.LA(1);
						}
						}
					}

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

				this.state = 3655;
				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, 346, SparkSqlParser.RULE_windowFrame);
		try {
			this.state = 3674;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 474, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3658;
				_localctx._frameType = this.match(SparkSqlParser.KW_RANGE);
				this.state = 3659;
				_localctx._start_ = this.frameBound();
				}
				break;

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

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3662;
				_localctx._frameType = this.match(SparkSqlParser.KW_RANGE);
				this.state = 3663;
				this.match(SparkSqlParser.KW_BETWEEN);
				this.state = 3664;
				_localctx._start_ = this.frameBound();
				this.state = 3665;
				this.match(SparkSqlParser.KW_AND);
				this.state = 3666;
				_localctx._end = this.frameBound();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3668;
				_localctx._frameType = this.match(SparkSqlParser.KW_ROWS);
				this.state = 3669;
				this.match(SparkSqlParser.KW_BETWEEN);
				this.state = 3670;
				_localctx._start_ = this.frameBound();
				this.state = 3671;
				this.match(SparkSqlParser.KW_AND);
				this.state = 3672;
				_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, 348, SparkSqlParser.RULE_frameBound);
		let _la: number;
		try {
			this.state = 3683;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 475, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3676;
				this.match(SparkSqlParser.KW_UNBOUNDED);
				this.state = 3677;
				_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 = 3678;
				_localctx._boundType = this.match(SparkSqlParser.KW_CURRENT);
				this.state = 3679;
				this.match(SparkSqlParser.KW_ROW);
				}
				break;

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3680;
				this.expression();
				this.state = 3681;
				_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, 350, SparkSqlParser.RULE_qualifiedNameList);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3685;
			this.qualifiedName();
			this.state = 3690;
			this._errHandler.sync(this);
			_la = this._input.LA(1);
			while (_la === SparkSqlParser.COMMA) {
				{
				{
				this.state = 3686;
				this.match(SparkSqlParser.COMMA);
				this.state = 3687;
				this.qualifiedName();
				}
				}
				this.state = 3692;
				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, 352, SparkSqlParser.RULE_functionName);
		try {
			this.state = 3702;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 477, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3693;
				this.match(SparkSqlParser.KW_IDENTIFIER_KW);
				this.state = 3694;
				this.match(SparkSqlParser.LEFT_PAREN);
				this.state = 3695;
				this.expression();
				this.state = 3696;
				this.match(SparkSqlParser.RIGHT_PAREN);
				}
				break;

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

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

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

			case 5:
				this.enterOuterAlt(_localctx, 5);
				{
				this.state = 3701;
				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, 354, SparkSqlParser.RULE_functionNameCreate);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3704;
			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, 356, SparkSqlParser.RULE_qualifiedName);
		try {
			let _alt: number;
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3706;
			this.identifier();
			this.state = 3711;
			this._errHandler.sync(this);
			_alt = this.interpreter.adaptivePredict(this._input, 478, this._ctx);
			while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) {
				if (_alt === 1) {
					{
					{
					this.state = 3707;
					this.match(SparkSqlParser.DOT);
					this.state = 3708;
					this.identifier();
					}
					}
				}
				this.state = 3713;
				this._errHandler.sync(this);
				_alt = this.interpreter.adaptivePredict(this._input, 478, 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, 358, SparkSqlParser.RULE_errorCapturingIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3714;
			this.identifier();
			this.state = 3715;
			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, 360, SparkSqlParser.RULE_errorCapturingIdentifierExtra);
		try {
			let _alt: number;
			this.state = 3724;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 480, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3719;
				this._errHandler.sync(this);
				_alt = 1;
				do {
					switch (_alt) {
					case 1:
						{
						{
						this.state = 3717;
						this.match(SparkSqlParser.MINUS);
						this.state = 3718;
						this.identifier();
						}
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					this.state = 3721;
					this._errHandler.sync(this);
					_alt = this.interpreter.adaptivePredict(this._input, 479, 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, 362, SparkSqlParser.RULE_identifier);
		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 = 3726;
				this.strictIdentifier();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3727;
				if (!(!this.SQL_standard_keyword_behavior)) {
					throw this.createFailedPredicateException("!this.SQL_standard_keyword_behavior");
				}
				this.state = 3728;
				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, 364, SparkSqlParser.RULE_strictIdentifier);
		try {
			this.state = 3737;
			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.IDENTIFIER);
				}
				break;

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

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3733;
				if (!(this.SQL_standard_keyword_behavior)) {
					throw this.createFailedPredicateException("this.SQL_standard_keyword_behavior");
				}
				this.state = 3734;
				this.ansiNonReserved();
				}
				break;

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3735;
				if (!(!this.SQL_standard_keyword_behavior)) {
					throw this.createFailedPredicateException("!this.SQL_standard_keyword_behavior");
				}
				this.state = 3736;
				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, 366, SparkSqlParser.RULE_quotedIdentifier);
		try {
			this.state = 3742;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 483, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3739;
				this.match(SparkSqlParser.BACKQUOTED_IDENTIFIER);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3740;
				if (!(this.double_quoted_identifiers)) {
					throw this.createFailedPredicateException("this.double_quoted_identifiers");
				}
				this.state = 3741;
				this.match(SparkSqlParser.DOUBLEQUOTED_STRING);
				}
				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 backQuotedIdentifier(): BackQuotedIdentifierContext {
		let _localctx: BackQuotedIdentifierContext = new BackQuotedIdentifierContext(this._ctx, this.state);
		this.enterRule(_localctx, 368, SparkSqlParser.RULE_backQuotedIdentifier);
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3744;
			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, 370, SparkSqlParser.RULE_number);
		let _la: number;
		try {
			this.state = 3789;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 494, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3746;
				if (!(!this.legacy_exponent_literal_as_decimal_enabled)) {
					throw this.createFailedPredicateException("!this.legacy_exponent_literal_as_decimal_enabled");
				}
				this.state = 3748;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3747;
					this.match(SparkSqlParser.MINUS);
					}
				}

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

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3751;
				if (!(!this.legacy_exponent_literal_as_decimal_enabled)) {
					throw this.createFailedPredicateException("!this.legacy_exponent_literal_as_decimal_enabled");
				}
				this.state = 3753;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3752;
					this.match(SparkSqlParser.MINUS);
					}
				}

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

			case 3:
				this.enterOuterAlt(_localctx, 3);
				{
				this.state = 3756;
				if (!(this.legacy_exponent_literal_as_decimal_enabled)) {
					throw this.createFailedPredicateException("this.legacy_exponent_literal_as_decimal_enabled");
				}
				this.state = 3758;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3757;
					this.match(SparkSqlParser.MINUS);
					}
				}

				this.state = 3760;
				_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 = 3762;
				this._errHandler.sync(this);
				_la = this._input.LA(1);
				if (_la === SparkSqlParser.MINUS) {
					{
					this.state = 3761;
					this.match(SparkSqlParser.MINUS);
					}
				}

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

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

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

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

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

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

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

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

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

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

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

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

				this.state = 3788;
				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, 372, SparkSqlParser.RULE_alterColumnAction);
		let _la: number;
		try {
			this.state = 3802;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 495, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3791;
				this.match(SparkSqlParser.KW_TYPE);
				this.state = 3792;
				this.dataType();
				}
				break;

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

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

			case 4:
				this.enterOuterAlt(_localctx, 4);
				{
				this.state = 3795;
				_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 = 3796;
				this.match(SparkSqlParser.KW_NOT);
				this.state = 3797;
				this.match(SparkSqlParser.KW_NULL);
				}
				break;

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

			case 6:
				this.enterOuterAlt(_localctx, 6);
				{
				this.state = 3800;
				_localctx._dropDefault = this.match(SparkSqlParser.KW_DROP);
				this.state = 3801;
				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, 374, SparkSqlParser.RULE_stringLit);
		try {
			this.state = 3807;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 496, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3804;
				this.match(SparkSqlParser.STRING_LITERAL);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3805;
				if (!(!this.double_quoted_identifiers)) {
					throw this.createFailedPredicateException("!this.double_quoted_identifiers");
				}
				this.state = 3806;
				this.match(SparkSqlParser.DOUBLEQUOTED_STRING);
				}
				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 comment(): CommentContext {
		let _localctx: CommentContext = new CommentContext(this._ctx, this.state);
		this.enterRule(_localctx, 376, SparkSqlParser.RULE_comment);
		try {
			this.state = 3811;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 497, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3809;
				this.stringLit();
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3810;
				this.match(SparkSqlParser.KW_NULL);
				}
				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 version(): VersionContext {
		let _localctx: VersionContext = new VersionContext(this._ctx, this.state);
		this.enterRule(_localctx, 378, SparkSqlParser.RULE_version);
		try {
			this.state = 3815;
			this._errHandler.sync(this);
			switch ( this.interpreter.adaptivePredict(this._input, 498, this._ctx) ) {
			case 1:
				this.enterOuterAlt(_localctx, 1);
				{
				this.state = 3813;
				this.match(SparkSqlParser.INTEGER_VALUE);
				}
				break;

			case 2:
				this.enterOuterAlt(_localctx, 2);
				{
				this.state = 3814;
				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 ansiNonReserved(): AnsiNonReservedContext {
		let _localctx: AnsiNonReservedContext = new AnsiNonReservedContext(this._ctx, this.state);
		this.enterRule(_localctx, 380, SparkSqlParser.RULE_ansiNonReserved);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3817;
			_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_KW - 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)) | (1 << (SparkSqlParser.KW_NULLS - 163)))) !== 0) || ((((_la - 195)) & ~0x1F) === 0 && ((1 << (_la - 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)) | (1 << (SparkSqlParser.KW_QUERY - 195)))) !== 0) || ((((_la - 227)) & ~0x1F) === 0 && ((1 << (_la - 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)) | (1 << (SparkSqlParser.KW_SEPARATED - 227)))) !== 0) || ((((_la - 259)) & ~0x1F) === 0 && ((1 << (_la - 259)) & ((1 << (SparkSqlParser.KW_SERDE - 259)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 259)) | (1 << (SparkSqlParser.KW_SET - 259)) | (1 << (SparkSqlParser.KW_SETMINUS - 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)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 259)))) !== 0) || ((((_la - 291)) & ~0x1F) === 0 && ((1 << (_la - 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)) | (1 << (SparkSqlParser.KW_UPDATE - 291)))) !== 0) || ((((_la - 323)) & ~0x1F) === 0 && ((1 << (_la - 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, 382, SparkSqlParser.RULE_strictNonReserved);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3819;
			_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 - 243)) & ~0x1F) === 0 && ((1 << (_la - 243)) & ((1 << (SparkSqlParser.KW_RIGHT - 243)) | (1 << (SparkSqlParser.KW_SEMI - 243)) | (1 << (SparkSqlParser.KW_SETMINUS - 243)))) !== 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, 384, SparkSqlParser.RULE_nonReserved);
		let _la: number;
		try {
			this.enterOuterAlt(_localctx, 1);
			{
			this.state = 3821;
			_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_KW - 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 - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & ((1 << (SparkSqlParser.KW_NOT - 192)) | (1 << (SparkSqlParser.KW_NULL - 192)) | (1 << (SparkSqlParser.KW_NULLS - 192)) | (1 << (SparkSqlParser.KW_NUMERIC - 192)) | (1 << (SparkSqlParser.KW_OF - 192)) | (1 << (SparkSqlParser.KW_OFFSET - 192)) | (1 << (SparkSqlParser.KW_ONLY - 192)) | (1 << (SparkSqlParser.KW_OPTION - 192)) | (1 << (SparkSqlParser.KW_OPTIONS - 192)) | (1 << (SparkSqlParser.KW_OR - 192)) | (1 << (SparkSqlParser.KW_ORDER - 192)) | (1 << (SparkSqlParser.KW_OUT - 192)) | (1 << (SparkSqlParser.KW_OUTER - 192)) | (1 << (SparkSqlParser.KW_OUTPUTFORMAT - 192)) | (1 << (SparkSqlParser.KW_OVER - 192)) | (1 << (SparkSqlParser.KW_OVERLAPS - 192)) | (1 << (SparkSqlParser.KW_OVERLAY - 192)) | (1 << (SparkSqlParser.KW_OVERWRITE - 192)) | (1 << (SparkSqlParser.KW_PARTITION - 192)) | (1 << (SparkSqlParser.KW_PARTITIONED - 192)) | (1 << (SparkSqlParser.KW_PARTITIONS - 192)) | (1 << (SparkSqlParser.KW_PERCENTILE_CONT - 192)) | (1 << (SparkSqlParser.KW_PERCENTILE_DISC - 192)) | (1 << (SparkSqlParser.KW_PERCENTLIT - 192)) | (1 << (SparkSqlParser.KW_PIVOT - 192)) | (1 << (SparkSqlParser.KW_PLACING - 192)) | (1 << (SparkSqlParser.KW_POSITION - 192)) | (1 << (SparkSqlParser.KW_PRECEDING - 192)) | (1 << (SparkSqlParser.KW_PRIMARY - 192)) | (1 << (SparkSqlParser.KW_PRINCIPALS - 192)) | (1 << (SparkSqlParser.KW_PROPERTIES - 192)))) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & ((1 << (SparkSqlParser.KW_PURGE - 224)) | (1 << (SparkSqlParser.KW_QUARTER - 224)) | (1 << (SparkSqlParser.KW_QUERY - 224)) | (1 << (SparkSqlParser.KW_RANGE - 224)) | (1 << (SparkSqlParser.KW_REAL - 224)) | (1 << (SparkSqlParser.KW_RECORDREADER - 224)) | (1 << (SparkSqlParser.KW_RECORDWRITER - 224)) | (1 << (SparkSqlParser.KW_RECOVER - 224)) | (1 << (SparkSqlParser.KW_REDUCE - 224)) | (1 << (SparkSqlParser.KW_REFERENCES - 224)) | (1 << (SparkSqlParser.KW_REFRESH - 224)) | (1 << (SparkSqlParser.KW_RENAME - 224)) | (1 << (SparkSqlParser.KW_REPAIR - 224)) | (1 << (SparkSqlParser.KW_REPEATABLE - 224)) | (1 << (SparkSqlParser.KW_REPLACE - 224)) | (1 << (SparkSqlParser.KW_RESET - 224)) | (1 << (SparkSqlParser.KW_RESPECT - 224)) | (1 << (SparkSqlParser.KW_RESTRICT - 224)) | (1 << (SparkSqlParser.KW_REVOKE - 224)) | (1 << (SparkSqlParser.KW_RLIKE - 224)) | (1 << (SparkSqlParser.KW_REGEXP - 224)) | (1 << (SparkSqlParser.KW_ROLE - 224)) | (1 << (SparkSqlParser.KW_ROLES - 224)) | (1 << (SparkSqlParser.KW_ROLLBACK - 224)) | (1 << (SparkSqlParser.KW_ROLLUP - 224)) | (1 << (SparkSqlParser.KW_ROW - 224)) | (1 << (SparkSqlParser.KW_ROWS - 224)) | (1 << (SparkSqlParser.KW_SECOND - 224)) | (1 << (SparkSqlParser.KW_SECONDS - 224)) | (1 << (SparkSqlParser.KW_SCHEMA - 224)) | (1 << (SparkSqlParser.KW_SCHEMAS - 224)))) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & ((1 << (SparkSqlParser.KW_SELECT - 256)) | (1 << (SparkSqlParser.KW_SEPARATED - 256)) | (1 << (SparkSqlParser.KW_SERDE - 256)) | (1 << (SparkSqlParser.KW_SERDEPROPERTIES - 256)) | (1 << (SparkSqlParser.KW_SESSION_USER - 256)) | (1 << (SparkSqlParser.KW_SET - 256)) | (1 << (SparkSqlParser.KW_SETS - 256)) | (1 << (SparkSqlParser.KW_SHORT - 256)) | (1 << (SparkSqlParser.KW_SHOW - 256)) | (1 << (SparkSqlParser.KW_SINGLE - 256)) | (1 << (SparkSqlParser.KW_SKEWED - 256)) | (1 << (SparkSqlParser.KW_SMALLINT - 256)) | (1 << (SparkSqlParser.KW_SOME - 256)) | (1 << (SparkSqlParser.KW_SORT - 256)) | (1 << (SparkSqlParser.KW_SORTED - 256)) | (1 << (SparkSqlParser.KW_SOURCE - 256)) | (1 << (SparkSqlParser.KW_START - 256)) | (1 << (SparkSqlParser.KW_STATISTICS - 256)) | (1 << (SparkSqlParser.KW_STORED - 256)) | (1 << (SparkSqlParser.KW_STRATIFY - 256)) | (1 << (SparkSqlParser.KW_STRING - 256)) | (1 << (SparkSqlParser.KW_STRUCT - 256)) | (1 << (SparkSqlParser.KW_SUBSTR - 256)) | (1 << (SparkSqlParser.KW_SUBSTRING - 256)) | (1 << (SparkSqlParser.KW_SYNC - 256)) | (1 << (SparkSqlParser.KW_SYSTEM - 256)) | (1 << (SparkSqlParser.KW_SYSTEM_TIME - 256)) | (1 << (SparkSqlParser.KW_SYSTEM_VERSION - 256)) | (1 << (SparkSqlParser.KW_TABLE - 256)) | (1 << (SparkSqlParser.KW_TABLES - 256)))) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & ((1 << (SparkSqlParser.KW_TABLESAMPLE - 288)) | (1 << (SparkSqlParser.KW_TARGET - 288)) | (1 << (SparkSqlParser.KW_TBLPROPERTIES - 288)) | (1 << (SparkSqlParser.KW_TEMPORARY - 288)) | (1 << (SparkSqlParser.KW_TERMINATED - 288)) | (1 << (SparkSqlParser.KW_THEN - 288)) | (1 << (SparkSqlParser.KW_TIME - 288)) | (1 << (SparkSqlParser.KW_TIMEDIFF - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMP - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMP_LTZ - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMP_NTZ - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMPADD - 288)) | (1 << (SparkSqlParser.KW_TIMESTAMPDIFF - 288)) | (1 << (SparkSqlParser.KW_TINYINT - 288)) | (1 << (SparkSqlParser.KW_TO - 288)) | (1 << (SparkSqlParser.KW_TOUCH - 288)) | (1 << (SparkSqlParser.KW_TRAILING - 288)) | (1 << (SparkSqlParser.KW_TRANSACTION - 288)) | (1 << (SparkSqlParser.KW_TRANSACTIONS - 288)) | (1 << (SparkSqlParser.KW_TRANSFORM - 288)) | (1 << (SparkSqlParser.KW_TRIM - 288)) | (1 << (SparkSqlParser.KW_TRUE - 288)) | (1 << (SparkSqlParser.KW_TRUNCATE - 288)) | (1 << (SparkSqlParser.KW_TRY_CAST - 288)) | (1 << (SparkSqlParser.KW_TYPE - 288)) | (1 << (SparkSqlParser.KW_UNARCHIVE - 288)) | (1 << (SparkSqlParser.KW_UNBOUNDED - 288)) | (1 << (SparkSqlParser.KW_UNCACHE - 288)) | (1 << (SparkSqlParser.KW_UNIQUE - 288)) | (1 << (SparkSqlParser.KW_UNKNOWN - 288)) | (1 << (SparkSqlParser.KW_UNLOCK - 288)))) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & ((1 << (SparkSqlParser.KW_UNPIVOT - 320)) | (1 << (SparkSqlParser.KW_UNSET - 320)) | (1 << (SparkSqlParser.KW_UPDATE - 320)) | (1 << (SparkSqlParser.KW_USE - 320)) | (1 << (SparkSqlParser.KW_USER - 320)) | (1 << (SparkSqlParser.KW_VALUES - 320)) | (1 << (SparkSqlParser.KW_VARCHAR - 320)) | (1 << (SparkSqlParser.KW_VAR - 320)) | (1 << (SparkSqlParser.KW_VARIABLE - 320)) | (1 << (SparkSqlParser.KW_VERSION - 320)) | (1 << (SparkSqlParser.KW_VIEW - 320)) | (1 << (SparkSqlParser.KW_VIEWS - 320)) | (1 << (SparkSqlParser.KW_VOID - 320)) | (1 << (SparkSqlParser.KW_WEEK - 320)) | (1 << (SparkSqlParser.KW_WEEKS - 320)) | (1 << (SparkSqlParser.KW_WHEN - 320)) | (1 << (SparkSqlParser.KW_WHERE - 320)) | (1 << (SparkSqlParser.KW_WINDOW - 320)) | (1 << (SparkSqlParser.KW_WITH - 320)) | (1 << (SparkSqlParser.KW_WITHIN - 320)) | (1 << (SparkSqlParser.KW_YEAR - 320)) | (1 << (SparkSqlParser.KW_YEARS - 320)) | (1 << (SparkSqlParser.KW_ZONE - 320)))) !== 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 48:
			return this.queryTerm_sempred(_localctx as QueryTermContext, predIndex);

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

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

		case 138:
			return this.primaryExpression_sempred(_localctx as PrimaryExpressionContext, predIndex);

		case 181:
			return this.identifier_sempred(_localctx as IdentifierContext, predIndex);

		case 182:
			return this.strictIdentifier_sempred(_localctx as StrictIdentifierContext, predIndex);

		case 183:
			return this.quotedIdentifier_sempred(_localctx as QuotedIdentifierContext, predIndex);

		case 185:
			return this.number_sempred(_localctx as NumberContext, predIndex);

		case 187:
			return this.stringLit_sempred(_localctx as StringLitContext, 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.legacy_setops_precedence_enabled;

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

		case 3:
			return !this.legacy_setops_precedence_enabled;

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

		case 5:
			return !this.legacy_setops_precedence_enabled;
		}
		return true;
	}
	private booleanExpression_sempred(_localctx: BooleanExpressionContext, predIndex: number): boolean {
		switch (predIndex) {
		case 6:
			return this.precpred(this._ctx, 2);

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

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

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

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

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

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

		case 15:
			return this.precpred(this._ctx, 7);
		}
		return true;
	}
	private identifier_sempred(_localctx: IdentifierContext, predIndex: number): boolean {
		switch (predIndex) {
		case 16:
			return !this.SQL_standard_keyword_behavior;
		}
		return true;
	}
	private strictIdentifier_sempred(_localctx: StrictIdentifierContext, predIndex: number): boolean {
		switch (predIndex) {
		case 17:
			return this.SQL_standard_keyword_behavior;

		case 18:
			return !this.SQL_standard_keyword_behavior;
		}
		return true;
	}
	private quotedIdentifier_sempred(_localctx: QuotedIdentifierContext, predIndex: number): boolean {
		switch (predIndex) {
		case 19:
			return this.double_quoted_identifiers;
		}
		return true;
	}
	private number_sempred(_localctx: NumberContext, predIndex: number): boolean {
		switch (predIndex) {
		case 20:
			return !this.legacy_exponent_literal_as_decimal_enabled;

		case 21:
			return !this.legacy_exponent_literal_as_decimal_enabled;

		case 22:
			return this.legacy_exponent_literal_as_decimal_enabled;
		}
		return true;
	}
	private stringLit_sempred(_localctx: StringLitContext, predIndex: number): boolean {
		switch (predIndex) {
		case 23:
			return !this.double_quoted_identifiers;
		}
		return true;
	}

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


export class QualifiedColTypeWithPositionContext extends ParserRuleContext {
	public _name!: MultipartIdentifierContext;
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public multipartIdentifier(): MultipartIdentifierContext {
		return this.getRuleContext(0, MultipartIdentifierContext);
	}
	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_qualifiedColTypeWithPosition; }
	// @Override
	public enterRule(listener: SparkSqlParserListener): void {
		if (listener.enterQualifiedColTypeWithPosition) {
			listener.enterQualifiedColTypeWithPosition(this);
		}
	}
	// @Override
	public exitRule(listener: SparkSqlParserListener): void {
		if (listener.exitQualifiedColTypeWithPosition) {
			listener.exitQualifiedColTypeWithPosition(this);
		}
	}
	// @Override
	public accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result {
		if (visitor.visitQualifiedColTypeWithPosition) {
			return visitor.visitQualifiedColTypeWithPosition(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!: ErrorCapturingIdentifierContext;
	public dataType(): DataTypeContext {
		return this.getRuleContext(0, DataTypeContext);
	}
	public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
		return this.getRuleContext(0, ErrorCapturingIdentifierContext);
	}
	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_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 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_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 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_SETMINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETMINUS, 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_SETMINUS(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_SETMINUS, 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_KW(): TerminalNode | undefined { return this.tryGetToken(SparkSqlParser.KW_IDENTIFIER_KW, 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);
		}
	}
}