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

// @ts-nocheck

import * as antlr from "antlr4ng";
import { Token } from "antlr4ng";

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

// for running tests with parameters, TODO: discuss strategy for typed parameters in CI
// eslint-disable-next-line no-unused-vars
type int = number;


import { SQLParserBase } from '../SQLParserBase';


export class SparkSqlParser extends SQLParserBase {
    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_DISABLE = 91;
    public static readonly KW_DISTINCT = 92;
    public static readonly KW_DISTRIBUTE = 93;
    public static readonly KW_DIV = 94;
    public static readonly KW_DOUBLE = 95;
    public static readonly KW_DROP = 96;
    public static readonly KW_ELSE = 97;
    public static readonly KW_ENABLE = 98;
    public static readonly KW_END = 99;
    public static readonly KW_ESCAPE = 100;
    public static readonly KW_ESCAPED = 101;
    public static readonly KW_EXCEPT = 102;
    public static readonly KW_EXCHANGE = 103;
    public static readonly KW_EXCLUDE = 104;
    public static readonly KW_EXISTS = 105;
    public static readonly KW_EXPLAIN = 106;
    public static readonly KW_EXPORT = 107;
    public static readonly KW_EXTENDED = 108;
    public static readonly KW_EXTERNAL = 109;
    public static readonly KW_EXTRACT = 110;
    public static readonly KW_FALSE = 111;
    public static readonly KW_FETCH = 112;
    public static readonly KW_FIELDS = 113;
    public static readonly KW_FILTER = 114;
    public static readonly KW_FILEFORMAT = 115;
    public static readonly KW_FIRST = 116;
    public static readonly KW_FLOAT = 117;
    public static readonly KW_FOLLOWING = 118;
    public static readonly KW_FOR = 119;
    public static readonly KW_FOREIGN = 120;
    public static readonly KW_FORMAT = 121;
    public static readonly KW_FORMATTED = 122;
    public static readonly KW_FROM = 123;
    public static readonly KW_FULL = 124;
    public static readonly KW_FUNCTION = 125;
    public static readonly KW_FUNCTIONS = 126;
    public static readonly KW_GENERATED = 127;
    public static readonly KW_GLOBAL = 128;
    public static readonly KW_GRANT = 129;
    public static readonly KW_GROUP = 130;
    public static readonly KW_GROUPING = 131;
    public static readonly KW_HAVING = 132;
    public static readonly KW_BINARY_HEX = 133;
    public static readonly KW_HOUR = 134;
    public static readonly KW_HOURS = 135;
    public static readonly KW_IDENTIFIER = 136;
    public static readonly KW_IF = 137;
    public static readonly KW_IGNORE = 138;
    public static readonly KW_IMPORT = 139;
    public static readonly KW_IN = 140;
    public static readonly KW_INCLUDE = 141;
    public static readonly KW_INDEX = 142;
    public static readonly KW_INDEXES = 143;
    public static readonly KW_INNER = 144;
    public static readonly KW_INPATH = 145;
    public static readonly KW_INPUTFORMAT = 146;
    public static readonly KW_INSERT = 147;
    public static readonly KW_INTERSECT = 148;
    public static readonly KW_INTERVAL = 149;
    public static readonly KW_INT = 150;
    public static readonly KW_INTEGER = 151;
    public static readonly KW_INTO = 152;
    public static readonly KW_IS = 153;
    public static readonly KW_ITEMS = 154;
    public static readonly KW_JOIN = 155;
    public static readonly KW_KEYS = 156;
    public static readonly KW_LAST = 157;
    public static readonly KW_LATERAL = 158;
    public static readonly KW_LAZY = 159;
    public static readonly KW_LEADING = 160;
    public static readonly KW_LEFT = 161;
    public static readonly KW_LIFECYCLE = 162;
    public static readonly KW_LIKE = 163;
    public static readonly KW_ILIKE = 164;
    public static readonly KW_LIMIT = 165;
    public static readonly KW_LINES = 166;
    public static readonly KW_LIST = 167;
    public static readonly KW_LOAD = 168;
    public static readonly KW_LOCAL = 169;
    public static readonly KW_LOCATION = 170;
    public static readonly KW_LOCK = 171;
    public static readonly KW_LOCKS = 172;
    public static readonly KW_LOGICAL = 173;
    public static readonly KW_LONG = 174;
    public static readonly KW_MACRO = 175;
    public static readonly KW_MATERIALIZED = 176;
    public static readonly KW_MAP = 177;
    public static readonly KW_MATCHED = 178;
    public static readonly KW_MERGE = 179;
    public static readonly KW_MICROSECOND = 180;
    public static readonly KW_MICROSECONDS = 181;
    public static readonly KW_MILLISECOND = 182;
    public static readonly KW_MILLISECONDS = 183;
    public static readonly KW_MINUTE = 184;
    public static readonly KW_MINUTES = 185;
    public static readonly KW_MONTH = 186;
    public static readonly KW_MONTHS = 187;
    public static readonly KW_MSCK = 188;
    public static readonly KW_NAME = 189;
    public static readonly KW_NAMESPACE = 190;
    public static readonly KW_NAMESPACES = 191;
    public static readonly KW_NANOSECOND = 192;
    public static readonly KW_NANOSECONDS = 193;
    public static readonly KW_NATURAL = 194;
    public static readonly KW_NO = 195;
    public static readonly KW_NOSCAN = 196;
    public static readonly KW_NOT = 197;
    public static readonly KW_NULL = 198;
    public static readonly KW_NULLS = 199;
    public static readonly KW_NUMERIC = 200;
    public static readonly KW_OF = 201;
    public static readonly KW_OFFSET = 202;
    public static readonly KW_ON = 203;
    public static readonly KW_ONLY = 204;
    public static readonly KW_OPTIMIZE = 205;
    public static readonly KW_OPTION = 206;
    public static readonly KW_OPTIONS = 207;
    public static readonly KW_OR = 208;
    public static readonly KW_ORDER = 209;
    public static readonly KW_OUT = 210;
    public static readonly KW_OUTER = 211;
    public static readonly KW_OUTPUTFORMAT = 212;
    public static readonly KW_OVER = 213;
    public static readonly KW_OVERLAPS = 214;
    public static readonly KW_OVERLAY = 215;
    public static readonly KW_OVERWRITE = 216;
    public static readonly KW_PARTITION = 217;
    public static readonly KW_PARTITIONED = 218;
    public static readonly KW_PARTITIONS = 219;
    public static readonly KW_PERCENTILE_CONT = 220;
    public static readonly KW_PERCENTILE_DISC = 221;
    public static readonly KW_PERCENTLIT = 222;
    public static readonly KW_PIVOT = 223;
    public static readonly KW_PLACING = 224;
    public static readonly KW_POSITION = 225;
    public static readonly KW_PRECEDING = 226;
    public static readonly KW_PRIMARY = 227;
    public static readonly KW_PRINCIPALS = 228;
    public static readonly KW_PROPERTIES = 229;
    public static readonly KW_PURGE = 230;
    public static readonly KW_QUARTER = 231;
    public static readonly KW_QUERY = 232;
    public static readonly KW_RANGE = 233;
    public static readonly KW_REAL = 234;
    public static readonly KW_RECORDREADER = 235;
    public static readonly KW_RECORDWRITER = 236;
    public static readonly KW_RECOVER = 237;
    public static readonly KW_REDUCE = 238;
    public static readonly KW_REFERENCES = 239;
    public static readonly KW_REFRESH = 240;
    public static readonly KW_RENAME = 241;
    public static readonly KW_REPAIR = 242;
    public static readonly KW_REPEATABLE = 243;
    public static readonly KW_REPLACE = 244;
    public static readonly KW_RESET = 245;
    public static readonly KW_RESPECT = 246;
    public static readonly KW_RESTRICT = 247;
    public static readonly KW_REWRITE = 248;
    public static readonly KW_REVOKE = 249;
    public static readonly KW_RIGHT = 250;
    public static readonly KW_RLIKE = 251;
    public static readonly KW_REGEXP = 252;
    public static readonly KW_ROLE = 253;
    public static readonly KW_ROLES = 254;
    public static readonly KW_ROLLBACK = 255;
    public static readonly KW_ROLLUP = 256;
    public static readonly KW_ROW = 257;
    public static readonly KW_ROWS = 258;
    public static readonly KW_SECOND = 259;
    public static readonly KW_SECONDS = 260;
    public static readonly KW_SCHEMA = 261;
    public static readonly KW_SCHEMAS = 262;
    public static readonly KW_SELECT = 263;
    public static readonly KW_SEMI = 264;
    public static readonly KW_SEPARATED = 265;
    public static readonly KW_SERDE = 266;
    public static readonly KW_SERDEPROPERTIES = 267;
    public static readonly KW_SESSION_USER = 268;
    public static readonly KW_SET = 269;
    public static readonly KW_MINUS = 270;
    public static readonly KW_SETS = 271;
    public static readonly KW_SHORT = 272;
    public static readonly KW_SHOW = 273;
    public static readonly KW_SINGLE = 274;
    public static readonly KW_SKEWED = 275;
    public static readonly KW_SMALLINT = 276;
    public static readonly KW_SOME = 277;
    public static readonly KW_SORT = 278;
    public static readonly KW_SORTED = 279;
    public static readonly KW_SOURCE = 280;
    public static readonly KW_START = 281;
    public static readonly KW_STATISTICS = 282;
    public static readonly KW_STORED = 283;
    public static readonly KW_STRATIFY = 284;
    public static readonly KW_STRING = 285;
    public static readonly KW_STRUCT = 286;
    public static readonly KW_SUBSTR = 287;
    public static readonly KW_SUBSTRING = 288;
    public static readonly KW_SYNC = 289;
    public static readonly KW_SYSTEM = 290;
    public static readonly KW_SYSTEM_TIME = 291;
    public static readonly KW_SYSTEM_VERSION = 292;
    public static readonly KW_TABLE = 293;
    public static readonly KW_TABLES = 294;
    public static readonly KW_TABLESAMPLE = 295;
    public static readonly KW_TARGET = 296;
    public static readonly KW_TBLPROPERTIES = 297;
    public static readonly KW_TEMPORARY = 298;
    public static readonly KW_TERMINATED = 299;
    public static readonly KW_THEN = 300;
    public static readonly KW_TIME = 301;
    public static readonly KW_TIMEDIFF = 302;
    public static readonly KW_TIMESTAMP = 303;
    public static readonly KW_TIMESTAMP_LTZ = 304;
    public static readonly KW_TIMESTAMP_NTZ = 305;
    public static readonly KW_TIMESTAMPADD = 306;
    public static readonly KW_TIMESTAMPDIFF = 307;
    public static readonly KW_TINYINT = 308;
    public static readonly KW_TO = 309;
    public static readonly KW_TOUCH = 310;
    public static readonly KW_TRAILING = 311;
    public static readonly KW_TRANSACTION = 312;
    public static readonly KW_TRANSACTIONS = 313;
    public static readonly KW_TRANSFORM = 314;
    public static readonly KW_TRIM = 315;
    public static readonly KW_TRUE = 316;
    public static readonly KW_TRUNCATE = 317;
    public static readonly KW_TRY_CAST = 318;
    public static readonly KW_TYPE = 319;
    public static readonly KW_UNARCHIVE = 320;
    public static readonly KW_UNBOUNDED = 321;
    public static readonly KW_UNCACHE = 322;
    public static readonly KW_UNION = 323;
    public static readonly KW_UNIQUE = 324;
    public static readonly KW_UNKNOWN = 325;
    public static readonly KW_UNLOCK = 326;
    public static readonly KW_UNPIVOT = 327;
    public static readonly KW_UNSET = 328;
    public static readonly KW_UPDATE = 329;
    public static readonly KW_USE = 330;
    public static readonly KW_USER = 331;
    public static readonly KW_USING = 332;
    public static readonly KW_VALUES = 333;
    public static readonly KW_VARCHAR = 334;
    public static readonly KW_VAR = 335;
    public static readonly KW_VARIABLE = 336;
    public static readonly KW_VERSION = 337;
    public static readonly KW_VIEW = 338;
    public static readonly KW_VIEWS = 339;
    public static readonly KW_VOID = 340;
    public static readonly KW_WEEK = 341;
    public static readonly KW_WEEKS = 342;
    public static readonly KW_WHEN = 343;
    public static readonly KW_WHERE = 344;
    public static readonly KW_WINDOW = 345;
    public static readonly KW_WITH = 346;
    public static readonly KW_WITHIN = 347;
    public static readonly KW_YEAR = 348;
    public static readonly KW_YEARS = 349;
    public static readonly KW_ZONE = 350;
    public static readonly KW_ZORDER = 351;
    public static readonly EQ = 352;
    public static readonly NSEQ = 353;
    public static readonly NEQ = 354;
    public static readonly NEQJ = 355;
    public static readonly LT = 356;
    public static readonly LTE = 357;
    public static readonly GT = 358;
    public static readonly GTE = 359;
    public static readonly NOT = 360;
    public static readonly PLUS = 361;
    public static readonly MINUS = 362;
    public static readonly ASTERISK = 363;
    public static readonly SLASH = 364;
    public static readonly PERCENT = 365;
    public static readonly TILDE = 366;
    public static readonly AMPERSAND = 367;
    public static readonly PIPE = 368;
    public static readonly CONCAT_PIPE = 369;
    public static readonly HAT = 370;
    public static readonly COLON = 371;
    public static readonly ARROW = 372;
    public static readonly FAT_ARROW = 373;
    public static readonly HENT_START = 374;
    public static readonly HENT_END = 375;
    public static readonly QUESTION = 376;
    public static readonly STRING_LITERAL = 377;
    public static readonly DOUBLEQUOTED_STRING = 378;
    public static readonly BIGINT_LITERAL = 379;
    public static readonly SMALLINT_LITERAL = 380;
    public static readonly TINYINT_LITERAL = 381;
    public static readonly INTEGER_VALUE = 382;
    public static readonly EXPONENT_VALUE = 383;
    public static readonly DECIMAL_VALUE = 384;
    public static readonly FLOAT_LITERAL = 385;
    public static readonly DOUBLE_LITERAL = 386;
    public static readonly BIGDECIMAL_LITERAL = 387;
    public static readonly IDENTIFIER = 388;
    public static readonly BACKQUOTED_IDENTIFIER = 389;
    public static readonly SIMPLE_COMMENT = 390;
    public static readonly BRACKETED_COMMENT = 391;
    public static readonly WS = 392;
    public static readonly UNRECOGNIZED = 393;
    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_namespace = 18;
    public static readonly RULE_namespaces = 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_tableLifecycle = 26;
    public static readonly RULE_propertyList = 27;
    public static readonly RULE_property = 28;
    public static readonly RULE_propertyKey = 29;
    public static readonly RULE_propertyValue = 30;
    public static readonly RULE_expressionPropertyList = 31;
    public static readonly RULE_expressionProperty = 32;
    public static readonly RULE_constantList = 33;
    public static readonly RULE_nestedConstantList = 34;
    public static readonly RULE_createFileFormat = 35;
    public static readonly RULE_fileFormat = 36;
    public static readonly RULE_storageHandler = 37;
    public static readonly RULE_resource = 38;
    public static readonly RULE_dmlStatementNoWith = 39;
    public static readonly RULE_namespaceName = 40;
    public static readonly RULE_namespaceNameCreate = 41;
    public static readonly RULE_tableNameCreate = 42;
    public static readonly RULE_tableName = 43;
    public static readonly RULE_viewNameCreate = 44;
    public static readonly RULE_viewName = 45;
    public static readonly RULE_columnName = 46;
    public static readonly RULE_columnNameSeq = 47;
    public static readonly RULE_columnNameCreate = 48;
    public static readonly RULE_identifierReference = 49;
    public static readonly RULE_queryOrganization = 50;
    public static readonly RULE_multiInsertQueryBody = 51;
    public static readonly RULE_queryTerm = 52;
    public static readonly RULE_queryPrimary = 53;
    public static readonly RULE_sortItem = 54;
    public static readonly RULE_fromStatement = 55;
    public static readonly RULE_fromStatementBody = 56;
    public static readonly RULE_querySpecification = 57;
    public static readonly RULE_transformClause = 58;
    public static readonly RULE_selectClause = 59;
    public static readonly RULE_setClause = 60;
    public static readonly RULE_matchedClause = 61;
    public static readonly RULE_notMatchedClause = 62;
    public static readonly RULE_notMatchedBySourceClause = 63;
    public static readonly RULE_matchedAction = 64;
    public static readonly RULE_notMatchedAction = 65;
    public static readonly RULE_notMatchedBySourceAction = 66;
    public static readonly RULE_assignmentList = 67;
    public static readonly RULE_assignment = 68;
    public static readonly RULE_whereClause = 69;
    public static readonly RULE_havingClause = 70;
    public static readonly RULE_hint = 71;
    public static readonly RULE_hintStatement = 72;
    public static readonly RULE_fromClause = 73;
    public static readonly RULE_functionKind = 74;
    public static readonly RULE_temporalClause = 75;
    public static readonly RULE_aggregationClause = 76;
    public static readonly RULE_groupByClause = 77;
    public static readonly RULE_groupingAnalytics = 78;
    public static readonly RULE_groupingElement = 79;
    public static readonly RULE_groupingSet = 80;
    public static readonly RULE_pivotClause = 81;
    public static readonly RULE_pivotColumn = 82;
    public static readonly RULE_pivotValue = 83;
    public static readonly RULE_unpivotClause = 84;
    public static readonly RULE_unpivotNullClause = 85;
    public static readonly RULE_unpivotOperator = 86;
    public static readonly RULE_unpivotSingleValueColumnClause = 87;
    public static readonly RULE_unpivotMultiValueColumnClause = 88;
    public static readonly RULE_unpivotColumnSet = 89;
    public static readonly RULE_unpivotValueColumn = 90;
    public static readonly RULE_unpivotNameColumn = 91;
    public static readonly RULE_unpivotColumnAndAlias = 92;
    public static readonly RULE_unpivotColumn = 93;
    public static readonly RULE_unpivotAlias = 94;
    public static readonly RULE_ifNotExists = 95;
    public static readonly RULE_ifExists = 96;
    public static readonly RULE_lateralView = 97;
    public static readonly RULE_setQuantifier = 98;
    public static readonly RULE_relation = 99;
    public static readonly RULE_relationExtension = 100;
    public static readonly RULE_joinRelation = 101;
    public static readonly RULE_joinType = 102;
    public static readonly RULE_joinCriteria = 103;
    public static readonly RULE_sample = 104;
    public static readonly RULE_sampleMethod = 105;
    public static readonly RULE_identifierList = 106;
    public static readonly RULE_identifierSeq = 107;
    public static readonly RULE_orderedIdentifierList = 108;
    public static readonly RULE_orderedIdentifier = 109;
    public static readonly RULE_identifierCommentList = 110;
    public static readonly RULE_identifierComment = 111;
    public static readonly RULE_relationPrimary = 112;
    public static readonly RULE_inlineTable = 113;
    public static readonly RULE_functionTableSubqueryArgument = 114;
    public static readonly RULE_tableArgumentPartitioning = 115;
    public static readonly RULE_functionTableNamedArgumentExpression = 116;
    public static readonly RULE_functionTableReferenceArgument = 117;
    public static readonly RULE_functionTableArgument = 118;
    public static readonly RULE_functionTable = 119;
    public static readonly RULE_tableAlias = 120;
    public static readonly RULE_rowFormat = 121;
    public static readonly RULE_multipartIdentifierList = 122;
    public static readonly RULE_multipartIdentifier = 123;
    public static readonly RULE_multipartIdentifierPropertyList = 124;
    public static readonly RULE_multipartIdentifierProperty = 125;
    public static readonly RULE_tableIdentifier = 126;
    public static readonly RULE_viewIdentifier = 127;
    public static readonly RULE_namedExpression = 128;
    public static readonly RULE_namedExpressionSeq = 129;
    public static readonly RULE_partitionFieldList = 130;
    public static readonly RULE_partitionField = 131;
    public static readonly RULE_transform = 132;
    public static readonly RULE_transformArgument = 133;
    public static readonly RULE_expression = 134;
    public static readonly RULE_namedArgumentExpression = 135;
    public static readonly RULE_functionArgument = 136;
    public static readonly RULE_expressionSeq = 137;
    public static readonly RULE_booleanExpression = 138;
    public static readonly RULE_predicate = 139;
    public static readonly RULE_valueExpression = 140;
    public static readonly RULE_datetimeUnit = 141;
    public static readonly RULE_primaryExpression = 142;
    public static readonly RULE_literalType = 143;
    public static readonly RULE_constant = 144;
    public static readonly RULE_comparisonOperator = 145;
    public static readonly RULE_arithmeticOperator = 146;
    public static readonly RULE_predicateOperator = 147;
    public static readonly RULE_booleanValue = 148;
    public static readonly RULE_interval = 149;
    public static readonly RULE_errorCapturingMultiUnitsInterval = 150;
    public static readonly RULE_multiUnitsInterval = 151;
    public static readonly RULE_errorCapturingUnitToUnitInterval = 152;
    public static readonly RULE_unitToUnitInterval = 153;
    public static readonly RULE_intervalValue = 154;
    public static readonly RULE_unitInMultiUnits = 155;
    public static readonly RULE_unitInUnitToUnit = 156;
    public static readonly RULE_colPosition = 157;
    public static readonly RULE_type = 158;
    public static readonly RULE_dataType = 159;
    public static readonly RULE_qualifiedColTypeWithPositionSeqForAdd = 160;
    public static readonly RULE_qualifiedColTypeWithPositionForAdd = 161;
    public static readonly RULE_qualifiedColTypeWithPositionSeqForReplace = 162;
    public static readonly RULE_qualifiedColTypeWithPositionForReplace = 163;
    public static readonly RULE_colDefinitionDescriptorWithPosition = 164;
    public static readonly RULE_defaultExpression = 165;
    public static readonly RULE_variableDefaultExpression = 166;
    public static readonly RULE_colTypeList = 167;
    public static readonly RULE_colType = 168;
    public static readonly RULE_createOrReplaceTableColTypeList = 169;
    public static readonly RULE_createOrReplaceTableColType = 170;
    public static readonly RULE_colDefinitionOption = 171;
    public static readonly RULE_generationExpression = 172;
    public static readonly RULE_complexColTypeList = 173;
    public static readonly RULE_complexColType = 174;
    public static readonly RULE_whenClause = 175;
    public static readonly RULE_windowClause = 176;
    public static readonly RULE_zorderClause = 177;
    public static readonly RULE_namedWindow = 178;
    public static readonly RULE_windowSpec = 179;
    public static readonly RULE_windowFrame = 180;
    public static readonly RULE_frameBound = 181;
    public static readonly RULE_qualifiedNameList = 182;
    public static readonly RULE_functionName = 183;
    public static readonly RULE_functionNameCreate = 184;
    public static readonly RULE_qualifiedName = 185;
    public static readonly RULE_errorCapturingIdentifier = 186;
    public static readonly RULE_errorCapturingIdentifierExtra = 187;
    public static readonly RULE_identifier = 188;
    public static readonly RULE_strictIdentifier = 189;
    public static readonly RULE_quotedIdentifier = 190;
    public static readonly RULE_backQuotedIdentifier = 191;
    public static readonly RULE_number = 192;
    public static readonly RULE_alterColumnAction = 193;
    public static readonly RULE_stringLit = 194;
    public static readonly RULE_comment = 195;
    public static readonly RULE_version = 196;
    public static readonly RULE_ansiNonReserved = 197;
    public static readonly RULE_strictNonReserved = 198;
    public static readonly RULE_nonReserved = 199;

    public static readonly literalNames = [
        null, "';'", "'('", "')'", "','", "'.'", "'['", "']'", "'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'", 
        "'DISABLE'", "'DISTINCT'", "'DISTRIBUTE'", "'DIV'", "'DOUBLE'", 
        "'DROP'", "'ELSE'", "'ENABLE'", "'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'", "'LIFECYCLE'", "'LIKE'", 
        "'ILIKE'", "'LIMIT'", "'LINES'", "'LIST'", "'LOAD'", "'LOCAL'", 
        "'LOCATION'", "'LOCK'", "'LOCKS'", "'LOGICAL'", "'LONG'", "'MACRO'", 
        "'MATERIALIZED'", "'MAP'", "'MATCHED'", "'MERGE'", "'MICROSECOND'", 
        "'MICROSECONDS'", "'MILLISECOND'", "'MILLISECONDS'", "'MINUTE'", 
        "'MINUTES'", "'MONTH'", "'MONTHS'", "'MSCK'", "'NAME'", "'NAMESPACE'", 
        "'NAMESPACES'", "'NANOSECOND'", "'NANOSECONDS'", "'NATURAL'", "'NO'", 
        "'NOSCAN'", "'NOT'", "'NULL'", "'NULLS'", "'NUMERIC'", "'OF'", "'OFFSET'", 
        "'ON'", "'ONLY'", "'OPTIMIZE'", "'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'", "'REWRITE'", "'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'", 
        "'ZORDER'", null, "'<=>'", "'<>'", "'!='", "'<'", null, "'>'", null, 
        "'!'", "'+'", "'-'", "'*'", "'/'", "'%'", "'~'", "'&'", "'|'", "'||'", 
        "'^'", "':'", "'->'", "'=>'", "'/*+'", "'*/'", "'?'"
    ];

    public static readonly symbolicNames = [
        null, "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_DISABLE", "KW_DISTINCT", 
        "KW_DISTRIBUTE", "KW_DIV", "KW_DOUBLE", "KW_DROP", "KW_ELSE", "KW_ENABLE", 
        "KW_END", "KW_ESCAPE", "KW_ESCAPED", "KW_EXCEPT", "KW_EXCHANGE", 
        "KW_EXCLUDE", "KW_EXISTS", "KW_EXPLAIN", "KW_EXPORT", "KW_EXTENDED", 
        "KW_EXTERNAL", "KW_EXTRACT", "KW_FALSE", "KW_FETCH", "KW_FIELDS", 
        "KW_FILTER", "KW_FILEFORMAT", "KW_FIRST", "KW_FLOAT", "KW_FOLLOWING", 
        "KW_FOR", "KW_FOREIGN", "KW_FORMAT", "KW_FORMATTED", "KW_FROM", 
        "KW_FULL", "KW_FUNCTION", "KW_FUNCTIONS", "KW_GENERATED", "KW_GLOBAL", 
        "KW_GRANT", "KW_GROUP", "KW_GROUPING", "KW_HAVING", "KW_BINARY_HEX", 
        "KW_HOUR", "KW_HOURS", "KW_IDENTIFIER", "KW_IF", "KW_IGNORE", "KW_IMPORT", 
        "KW_IN", "KW_INCLUDE", "KW_INDEX", "KW_INDEXES", "KW_INNER", "KW_INPATH", 
        "KW_INPUTFORMAT", "KW_INSERT", "KW_INTERSECT", "KW_INTERVAL", "KW_INT", 
        "KW_INTEGER", "KW_INTO", "KW_IS", "KW_ITEMS", "KW_JOIN", "KW_KEYS", 
        "KW_LAST", "KW_LATERAL", "KW_LAZY", "KW_LEADING", "KW_LEFT", "KW_LIFECYCLE", 
        "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_MATERIALIZED", "KW_MAP", "KW_MATCHED", 
        "KW_MERGE", "KW_MICROSECOND", "KW_MICROSECONDS", "KW_MILLISECOND", 
        "KW_MILLISECONDS", "KW_MINUTE", "KW_MINUTES", "KW_MONTH", "KW_MONTHS", 
        "KW_MSCK", "KW_NAME", "KW_NAMESPACE", "KW_NAMESPACES", "KW_NANOSECOND", 
        "KW_NANOSECONDS", "KW_NATURAL", "KW_NO", "KW_NOSCAN", "KW_NOT", 
        "KW_NULL", "KW_NULLS", "KW_NUMERIC", "KW_OF", "KW_OFFSET", "KW_ON", 
        "KW_ONLY", "KW_OPTIMIZE", "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_REWRITE", "KW_REVOKE", "KW_RIGHT", "KW_RLIKE", "KW_REGEXP", 
        "KW_ROLE", "KW_ROLES", "KW_ROLLBACK", "KW_ROLLUP", "KW_ROW", "KW_ROWS", 
        "KW_SECOND", "KW_SECONDS", "KW_SCHEMA", "KW_SCHEMAS", "KW_SELECT", 
        "KW_SEMI", "KW_SEPARATED", "KW_SERDE", "KW_SERDEPROPERTIES", "KW_SESSION_USER", 
        "KW_SET", "KW_MINUS", "KW_SETS", "KW_SHORT", "KW_SHOW", "KW_SINGLE", 
        "KW_SKEWED", "KW_SMALLINT", "KW_SOME", "KW_SORT", "KW_SORTED", "KW_SOURCE", 
        "KW_START", "KW_STATISTICS", "KW_STORED", "KW_STRATIFY", "KW_STRING", 
        "KW_STRUCT", "KW_SUBSTR", "KW_SUBSTRING", "KW_SYNC", "KW_SYSTEM", 
        "KW_SYSTEM_TIME", "KW_SYSTEM_VERSION", "KW_TABLE", "KW_TABLES", 
        "KW_TABLESAMPLE", "KW_TARGET", "KW_TBLPROPERTIES", "KW_TEMPORARY", 
        "KW_TERMINATED", "KW_THEN", "KW_TIME", "KW_TIMEDIFF", "KW_TIMESTAMP", 
        "KW_TIMESTAMP_LTZ", "KW_TIMESTAMP_NTZ", "KW_TIMESTAMPADD", "KW_TIMESTAMPDIFF", 
        "KW_TINYINT", "KW_TO", "KW_TOUCH", "KW_TRAILING", "KW_TRANSACTION", 
        "KW_TRANSACTIONS", "KW_TRANSFORM", "KW_TRIM", "KW_TRUE", "KW_TRUNCATE", 
        "KW_TRY_CAST", "KW_TYPE", "KW_UNARCHIVE", "KW_UNBOUNDED", "KW_UNCACHE", 
        "KW_UNION", "KW_UNIQUE", "KW_UNKNOWN", "KW_UNLOCK", "KW_UNPIVOT", 
        "KW_UNSET", "KW_UPDATE", "KW_USE", "KW_USER", "KW_USING", "KW_VALUES", 
        "KW_VARCHAR", "KW_VAR", "KW_VARIABLE", "KW_VERSION", "KW_VIEW", 
        "KW_VIEWS", "KW_VOID", "KW_WEEK", "KW_WEEKS", "KW_WHEN", "KW_WHERE", 
        "KW_WINDOW", "KW_WITH", "KW_WITHIN", "KW_YEAR", "KW_YEARS", "KW_ZONE", 
        "KW_ZORDER", "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 ruleNames = [
        "program", "singleStatement", "statement", "timezone", "configKey", 
        "configValue", "unsupportedHiveNativeCommands", "createTableHeader", 
        "replaceTableHeader", "bucketSpec", "skewSpec", "locationSpec", 
        "commentSpec", "query", "insertInto", "partitionSpecLocation", "partitionSpec", 
        "partitionVal", "namespace", "namespaces", "describeFuncName", "describeColName", 
        "ctes", "namedQuery", "tableProvider", "createTableClauses", "tableLifecycle", 
        "propertyList", "property", "propertyKey", "propertyValue", "expressionPropertyList", 
        "expressionProperty", "constantList", "nestedConstantList", "createFileFormat", 
        "fileFormat", "storageHandler", "resource", "dmlStatementNoWith", 
        "namespaceName", "namespaceNameCreate", "tableNameCreate", "tableName", 
        "viewNameCreate", "viewName", "columnName", "columnNameSeq", "columnNameCreate", 
        "identifierReference", "queryOrganization", "multiInsertQueryBody", 
        "queryTerm", "queryPrimary", "sortItem", "fromStatement", "fromStatementBody", 
        "querySpecification", "transformClause", "selectClause", "setClause", 
        "matchedClause", "notMatchedClause", "notMatchedBySourceClause", 
        "matchedAction", "notMatchedAction", "notMatchedBySourceAction", 
        "assignmentList", "assignment", "whereClause", "havingClause", "hint", 
        "hintStatement", "fromClause", "functionKind", "temporalClause", 
        "aggregationClause", "groupByClause", "groupingAnalytics", "groupingElement", 
        "groupingSet", "pivotClause", "pivotColumn", "pivotValue", "unpivotClause", 
        "unpivotNullClause", "unpivotOperator", "unpivotSingleValueColumnClause", 
        "unpivotMultiValueColumnClause", "unpivotColumnSet", "unpivotValueColumn", 
        "unpivotNameColumn", "unpivotColumnAndAlias", "unpivotColumn", "unpivotAlias", 
        "ifNotExists", "ifExists", "lateralView", "setQuantifier", "relation", 
        "relationExtension", "joinRelation", "joinType", "joinCriteria", 
        "sample", "sampleMethod", "identifierList", "identifierSeq", "orderedIdentifierList", 
        "orderedIdentifier", "identifierCommentList", "identifierComment", 
        "relationPrimary", "inlineTable", "functionTableSubqueryArgument", 
        "tableArgumentPartitioning", "functionTableNamedArgumentExpression", 
        "functionTableReferenceArgument", "functionTableArgument", "functionTable", 
        "tableAlias", "rowFormat", "multipartIdentifierList", "multipartIdentifier", 
        "multipartIdentifierPropertyList", "multipartIdentifierProperty", 
        "tableIdentifier", "viewIdentifier", "namedExpression", "namedExpressionSeq", 
        "partitionFieldList", "partitionField", "transform", "transformArgument", 
        "expression", "namedArgumentExpression", "functionArgument", "expressionSeq", 
        "booleanExpression", "predicate", "valueExpression", "datetimeUnit", 
        "primaryExpression", "literalType", "constant", "comparisonOperator", 
        "arithmeticOperator", "predicateOperator", "booleanValue", "interval", 
        "errorCapturingMultiUnitsInterval", "multiUnitsInterval", "errorCapturingUnitToUnitInterval", 
        "unitToUnitInterval", "intervalValue", "unitInMultiUnits", "unitInUnitToUnit", 
        "colPosition", "type", "dataType", "qualifiedColTypeWithPositionSeqForAdd", 
        "qualifiedColTypeWithPositionForAdd", "qualifiedColTypeWithPositionSeqForReplace", 
        "qualifiedColTypeWithPositionForReplace", "colDefinitionDescriptorWithPosition", 
        "defaultExpression", "variableDefaultExpression", "colTypeList", 
        "colType", "createOrReplaceTableColTypeList", "createOrReplaceTableColType", 
        "colDefinitionOption", "generationExpression", "complexColTypeList", 
        "complexColType", "whenClause", "windowClause", "zorderClause", 
        "namedWindow", "windowSpec", "windowFrame", "frameBound", "qualifiedNameList", 
        "functionName", "functionNameCreate", "qualifiedName", "errorCapturingIdentifier", 
        "errorCapturingIdentifierExtra", "identifier", "strictIdentifier", 
        "quotedIdentifier", "backQuotedIdentifier", "number", "alterColumnAction", 
        "stringLit", "comment", "version", "ansiNonReserved", "strictNonReserved", 
        "nonReserved",
    ];

    public get grammarFileName(): string { return "SparkSqlParser.g4"; }
    public get literalNames(): (string | null)[] { return SparkSqlParser.literalNames; }
    public get symbolicNames(): (string | null)[] { return SparkSqlParser.symbolicNames; }
    public get ruleNames(): string[] { return SparkSqlParser.ruleNames; }
    public get serializedATN(): number[] { return SparkSqlParser._serializedATN; }

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

    public constructor(input: antlr.TokenStream) {
        super(input);
        this.interpreter = new antlr.ParserATNSimulator(this, SparkSqlParser._ATN, SparkSqlParser.decisionsToDFA, new antlr.PredictionContextCache());
    }
    public program(): ProgramContext {
        let localContext = new ProgramContext(this.context, this.state);
        this.enterRule(localContext, 0, SparkSqlParser.RULE_program);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 403;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 10500) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & 67896321) !== 0) || ((((_la - 81)) & ~0x1F) === 0 && ((1 << (_la - 81)) & 100696297) !== 0) || ((((_la - 123)) & ~0x1F) === 0 && ((1 << (_la - 123)) & 16842817) !== 0) || ((((_la - 167)) & ~0x1F) === 0 && ((1 << (_la - 167)) & 2102291) !== 0) || _la === 205 || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & 2181171413) !== 0) || ((((_la - 273)) & ~0x1F) === 0 && ((1 << (_la - 273)) & 1048833) !== 0) || ((((_la - 317)) & ~0x1F) === 0 && ((1 << (_la - 317)) & 536949281) !== 0)) {
                {
                {
                this.state = 400;
                this.singleStatement();
                }
                }
                this.state = 405;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 406;
            this.match(SparkSqlParser.EOF);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public singleStatement(): SingleStatementContext {
        let localContext = new SingleStatementContext(this.context, this.state);
        this.enterRule(localContext, 2, SparkSqlParser.RULE_singleStatement);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 408;
            this.statement();
            this.state = 410;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 1) {
                {
                this.state = 409;
                this.match(SparkSqlParser.SEMICOLON);
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public statement(): StatementContext {
        let localContext = new StatementContext(this.context, this.state);
        this.enterRule(localContext, 4, SparkSqlParser.RULE_statement);
        let _la: number;
        try {
            let alternative: number;
            this.state = 1337;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 144, this.context) ) {
            case 1:
                localContext = new StatementDefaultContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 412;
                this.query();
                }
                break;
            case 2:
                localContext = new DmlStatementContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 414;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 346) {
                    {
                    this.state = 413;
                    this.ctes();
                    }
                }

                this.state = 416;
                this.dmlStatementNoWith();
                }
                break;
            case 3:
                localContext = new UseNamespaceContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 417;
                this.match(SparkSqlParser.KW_USE);
                this.state = 419;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 3, this.context) ) {
                case 1:
                    {
                    this.state = 418;
                    this.namespace();
                    }
                    break;
                }
                this.state = 421;
                this.namespaceName();
                }
                break;
            case 4:
                localContext = new SetCatalogContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 422;
                this.match(SparkSqlParser.KW_SET);
                this.state = 423;
                this.match(SparkSqlParser.KW_CATALOG);
                this.state = 426;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 4, this.context) ) {
                case 1:
                    {
                    this.state = 424;
                    this.identifier();
                    }
                    break;
                case 2:
                    {
                    this.state = 425;
                    this.stringLit();
                    }
                    break;
                }
                }
                break;
            case 5:
                localContext = new CreateNamespaceContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 428;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 429;
                this.namespace();
                this.state = 431;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 5, this.context) ) {
                case 1:
                    {
                    this.state = 430;
                    this.ifNotExists();
                    }
                    break;
                }
                this.state = 433;
                this.namespaceNameCreate();
                this.state = 441;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 7, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        this.state = 439;
                        this.errorHandler.sync(this);
                        switch (this.tokenStream.LA(1)) {
                        case SparkSqlParser.KW_COMMENT:
                            {
                            this.state = 434;
                            this.commentSpec();
                            }
                            break;
                        case SparkSqlParser.KW_LOCATION:
                            {
                            this.state = 435;
                            this.locationSpec();
                            }
                            break;
                        case SparkSqlParser.KW_WITH:
                            {
                            {
                            this.state = 436;
                            this.match(SparkSqlParser.KW_WITH);
                            this.state = 437;
                            _la = this.tokenStream.LA(1);
                            if(!(_la === 78 || _la === 229)) {
                            this.errorHandler.recoverInline(this);
                            }
                            else {
                                this.errorHandler.reportMatch(this);
                                this.consume();
                            }
                            this.state = 438;
                            this.propertyList();
                            }
                            }
                            break;
                        default:
                            throw new antlr.NoViableAltException(this);
                        }
                        }
                    }
                    this.state = 443;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 7, this.context);
                }
                }
                break;
            case 6:
                localContext = new SetNamespacePropertiesContext(localContext);
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 444;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 445;
                this.namespace();
                this.state = 446;
                this.namespaceName();
                this.state = 447;
                this.match(SparkSqlParser.KW_SET);
                this.state = 448;
                _la = this.tokenStream.LA(1);
                if(!(_la === 78 || _la === 229)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 449;
                this.propertyList();
                }
                break;
            case 7:
                localContext = new SetNamespaceLocationContext(localContext);
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 451;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 452;
                this.namespace();
                this.state = 453;
                this.namespaceName();
                this.state = 454;
                this.match(SparkSqlParser.KW_SET);
                this.state = 455;
                this.locationSpec();
                }
                break;
            case 8:
                localContext = new DropNamespaceContext(localContext);
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 457;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 458;
                this.namespace();
                this.state = 460;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 8, this.context) ) {
                case 1:
                    {
                    this.state = 459;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 462;
                this.namespaceName();
                this.state = 464;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 34 || _la === 247) {
                    {
                    this.state = 463;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 34 || _la === 247)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    }
                }

                }
                break;
            case 9:
                localContext = new ShowNamespacesContext(localContext);
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 466;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 467;
                this.namespaces();
                this.state = 470;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 10, this.context) ) {
                case 1:
                    {
                    this.state = 468;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 469;
                    this.multipartIdentifier();
                    }
                    break;
                }
                this.state = 476;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 163 || _la === 377 || _la === 378) {
                    {
                    this.state = 473;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 163) {
                        {
                        this.state = 472;
                        this.match(SparkSqlParser.KW_LIKE);
                        }
                    }

                    this.state = 475;
                    (localContext as ShowNamespacesContext)._pattern = this.stringLit();
                    }
                }

                }
                break;
            case 10:
                localContext = new CreateTableContext(localContext);
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 478;
                this.createTableHeader();
                this.state = 483;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 13, this.context) ) {
                case 1:
                    {
                    this.state = 479;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 480;
                    this.createOrReplaceTableColTypeList();
                    this.state = 481;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                this.state = 486;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 332) {
                    {
                    this.state = 485;
                    this.tableProvider();
                    }
                }

                this.state = 488;
                this.createTableClauses();
                this.state = 493;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 16, this.context) ) {
                case 1:
                    {
                    this.state = 490;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 20) {
                        {
                        this.state = 489;
                        this.match(SparkSqlParser.KW_AS);
                        }
                    }

                    this.state = 492;
                    this.query();
                    }
                    break;
                }
                }
                break;
            case 11:
                localContext = new CreateTableLikeContext(localContext);
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 495;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 496;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 498;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 17, this.context) ) {
                case 1:
                    {
                    this.state = 497;
                    this.ifNotExists();
                    }
                    break;
                }
                this.state = 500;
                (localContext as CreateTableLikeContext)._target = this.tableNameCreate();
                this.state = 501;
                this.match(SparkSqlParser.KW_LIKE);
                this.state = 502;
                (localContext as CreateTableLikeContext)._source = this.tableName();
                this.state = 512;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 162 || _la === 170 || _la === 257 || _la === 283 || _la === 297 || _la === 332) {
                    {
                    this.state = 510;
                    this.errorHandler.sync(this);
                    switch (this.tokenStream.LA(1)) {
                    case SparkSqlParser.KW_USING:
                        {
                        this.state = 503;
                        this.tableProvider();
                        }
                        break;
                    case SparkSqlParser.KW_ROW:
                        {
                        this.state = 504;
                        this.rowFormat();
                        }
                        break;
                    case SparkSqlParser.KW_STORED:
                        {
                        this.state = 505;
                        this.createFileFormat();
                        }
                        break;
                    case SparkSqlParser.KW_LOCATION:
                        {
                        this.state = 506;
                        this.locationSpec();
                        }
                        break;
                    case SparkSqlParser.KW_TBLPROPERTIES:
                        {
                        {
                        this.state = 507;
                        this.match(SparkSqlParser.KW_TBLPROPERTIES);
                        this.state = 508;
                        (localContext as CreateTableLikeContext)._tableProps = this.propertyList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_LIFECYCLE:
                        {
                        this.state = 509;
                        this.tableLifecycle();
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    }
                    this.state = 514;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
                break;
            case 12:
                localContext = new ReplaceTableContext(localContext);
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 515;
                this.replaceTableHeader();
                this.state = 520;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 20, this.context) ) {
                case 1:
                    {
                    this.state = 516;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 517;
                    this.createOrReplaceTableColTypeList();
                    this.state = 518;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                this.state = 523;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 332) {
                    {
                    this.state = 522;
                    this.tableProvider();
                    }
                }

                this.state = 525;
                this.createTableClauses();
                this.state = 530;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 23, this.context) ) {
                case 1:
                    {
                    this.state = 527;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 20) {
                        {
                        this.state = 526;
                        this.match(SparkSqlParser.KW_AS);
                        }
                    }

                    this.state = 529;
                    this.query();
                    }
                    break;
                }
                }
                break;
            case 13:
                localContext = new AnalyzeContext(localContext);
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 532;
                this.match(SparkSqlParser.KW_ANALYZE);
                this.state = 533;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 534;
                this.tableName();
                this.state = 536;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 535;
                    this.partitionSpec();
                    }
                }

                this.state = 538;
                this.match(SparkSqlParser.KW_COMPUTE);
                this.state = 539;
                this.match(SparkSqlParser.KW_STATISTICS);
                this.state = 547;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 25, this.context) ) {
                case 1:
                    {
                    this.state = 540;
                    this.match(SparkSqlParser.KW_NOSCAN);
                    }
                    break;
                case 2:
                    {
                    this.state = 541;
                    this.match(SparkSqlParser.KW_FOR);
                    this.state = 542;
                    this.match(SparkSqlParser.KW_COLUMNS);
                    this.state = 543;
                    this.columnNameSeq();
                    }
                    break;
                case 3:
                    {
                    this.state = 544;
                    this.match(SparkSqlParser.KW_FOR);
                    this.state = 545;
                    this.match(SparkSqlParser.KW_ALL);
                    this.state = 546;
                    this.match(SparkSqlParser.KW_COLUMNS);
                    }
                    break;
                }
                }
                break;
            case 14:
                localContext = new AnalyzeTablesContext(localContext);
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 549;
                this.match(SparkSqlParser.KW_ANALYZE);
                this.state = 550;
                this.match(SparkSqlParser.KW_TABLES);
                this.state = 553;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 123 || _la === 140) {
                    {
                    this.state = 551;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 552;
                    this.namespaceName();
                    }
                }

                this.state = 555;
                this.match(SparkSqlParser.KW_COMPUTE);
                this.state = 556;
                this.match(SparkSqlParser.KW_STATISTICS);
                this.state = 558;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 196) {
                    {
                    this.state = 557;
                    this.match(SparkSqlParser.KW_NOSCAN);
                    }
                }

                }
                break;
            case 15:
                localContext = new AlterTableAddColumnContext(localContext);
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 560;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 561;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 562;
                this.tableName();
                this.state = 563;
                this.match(SparkSqlParser.KW_ADD);
                this.state = 564;
                this.match(SparkSqlParser.KW_COLUMN);
                this.state = 565;
                this.qualifiedColTypeWithPositionForAdd();
                }
                break;
            case 16:
                localContext = new AlterTableAddColumnsContext(localContext);
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 567;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 568;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 569;
                this.tableName();
                this.state = 570;
                this.match(SparkSqlParser.KW_ADD);
                this.state = 571;
                this.match(SparkSqlParser.KW_COLUMNS);
                this.state = 572;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 573;
                this.qualifiedColTypeWithPositionSeqForAdd();
                this.state = 574;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 17:
                localContext = new RenameTableColumnContext(localContext);
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 576;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 577;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 578;
                (localContext as RenameTableColumnContext)._table = this.tableName();
                this.state = 579;
                this.match(SparkSqlParser.KW_RENAME);
                this.state = 580;
                this.match(SparkSqlParser.KW_COLUMN);
                this.state = 581;
                this.columnName();
                this.state = 582;
                this.match(SparkSqlParser.KW_TO);
                this.state = 583;
                this.columnNameCreate();
                }
                break;
            case 18:
                localContext = new AlterTableDropColumnContext(localContext);
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 585;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 586;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 587;
                this.tableName();
                this.state = 588;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 589;
                this.match(SparkSqlParser.KW_COLUMN);
                this.state = 591;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 28, this.context) ) {
                case 1:
                    {
                    this.state = 590;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 593;
                this.columnName();
                }
                break;
            case 19:
                localContext = new DropTableColumnsContext(localContext);
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 595;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 596;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 597;
                this.tableName();
                this.state = 598;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 599;
                this.match(SparkSqlParser.KW_COLUMNS);
                this.state = 601;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 137) {
                    {
                    this.state = 600;
                    this.ifExists();
                    }
                }

                this.state = 603;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 604;
                this.columnNameSeq();
                this.state = 605;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 20:
                localContext = new RenameTableContext(localContext);
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 607;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 612;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_TABLE:
                    {
                    this.state = 608;
                    this.match(SparkSqlParser.KW_TABLE);
                    this.state = 609;
                    this.tableName();
                    }
                    break;
                case SparkSqlParser.KW_VIEW:
                    {
                    this.state = 610;
                    this.match(SparkSqlParser.KW_VIEW);
                    this.state = 611;
                    this.viewName();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 614;
                this.match(SparkSqlParser.KW_RENAME);
                this.state = 615;
                this.match(SparkSqlParser.KW_TO);
                this.state = 616;
                this.multipartIdentifier();
                }
                break;
            case 21:
                localContext = new SetTablePropertiesContext(localContext);
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 618;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 623;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_TABLE:
                    {
                    this.state = 619;
                    this.match(SparkSqlParser.KW_TABLE);
                    this.state = 620;
                    this.tableName();
                    }
                    break;
                case SparkSqlParser.KW_VIEW:
                    {
                    this.state = 621;
                    this.match(SparkSqlParser.KW_VIEW);
                    this.state = 622;
                    this.viewName();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 625;
                this.match(SparkSqlParser.KW_SET);
                this.state = 626;
                this.match(SparkSqlParser.KW_TBLPROPERTIES);
                this.state = 627;
                this.propertyList();
                }
                break;
            case 22:
                localContext = new UnsetTablePropertiesContext(localContext);
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 629;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 634;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_TABLE:
                    {
                    this.state = 630;
                    this.match(SparkSqlParser.KW_TABLE);
                    this.state = 631;
                    this.tableName();
                    }
                    break;
                case SparkSqlParser.KW_VIEW:
                    {
                    this.state = 632;
                    this.match(SparkSqlParser.KW_VIEW);
                    this.state = 633;
                    this.viewName();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 636;
                this.match(SparkSqlParser.KW_UNSET);
                this.state = 637;
                this.match(SparkSqlParser.KW_TBLPROPERTIES);
                this.state = 639;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 137) {
                    {
                    this.state = 638;
                    this.ifExists();
                    }
                }

                this.state = 641;
                this.propertyList();
                }
                break;
            case 23:
                localContext = new AlterTableAlterColumnContext(localContext);
                this.enterOuterAlt(localContext, 23);
                {
                this.state = 643;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 644;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 645;
                (localContext as AlterTableAlterColumnContext)._table = this.tableName();
                this.state = 646;
                _la = this.tokenStream.LA(1);
                if(!(_la === 11 || _la === 39)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 648;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 34, this.context) ) {
                case 1:
                    {
                    this.state = 647;
                    this.match(SparkSqlParser.KW_COLUMN);
                    }
                    break;
                }
                this.state = 650;
                (localContext as AlterTableAlterColumnContext)._column = this.columnName();
                this.state = 652;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 35, this.context) ) {
                case 1:
                    {
                    this.state = 651;
                    this.alterColumnAction();
                    }
                    break;
                }
                }
                break;
            case 24:
                localContext = new HiveChangeColumnContext(localContext);
                this.enterOuterAlt(localContext, 24);
                {
                this.state = 654;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 655;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 656;
                (localContext as HiveChangeColumnContext)._table = this.tableName();
                this.state = 658;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 657;
                    this.partitionSpec();
                    }
                }

                this.state = 660;
                this.match(SparkSqlParser.KW_CHANGE);
                this.state = 662;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 37, this.context) ) {
                case 1:
                    {
                    this.state = 661;
                    this.match(SparkSqlParser.KW_COLUMN);
                    }
                    break;
                }
                this.state = 664;
                (localContext as HiveChangeColumnContext)._colName = this.columnName();
                this.state = 665;
                this.colType();
                this.state = 667;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 9 || _la === 116) {
                    {
                    this.state = 666;
                    this.colPosition();
                    }
                }

                }
                break;
            case 25:
                localContext = new HiveReplaceColumnsContext(localContext);
                this.enterOuterAlt(localContext, 25);
                {
                this.state = 669;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 670;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 671;
                (localContext as HiveReplaceColumnsContext)._table = this.tableName();
                this.state = 673;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 672;
                    this.partitionSpec();
                    }
                }

                this.state = 675;
                this.match(SparkSqlParser.KW_REPLACE);
                this.state = 676;
                this.match(SparkSqlParser.KW_COLUMNS);
                this.state = 677;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 678;
                this.qualifiedColTypeWithPositionSeqForReplace();
                this.state = 679;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 26:
                localContext = new SetTableSerDeContext(localContext);
                this.enterOuterAlt(localContext, 26);
                {
                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.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 684;
                    this.partitionSpec();
                    }
                }

                this.state = 687;
                this.match(SparkSqlParser.KW_SET);
                this.state = 688;
                this.match(SparkSqlParser.KW_SERDE);
                this.state = 689;
                this.stringLit();
                this.state = 693;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 41, this.context) ) {
                case 1:
                    {
                    this.state = 690;
                    this.match(SparkSqlParser.KW_WITH);
                    this.state = 691;
                    this.match(SparkSqlParser.KW_SERDEPROPERTIES);
                    this.state = 692;
                    this.propertyList();
                    }
                    break;
                }
                }
                break;
            case 27:
                localContext = new SetTableSerDePropertiesContext(localContext);
                this.enterOuterAlt(localContext, 27);
                {
                this.state = 695;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 696;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 697;
                this.tableName();
                this.state = 699;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 698;
                    this.partitionSpec();
                    }
                }

                this.state = 701;
                this.match(SparkSqlParser.KW_SET);
                this.state = 702;
                this.match(SparkSqlParser.KW_SERDEPROPERTIES);
                this.state = 703;
                this.propertyList();
                }
                break;
            case 28:
                localContext = new AddTablePartitionContext(localContext);
                this.enterOuterAlt(localContext, 28);
                {
                this.state = 705;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 710;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_TABLE:
                    {
                    this.state = 706;
                    this.match(SparkSqlParser.KW_TABLE);
                    this.state = 707;
                    this.tableName();
                    }
                    break;
                case SparkSqlParser.KW_VIEW:
                    {
                    this.state = 708;
                    this.match(SparkSqlParser.KW_VIEW);
                    this.state = 709;
                    this.viewName();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 712;
                this.match(SparkSqlParser.KW_ADD);
                this.state = 714;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 137) {
                    {
                    this.state = 713;
                    this.ifNotExists();
                    }
                }

                this.state = 717;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                do {
                    {
                    {
                    this.state = 716;
                    this.partitionSpecLocation();
                    }
                    }
                    this.state = 719;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                } while (_la === 217);
                }
                break;
            case 29:
                localContext = new RenameTablePartitionContext(localContext);
                this.enterOuterAlt(localContext, 29);
                {
                this.state = 721;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 722;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 723;
                this.tableName();
                this.state = 724;
                this.partitionSpec();
                this.state = 725;
                this.match(SparkSqlParser.KW_RENAME);
                this.state = 726;
                this.match(SparkSqlParser.KW_TO);
                this.state = 727;
                this.partitionSpec();
                }
                break;
            case 30:
                localContext = new DropTablePartitionsContext(localContext);
                this.enterOuterAlt(localContext, 30);
                {
                this.state = 729;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 734;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_TABLE:
                    {
                    this.state = 730;
                    this.match(SparkSqlParser.KW_TABLE);
                    this.state = 731;
                    this.tableName();
                    }
                    break;
                case SparkSqlParser.KW_VIEW:
                    {
                    this.state = 732;
                    this.match(SparkSqlParser.KW_VIEW);
                    this.state = 733;
                    this.viewName();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 736;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 738;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 137) {
                    {
                    this.state = 737;
                    this.ifExists();
                    }
                }

                this.state = 740;
                this.partitionSpec();
                this.state = 745;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 741;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 742;
                    this.partitionSpec();
                    }
                    }
                    this.state = 747;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 749;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 230) {
                    {
                    this.state = 748;
                    this.match(SparkSqlParser.KW_PURGE);
                    }
                }

                }
                break;
            case 31:
                localContext = new SetTableLocationContext(localContext);
                this.enterOuterAlt(localContext, 31);
                {
                this.state = 751;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 752;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 753;
                this.tableName();
                this.state = 755;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 754;
                    this.partitionSpec();
                    }
                }

                this.state = 757;
                this.match(SparkSqlParser.KW_SET);
                this.state = 758;
                this.locationSpec();
                }
                break;
            case 32:
                localContext = new RecoverPartitionsContext(localContext);
                this.enterOuterAlt(localContext, 32);
                {
                this.state = 760;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 761;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 762;
                this.tableName();
                this.state = 763;
                this.match(SparkSqlParser.KW_RECOVER);
                this.state = 764;
                this.match(SparkSqlParser.KW_PARTITIONS);
                }
                break;
            case 33:
                localContext = new AlterMaterializedViewRewriteContext(localContext);
                this.enterOuterAlt(localContext, 33);
                {
                this.state = 766;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 767;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 768;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 769;
                this.viewName();
                this.state = 770;
                _la = this.tokenStream.LA(1);
                if(!(_la === 91 || _la === 98)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 771;
                this.match(SparkSqlParser.KW_REWRITE);
                }
                break;
            case 34:
                localContext = new AlterMaterializedViewPropertiesContext(localContext);
                this.enterOuterAlt(localContext, 34);
                {
                this.state = 773;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 774;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 775;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 776;
                this.viewName();
                this.state = 777;
                this.match(SparkSqlParser.KW_SET);
                this.state = 778;
                this.match(SparkSqlParser.KW_TBLPROPERTIES);
                this.state = 779;
                this.propertyList();
                }
                break;
            case 35:
                localContext = new DropTableContext(localContext);
                this.enterOuterAlt(localContext, 35);
                {
                this.state = 781;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 782;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 784;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 51, this.context) ) {
                case 1:
                    {
                    this.state = 783;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 786;
                this.tableName();
                this.state = 788;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 230) {
                    {
                    this.state = 787;
                    this.match(SparkSqlParser.KW_PURGE);
                    }
                }

                }
                break;
            case 36:
                localContext = new DropViewContext(localContext);
                this.enterOuterAlt(localContext, 36);
                {
                this.state = 790;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 791;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 793;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 53, this.context) ) {
                case 1:
                    {
                    this.state = 792;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 795;
                this.viewName();
                }
                break;
            case 37:
                localContext = new DropMaterializedViewContext(localContext);
                this.enterOuterAlt(localContext, 37);
                {
                this.state = 796;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 797;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 798;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 800;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 54, this.context) ) {
                case 1:
                    {
                    this.state = 799;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 802;
                this.viewName();
                }
                break;
            case 38:
                localContext = new CreateViewContext(localContext);
                this.enterOuterAlt(localContext, 38);
                {
                this.state = 803;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 806;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 208) {
                    {
                    this.state = 804;
                    this.match(SparkSqlParser.KW_OR);
                    this.state = 805;
                    this.match(SparkSqlParser.KW_REPLACE);
                    }
                }

                this.state = 812;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 128 || _la === 298) {
                    {
                    this.state = 809;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 128) {
                        {
                        this.state = 808;
                        this.match(SparkSqlParser.KW_GLOBAL);
                        }
                    }

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

                this.state = 814;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 816;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 58, this.context) ) {
                case 1:
                    {
                    this.state = 815;
                    this.ifNotExists();
                    }
                    break;
                }
                this.state = 818;
                this.viewNameCreate();
                this.state = 820;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 2) {
                    {
                    this.state = 819;
                    this.identifierCommentList();
                    }
                }

                this.state = 830;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 51 || _la === 218 || _la === 297) {
                    {
                    this.state = 828;
                    this.errorHandler.sync(this);
                    switch (this.tokenStream.LA(1)) {
                    case SparkSqlParser.KW_COMMENT:
                        {
                        this.state = 822;
                        this.commentSpec();
                        }
                        break;
                    case SparkSqlParser.KW_PARTITIONED:
                        {
                        {
                        this.state = 823;
                        this.match(SparkSqlParser.KW_PARTITIONED);
                        this.state = 824;
                        this.match(SparkSqlParser.KW_ON);
                        this.state = 825;
                        this.identifierList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_TBLPROPERTIES:
                        {
                        {
                        this.state = 826;
                        this.match(SparkSqlParser.KW_TBLPROPERTIES);
                        this.state = 827;
                        this.propertyList();
                        }
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    }
                    this.state = 832;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 833;
                this.match(SparkSqlParser.KW_AS);
                this.state = 834;
                this.query();
                }
                break;
            case 39:
                localContext = new CreateTempViewUsingContext(localContext);
                this.enterOuterAlt(localContext, 39);
                {
                this.state = 836;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 839;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 208) {
                    {
                    this.state = 837;
                    this.match(SparkSqlParser.KW_OR);
                    this.state = 838;
                    this.match(SparkSqlParser.KW_REPLACE);
                    }
                }

                this.state = 842;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 128) {
                    {
                    this.state = 841;
                    this.match(SparkSqlParser.KW_GLOBAL);
                    }
                }

                this.state = 844;
                this.match(SparkSqlParser.KW_TEMPORARY);
                this.state = 845;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 846;
                this.viewNameCreate();
                this.state = 851;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 2) {
                    {
                    this.state = 847;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 848;
                    this.colTypeList();
                    this.state = 849;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                }

                this.state = 853;
                this.tableProvider();
                this.state = 856;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 207) {
                    {
                    this.state = 854;
                    this.match(SparkSqlParser.KW_OPTIONS);
                    this.state = 855;
                    this.propertyList();
                    }
                }

                }
                break;
            case 40:
                localContext = new AlterViewQueryContext(localContext);
                this.enterOuterAlt(localContext, 40);
                {
                this.state = 858;
                this.match(SparkSqlParser.KW_ALTER);
                this.state = 859;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 860;
                this.viewName();
                this.state = 862;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20) {
                    {
                    this.state = 861;
                    this.match(SparkSqlParser.KW_AS);
                    }
                }

                this.state = 864;
                this.query();
                }
                break;
            case 41:
                localContext = new CreateFunctionContext(localContext);
                this.enterOuterAlt(localContext, 41);
                {
                this.state = 866;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 869;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 208) {
                    {
                    this.state = 867;
                    this.match(SparkSqlParser.KW_OR);
                    this.state = 868;
                    this.match(SparkSqlParser.KW_REPLACE);
                    }
                }

                this.state = 872;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 298) {
                    {
                    this.state = 871;
                    this.match(SparkSqlParser.KW_TEMPORARY);
                    }
                }

                this.state = 874;
                this.match(SparkSqlParser.KW_FUNCTION);
                this.state = 876;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 69, this.context) ) {
                case 1:
                    {
                    this.state = 875;
                    this.ifNotExists();
                    }
                    break;
                }
                this.state = 878;
                this.functionNameCreate();
                this.state = 879;
                this.match(SparkSqlParser.KW_AS);
                this.state = 880;
                (localContext as CreateFunctionContext)._className = this.stringLit();
                this.state = 890;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 332) {
                    {
                    this.state = 881;
                    this.match(SparkSqlParser.KW_USING);
                    this.state = 882;
                    this.resource();
                    this.state = 887;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 883;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 884;
                        this.resource();
                        }
                        }
                        this.state = 889;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                }

                }
                break;
            case 42:
                localContext = new CreateMaterializedViewContext(localContext);
                this.enterOuterAlt(localContext, 42);
                {
                this.state = 892;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 893;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 894;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 896;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 72, this.context) ) {
                case 1:
                    {
                    this.state = 895;
                    this.ifNotExists();
                    }
                    break;
                }
                this.state = 898;
                this.viewNameCreate();
                this.state = 900;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 332) {
                    {
                    this.state = 899;
                    this.tableProvider();
                    }
                }

                this.state = 917;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 45 || _la === 51 || _la === 170 || _la === 207 || _la === 218 || ((((_la - 257)) & ~0x1F) === 0 && ((1 << (_la - 257)) & 67371009) !== 0) || _la === 297) {
                    {
                    this.state = 915;
                    this.errorHandler.sync(this);
                    switch (this.tokenStream.LA(1)) {
                    case SparkSqlParser.KW_OPTIONS:
                        {
                        {
                        this.state = 902;
                        this.match(SparkSqlParser.KW_OPTIONS);
                        this.state = 903;
                        (localContext as CreateMaterializedViewContext)._options = this.propertyList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_PARTITIONED:
                        {
                        {
                        this.state = 904;
                        this.match(SparkSqlParser.KW_PARTITIONED);
                        this.state = 905;
                        this.match(SparkSqlParser.KW_BY);
                        this.state = 906;
                        (localContext as CreateMaterializedViewContext)._partitioning = this.partitionFieldList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_SKEWED:
                        {
                        this.state = 907;
                        this.skewSpec();
                        }
                        break;
                    case SparkSqlParser.KW_CLUSTERED:
                        {
                        this.state = 908;
                        this.bucketSpec();
                        }
                        break;
                    case SparkSqlParser.KW_ROW:
                        {
                        this.state = 909;
                        this.rowFormat();
                        }
                        break;
                    case SparkSqlParser.KW_STORED:
                        {
                        this.state = 910;
                        this.createFileFormat();
                        }
                        break;
                    case SparkSqlParser.KW_LOCATION:
                        {
                        this.state = 911;
                        this.locationSpec();
                        }
                        break;
                    case SparkSqlParser.KW_COMMENT:
                        {
                        this.state = 912;
                        this.commentSpec();
                        }
                        break;
                    case SparkSqlParser.KW_TBLPROPERTIES:
                        {
                        {
                        this.state = 913;
                        this.match(SparkSqlParser.KW_TBLPROPERTIES);
                        this.state = 914;
                        (localContext as CreateMaterializedViewContext)._tableProps = this.propertyList();
                        }
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    }
                    this.state = 919;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 920;
                this.match(SparkSqlParser.KW_AS);
                this.state = 921;
                this.query();
                }
                break;
            case 43:
                localContext = new DropFunctionContext(localContext);
                this.enterOuterAlt(localContext, 43);
                {
                this.state = 923;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 925;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 298) {
                    {
                    this.state = 924;
                    this.match(SparkSqlParser.KW_TEMPORARY);
                    }
                }

                this.state = 927;
                this.match(SparkSqlParser.KW_FUNCTION);
                this.state = 929;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 77, this.context) ) {
                case 1:
                    {
                    this.state = 928;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 931;
                this.functionName();
                }
                break;
            case 44:
                localContext = new DeclareVariableContext(localContext);
                this.enterOuterAlt(localContext, 44);
                {
                this.state = 932;
                this.match(SparkSqlParser.KW_DECLARE);
                this.state = 935;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 78, this.context) ) {
                case 1:
                    {
                    this.state = 933;
                    this.match(SparkSqlParser.KW_OR);
                    this.state = 934;
                    this.match(SparkSqlParser.KW_REPLACE);
                    }
                    break;
                }
                this.state = 938;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 79, this.context) ) {
                case 1:
                    {
                    this.state = 937;
                    this.match(SparkSqlParser.KW_VARIABLE);
                    }
                    break;
                }
                this.state = 940;
                this.functionName();
                this.state = 942;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 80, this.context) ) {
                case 1:
                    {
                    this.state = 941;
                    this.dataType();
                    }
                    break;
                }
                this.state = 945;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 82 || _la === 352) {
                    {
                    this.state = 944;
                    this.variableDefaultExpression();
                    }
                }

                }
                break;
            case 45:
                localContext = new DropVariableContext(localContext);
                this.enterOuterAlt(localContext, 45);
                {
                this.state = 947;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 948;
                this.match(SparkSqlParser.KW_TEMPORARY);
                this.state = 949;
                this.match(SparkSqlParser.KW_VARIABLE);
                this.state = 951;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 82, this.context) ) {
                case 1:
                    {
                    this.state = 950;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 956;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 83, this.context) ) {
                case 1:
                    {
                    this.state = 953;
                    this.tableName();
                    }
                    break;
                case 2:
                    {
                    this.state = 954;
                    this.viewName();
                    }
                    break;
                case 3:
                    {
                    this.state = 955;
                    this.functionName();
                    }
                    break;
                }
                }
                break;
            case 46:
                localContext = new ExplainStatementContext(localContext);
                this.enterOuterAlt(localContext, 46);
                {
                this.state = 958;
                this.match(SparkSqlParser.KW_EXPLAIN);
                this.state = 960;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 46 || _la === 58 || _la === 108 || _la === 122 || _la === 173) {
                    {
                    this.state = 959;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 46 || _la === 58 || _la === 108 || _la === 122 || _la === 173)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    }
                }

                this.state = 962;
                this.statement();
                }
                break;
            case 47:
                localContext = new ShowTablesContext(localContext);
                this.enterOuterAlt(localContext, 47);
                {
                this.state = 963;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 964;
                this.match(SparkSqlParser.KW_TABLES);
                this.state = 967;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 85, this.context) ) {
                case 1:
                    {
                    this.state = 965;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 966;
                    this.namespaceName();
                    }
                    break;
                }
                this.state = 973;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 163 || _la === 377 || _la === 378) {
                    {
                    this.state = 970;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 163) {
                        {
                        this.state = 969;
                        this.match(SparkSqlParser.KW_LIKE);
                        }
                    }

                    this.state = 972;
                    (localContext as ShowTablesContext)._pattern = this.stringLit();
                    }
                }

                }
                break;
            case 48:
                localContext = new ShowTableExtendedContext(localContext);
                this.enterOuterAlt(localContext, 48);
                {
                this.state = 975;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 976;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 977;
                this.match(SparkSqlParser.KW_EXTENDED);
                this.state = 980;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 123 || _la === 140) {
                    {
                    this.state = 978;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 979;
                    (localContext as ShowTableExtendedContext)._ns = this.namespaceName();
                    }
                }

                this.state = 982;
                this.match(SparkSqlParser.KW_LIKE);
                this.state = 983;
                (localContext as ShowTableExtendedContext)._pattern = this.stringLit();
                this.state = 985;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 984;
                    this.partitionSpec();
                    }
                }

                }
                break;
            case 49:
                localContext = new ShowTblPropertiesContext(localContext);
                this.enterOuterAlt(localContext, 49);
                {
                this.state = 987;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 988;
                this.match(SparkSqlParser.KW_TBLPROPERTIES);
                this.state = 989;
                (localContext as ShowTblPropertiesContext)._table = this.tableName();
                this.state = 994;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 90, this.context) ) {
                case 1:
                    {
                    this.state = 990;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 991;
                    (localContext as ShowTblPropertiesContext)._key = this.propertyKey();
                    this.state = 992;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                }
                break;
            case 50:
                localContext = new ShowColumnsContext(localContext);
                this.enterOuterAlt(localContext, 50);
                {
                this.state = 996;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 997;
                this.match(SparkSqlParser.KW_COLUMNS);
                this.state = 998;
                _la = this.tokenStream.LA(1);
                if(!(_la === 123 || _la === 140)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 999;
                (localContext as ShowColumnsContext)._table = this.tableName();
                this.state = 1002;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 91, this.context) ) {
                case 1:
                    {
                    this.state = 1000;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 1001;
                    this.namespaceName();
                    }
                    break;
                }
                }
                break;
            case 51:
                localContext = new ShowViewsContext(localContext);
                this.enterOuterAlt(localContext, 51);
                {
                this.state = 1004;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1005;
                this.match(SparkSqlParser.KW_VIEWS);
                this.state = 1008;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 92, this.context) ) {
                case 1:
                    {
                    this.state = 1006;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 1007;
                    this.namespaceName();
                    }
                    break;
                }
                this.state = 1014;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 163 || _la === 377 || _la === 378) {
                    {
                    this.state = 1011;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 163) {
                        {
                        this.state = 1010;
                        this.match(SparkSqlParser.KW_LIKE);
                        }
                    }

                    this.state = 1013;
                    (localContext as ShowViewsContext)._pattern = this.stringLit();
                    }
                }

                }
                break;
            case 52:
                localContext = new ShowPartitionsContext(localContext);
                this.enterOuterAlt(localContext, 52);
                {
                this.state = 1016;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1017;
                this.match(SparkSqlParser.KW_PARTITIONS);
                this.state = 1018;
                this.tableName();
                this.state = 1020;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1019;
                    this.partitionSpec();
                    }
                }

                }
                break;
            case 53:
                localContext = new ShowFunctionsContext(localContext);
                this.enterOuterAlt(localContext, 53);
                {
                this.state = 1022;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1024;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 10 || _la === 290 || _la === 331) {
                    {
                    this.state = 1023;
                    this.functionKind();
                    }
                }

                this.state = 1026;
                this.match(SparkSqlParser.KW_FUNCTIONS);
                this.state = 1029;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 97, this.context) ) {
                case 1:
                    {
                    this.state = 1027;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 1028;
                    (localContext as ShowFunctionsContext)._ns = this.namespaceName();
                    }
                    break;
                }
                this.state = 1038;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 100, this.context) ) {
                case 1:
                    {
                    this.state = 1032;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 98, this.context) ) {
                    case 1:
                        {
                        this.state = 1031;
                        this.match(SparkSqlParser.KW_LIKE);
                        }
                        break;
                    }
                    this.state = 1036;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 99, this.context) ) {
                    case 1:
                        {
                        this.state = 1034;
                        (localContext as ShowFunctionsContext)._legacy = this.multipartIdentifier();
                        }
                        break;
                    case 2:
                        {
                        this.state = 1035;
                        (localContext as ShowFunctionsContext)._pattern = this.stringLit();
                        }
                        break;
                    }
                    }
                    break;
                }
                }
                break;
            case 54:
                localContext = new ShowCreateTableContext(localContext);
                this.enterOuterAlt(localContext, 54);
                {
                this.state = 1040;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1041;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 1042;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1043;
                this.tableName();
                this.state = 1046;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20) {
                    {
                    this.state = 1044;
                    this.match(SparkSqlParser.KW_AS);
                    this.state = 1045;
                    this.match(SparkSqlParser.KW_SERDE);
                    }
                }

                }
                break;
            case 55:
                localContext = new ShowCurrentNamespaceContext(localContext);
                this.enterOuterAlt(localContext, 55);
                {
                this.state = 1048;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1049;
                this.match(SparkSqlParser.KW_CURRENT);
                this.state = 1050;
                this.namespace();
                }
                break;
            case 56:
                localContext = new ShowCatalogsContext(localContext);
                this.enterOuterAlt(localContext, 56);
                {
                this.state = 1051;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1052;
                this.match(SparkSqlParser.KW_CATALOGS);
                this.state = 1057;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 163 || _la === 377 || _la === 378) {
                    {
                    this.state = 1054;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 163) {
                        {
                        this.state = 1053;
                        this.match(SparkSqlParser.KW_LIKE);
                        }
                    }

                    this.state = 1056;
                    (localContext as ShowCatalogsContext)._pattern = this.stringLit();
                    }
                }

                }
                break;
            case 57:
                localContext = new ShowMaterializedViewsContext(localContext);
                this.enterOuterAlt(localContext, 57);
                {
                this.state = 1059;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1060;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 1061;
                this.match(SparkSqlParser.KW_VIEWS);
                this.state = 1064;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 104, this.context) ) {
                case 1:
                    {
                    this.state = 1062;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 123 || _la === 140)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 1063;
                    (localContext as ShowMaterializedViewsContext)._db_name = this.namespaceName();
                    }
                    break;
                }
                this.state = 1070;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 163 || _la === 377 || _la === 378) {
                    {
                    this.state = 1067;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 163) {
                        {
                        this.state = 1066;
                        this.match(SparkSqlParser.KW_LIKE);
                        }
                    }

                    this.state = 1069;
                    (localContext as ShowMaterializedViewsContext)._pattern = this.stringLit();
                    }
                }

                }
                break;
            case 58:
                localContext = new ShowCreateMaterializedViewContext(localContext);
                this.enterOuterAlt(localContext, 58);
                {
                this.state = 1072;
                this.match(SparkSqlParser.KW_SHOW);
                this.state = 1073;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 1074;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 1075;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 1076;
                this.viewName();
                this.state = 1079;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 20) {
                    {
                    this.state = 1077;
                    this.match(SparkSqlParser.KW_AS);
                    this.state = 1078;
                    this.match(SparkSqlParser.KW_SERDE);
                    }
                }

                }
                break;
            case 59:
                localContext = new DescribeFunctionContext(localContext);
                this.enterOuterAlt(localContext, 59);
                {
                this.state = 1081;
                _la = this.tokenStream.LA(1);
                if(!(_la === 86 || _la === 87)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1082;
                this.match(SparkSqlParser.KW_FUNCTION);
                this.state = 1084;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 108, this.context) ) {
                case 1:
                    {
                    this.state = 1083;
                    this.match(SparkSqlParser.KW_EXTENDED);
                    }
                    break;
                }
                this.state = 1086;
                this.describeFuncName();
                }
                break;
            case 60:
                localContext = new DescribeNamespaceContext(localContext);
                this.enterOuterAlt(localContext, 60);
                {
                this.state = 1087;
                _la = this.tokenStream.LA(1);
                if(!(_la === 86 || _la === 87)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1088;
                this.match(SparkSqlParser.KW_DATABASE);
                this.state = 1090;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 109, this.context) ) {
                case 1:
                    {
                    this.state = 1089;
                    this.match(SparkSqlParser.KW_EXTENDED);
                    }
                    break;
                }
                this.state = 1092;
                this.namespaceName();
                }
                break;
            case 61:
                localContext = new DescribeRelationContext(localContext);
                this.enterOuterAlt(localContext, 61);
                {
                this.state = 1093;
                _la = this.tokenStream.LA(1);
                if(!(_la === 86 || _la === 87)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1095;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 293) {
                    {
                    this.state = 1094;
                    this.match(SparkSqlParser.KW_TABLE);
                    }
                }

                this.state = 1098;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 111, this.context) ) {
                case 1:
                    {
                    this.state = 1097;
                    (localContext as DescribeRelationContext)._option = this.tokenStream.LT(1);
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 108 || _la === 122)) {
                        (localContext as DescribeRelationContext)._option = this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    }
                    break;
                }
                this.state = 1100;
                this.tableName();
                this.state = 1102;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 112, this.context) ) {
                case 1:
                    {
                    this.state = 1101;
                    this.partitionSpec();
                    }
                    break;
                }
                this.state = 1105;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 113, this.context) ) {
                case 1:
                    {
                    this.state = 1104;
                    this.describeColName();
                    }
                    break;
                }
                }
                break;
            case 62:
                localContext = new DescribeQueryContext(localContext);
                this.enterOuterAlt(localContext, 62);
                {
                this.state = 1107;
                _la = this.tokenStream.LA(1);
                if(!(_la === 86 || _la === 87)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1109;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 232) {
                    {
                    this.state = 1108;
                    this.match(SparkSqlParser.KW_QUERY);
                    }
                }

                this.state = 1111;
                this.query();
                }
                break;
            case 63:
                localContext = new CommentNamespaceContext(localContext);
                this.enterOuterAlt(localContext, 63);
                {
                this.state = 1112;
                this.match(SparkSqlParser.KW_COMMENT);
                this.state = 1113;
                this.match(SparkSqlParser.KW_ON);
                this.state = 1114;
                this.namespace();
                this.state = 1115;
                this.namespaceName();
                this.state = 1116;
                this.match(SparkSqlParser.KW_IS);
                this.state = 1117;
                this.comment();
                }
                break;
            case 64:
                localContext = new CommentTableContext(localContext);
                this.enterOuterAlt(localContext, 64);
                {
                this.state = 1119;
                this.match(SparkSqlParser.KW_COMMENT);
                this.state = 1120;
                this.match(SparkSqlParser.KW_ON);
                this.state = 1121;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1122;
                this.tableName();
                this.state = 1123;
                this.match(SparkSqlParser.KW_IS);
                this.state = 1124;
                this.comment();
                }
                break;
            case 65:
                localContext = new RefreshTableContext(localContext);
                this.enterOuterAlt(localContext, 65);
                {
                this.state = 1126;
                this.match(SparkSqlParser.KW_REFRESH);
                this.state = 1127;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1128;
                this.tableName();
                }
                break;
            case 66:
                localContext = new RefreshFunctionContext(localContext);
                this.enterOuterAlt(localContext, 66);
                {
                this.state = 1129;
                this.match(SparkSqlParser.KW_REFRESH);
                this.state = 1130;
                this.match(SparkSqlParser.KW_FUNCTION);
                this.state = 1131;
                this.functionName();
                }
                break;
            case 67:
                localContext = new RefreshResourceContext(localContext);
                this.enterOuterAlt(localContext, 67);
                {
                this.state = 1132;
                this.match(SparkSqlParser.KW_REFRESH);
                this.state = 1140;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 116, this.context) ) {
                case 1:
                    {
                    this.state = 1133;
                    this.stringLit();
                    }
                    break;
                case 2:
                    {
                    this.state = 1137;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 115, this.context);
                    while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                        if (alternative === 1 + 1) {
                            {
                            {
                            this.state = 1134;
                            this.matchWildcard();
                            }
                            }
                        }
                        this.state = 1139;
                        this.errorHandler.sync(this);
                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 115, this.context);
                    }
                    }
                    break;
                }
                }
                break;
            case 68:
                localContext = new RefreshMaterializedViewContext(localContext);
                this.enterOuterAlt(localContext, 68);
                {
                this.state = 1142;
                this.match(SparkSqlParser.KW_REFRESH);
                this.state = 1143;
                this.match(SparkSqlParser.KW_MATERIALIZED);
                this.state = 1144;
                this.match(SparkSqlParser.KW_VIEW);
                this.state = 1145;
                this.viewName();
                }
                break;
            case 69:
                localContext = new CacheTableContext(localContext);
                this.enterOuterAlt(localContext, 69);
                {
                this.state = 1146;
                this.match(SparkSqlParser.KW_CACHE);
                this.state = 1148;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 159) {
                    {
                    this.state = 1147;
                    this.match(SparkSqlParser.KW_LAZY);
                    }
                }

                this.state = 1150;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1151;
                this.tableName();
                this.state = 1154;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 207) {
                    {
                    this.state = 1152;
                    this.match(SparkSqlParser.KW_OPTIONS);
                    this.state = 1153;
                    (localContext as CacheTableContext)._options = this.propertyList();
                    }
                }

                this.state = 1160;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 120, this.context) ) {
                case 1:
                    {
                    this.state = 1157;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 20) {
                        {
                        this.state = 1156;
                        this.match(SparkSqlParser.KW_AS);
                        }
                    }

                    this.state = 1159;
                    this.query();
                    }
                    break;
                }
                }
                break;
            case 70:
                localContext = new UnCacheTableContext(localContext);
                this.enterOuterAlt(localContext, 70);
                {
                this.state = 1162;
                this.match(SparkSqlParser.KW_UNCACHE);
                this.state = 1163;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1165;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 121, this.context) ) {
                case 1:
                    {
                    this.state = 1164;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 1167;
                this.tableName();
                }
                break;
            case 71:
                localContext = new ClearCacheContext(localContext);
                this.enterOuterAlt(localContext, 71);
                {
                this.state = 1168;
                this.match(SparkSqlParser.KW_CLEAR);
                this.state = 1169;
                this.match(SparkSqlParser.KW_CACHE);
                }
                break;
            case 72:
                localContext = new LoadDataContext(localContext);
                this.enterOuterAlt(localContext, 72);
                {
                this.state = 1170;
                this.match(SparkSqlParser.KW_LOAD);
                this.state = 1171;
                this.match(SparkSqlParser.KW_DATA);
                this.state = 1173;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 169) {
                    {
                    this.state = 1172;
                    this.match(SparkSqlParser.KW_LOCAL);
                    }
                }

                this.state = 1175;
                this.match(SparkSqlParser.KW_INPATH);
                this.state = 1176;
                (localContext as LoadDataContext)._path = this.stringLit();
                this.state = 1178;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 216) {
                    {
                    this.state = 1177;
                    this.match(SparkSqlParser.KW_OVERWRITE);
                    }
                }

                this.state = 1180;
                this.match(SparkSqlParser.KW_INTO);
                this.state = 1181;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1182;
                this.tableName();
                this.state = 1184;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1183;
                    this.partitionSpec();
                    }
                }

                }
                break;
            case 73:
                localContext = new TruncateTableContext(localContext);
                this.enterOuterAlt(localContext, 73);
                {
                this.state = 1186;
                this.match(SparkSqlParser.KW_TRUNCATE);
                this.state = 1187;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1188;
                this.tableName();
                this.state = 1190;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1189;
                    this.partitionSpec();
                    }
                }

                }
                break;
            case 74:
                localContext = new RepairTableContext(localContext);
                this.enterOuterAlt(localContext, 74);
                {
                this.state = 1193;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 188) {
                    {
                    this.state = 1192;
                    this.match(SparkSqlParser.KW_MSCK);
                    }
                }

                this.state = 1195;
                this.match(SparkSqlParser.KW_REPAIR);
                this.state = 1196;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 1197;
                this.tableName();
                this.state = 1200;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 127, this.context) ) {
                case 1:
                    {
                    this.state = 1198;
                    (localContext as RepairTableContext)._option = this.tokenStream.LT(1);
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 8 || _la === 96 || _la === 289)) {
                        (localContext as RepairTableContext)._option = this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 1199;
                    this.match(SparkSqlParser.KW_PARTITIONS);
                    }
                    break;
                }
                }
                break;
            case 75:
                localContext = new ManageResourceContext(localContext);
                this.enterOuterAlt(localContext, 75);
                {
                this.state = 1202;
                (localContext as ManageResourceContext)._op = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 8 || _la === 167)) {
                    (localContext as ManageResourceContext)._op = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1203;
                this.identifier();
                this.state = 1207;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 128, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1204;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1209;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 128, this.context);
                }
                }
                break;
            case 76:
                localContext = new FailNativeCommandContext(localContext);
                this.enterOuterAlt(localContext, 76);
                {
                this.state = 1210;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1211;
                this.match(SparkSqlParser.KW_ROLE);
                this.state = 1215;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 129, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1212;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1217;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 129, this.context);
                }
                }
                break;
            case 77:
                localContext = new SetTimeZoneIntervalContext(localContext);
                this.enterOuterAlt(localContext, 77);
                {
                this.state = 1218;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1219;
                this.match(SparkSqlParser.KW_TIME);
                this.state = 1220;
                this.match(SparkSqlParser.KW_ZONE);
                this.state = 1221;
                this.interval();
                }
                break;
            case 78:
                localContext = new SetTimeZoneContext(localContext);
                this.enterOuterAlt(localContext, 78);
                {
                this.state = 1222;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1223;
                this.match(SparkSqlParser.KW_TIME);
                this.state = 1224;
                this.match(SparkSqlParser.KW_ZONE);
                this.state = 1225;
                this.timezone();
                }
                break;
            case 79:
                localContext = new SetTimeZoneAnyContext(localContext);
                this.enterOuterAlt(localContext, 79);
                {
                this.state = 1226;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1227;
                this.match(SparkSqlParser.KW_TIME);
                this.state = 1228;
                this.match(SparkSqlParser.KW_ZONE);
                this.state = 1232;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 130, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1229;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1234;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 130, this.context);
                }
                }
                break;
            case 80:
                localContext = new SetVariableAssignmentContext(localContext);
                this.enterOuterAlt(localContext, 80);
                {
                this.state = 1235;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1236;
                _la = this.tokenStream.LA(1);
                if(!(_la === 335 || _la === 336)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1237;
                this.assignmentList();
                }
                break;
            case 81:
                localContext = new SetVariableMultiAssignmentContext(localContext);
                this.enterOuterAlt(localContext, 81);
                {
                this.state = 1238;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1239;
                _la = this.tokenStream.LA(1);
                if(!(_la === 335 || _la === 336)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 1240;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 1241;
                this.multipartIdentifierList();
                this.state = 1242;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 1243;
                this.match(SparkSqlParser.EQ);
                this.state = 1244;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 1245;
                this.query();
                this.state = 1246;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 82:
                localContext = new SetConfigContext(localContext);
                this.enterOuterAlt(localContext, 82);
                {
                this.state = 1248;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1249;
                this.configKey();
                this.state = 1250;
                this.match(SparkSqlParser.EQ);
                this.state = 1251;
                this.configValue();
                }
                break;
            case 83:
                localContext = new SetConfigAndValueContext(localContext);
                this.enterOuterAlt(localContext, 83);
                {
                this.state = 1253;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1254;
                this.configKey();
                this.state = 1262;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 352) {
                    {
                    this.state = 1255;
                    this.match(SparkSqlParser.EQ);
                    this.state = 1259;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 131, this.context);
                    while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                        if (alternative === 1 + 1) {
                            {
                            {
                            this.state = 1256;
                            this.matchWildcard();
                            }
                            }
                        }
                        this.state = 1261;
                        this.errorHandler.sync(this);
                        alternative = this.interpreter.adaptivePredict(this.tokenStream, 131, this.context);
                    }
                    }
                }

                }
                break;
            case 84:
                localContext = new SetConfigAnyKeyContext(localContext);
                this.enterOuterAlt(localContext, 84);
                {
                this.state = 1264;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1268;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 133, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1265;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1270;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 133, this.context);
                }
                this.state = 1271;
                this.match(SparkSqlParser.EQ);
                this.state = 1272;
                this.configValue();
                }
                break;
            case 85:
                localContext = new SetAnyContext(localContext);
                this.enterOuterAlt(localContext, 85);
                {
                this.state = 1273;
                this.match(SparkSqlParser.KW_SET);
                this.state = 1277;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 134, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1274;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1279;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 134, this.context);
                }
                }
                break;
            case 86:
                localContext = new ResetConfigContext(localContext);
                this.enterOuterAlt(localContext, 86);
                {
                this.state = 1280;
                this.match(SparkSqlParser.KW_RESET);
                this.state = 1281;
                this.configKey();
                }
                break;
            case 87:
                localContext = new ResetAnyContext(localContext);
                this.enterOuterAlt(localContext, 87);
                {
                this.state = 1282;
                this.match(SparkSqlParser.KW_RESET);
                this.state = 1286;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 135, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1283;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1288;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 135, this.context);
                }
                }
                break;
            case 88:
                localContext = new CreateIndexContext(localContext);
                this.enterOuterAlt(localContext, 88);
                {
                this.state = 1289;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 1290;
                this.match(SparkSqlParser.KW_INDEX);
                this.state = 1292;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 136, this.context) ) {
                case 1:
                    {
                    this.state = 1291;
                    this.ifNotExists();
                    }
                    break;
                }
                this.state = 1294;
                this.identifier();
                this.state = 1295;
                this.match(SparkSqlParser.KW_ON);
                this.state = 1297;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 293) {
                    {
                    this.state = 1296;
                    this.match(SparkSqlParser.KW_TABLE);
                    }
                }

                this.state = 1299;
                this.tableName();
                this.state = 1302;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 332) {
                    {
                    this.state = 1300;
                    this.match(SparkSqlParser.KW_USING);
                    this.state = 1301;
                    (localContext as CreateIndexContext)._indexType = this.identifier();
                    }
                }

                this.state = 1304;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 1305;
                this.multipartIdentifierPropertyList();
                this.state = 1306;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 1309;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 207) {
                    {
                    this.state = 1307;
                    this.match(SparkSqlParser.KW_OPTIONS);
                    this.state = 1308;
                    (localContext as CreateIndexContext)._options = this.propertyList();
                    }
                }

                }
                break;
            case 89:
                localContext = new DropIndexContext(localContext);
                this.enterOuterAlt(localContext, 89);
                {
                this.state = 1311;
                this.match(SparkSqlParser.KW_DROP);
                this.state = 1312;
                this.match(SparkSqlParser.KW_INDEX);
                this.state = 1314;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 140, this.context) ) {
                case 1:
                    {
                    this.state = 1313;
                    this.ifExists();
                    }
                    break;
                }
                this.state = 1316;
                this.identifier();
                this.state = 1317;
                this.match(SparkSqlParser.KW_ON);
                this.state = 1319;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 293) {
                    {
                    this.state = 1318;
                    this.match(SparkSqlParser.KW_TABLE);
                    }
                }

                this.state = 1321;
                this.tableName();
                }
                break;
            case 90:
                localContext = new OptimizeTableContext(localContext);
                this.enterOuterAlt(localContext, 90);
                {
                this.state = 1323;
                this.match(SparkSqlParser.KW_OPTIMIZE);
                this.state = 1324;
                this.tableName();
                this.state = 1326;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 344) {
                    {
                    this.state = 1325;
                    this.whereClause();
                    }
                }

                this.state = 1328;
                this.zorderClause();
                }
                break;
            case 91:
                localContext = new UnsupportHiveCommandsContext(localContext);
                this.enterOuterAlt(localContext, 91);
                {
                this.state = 1330;
                this.unsupportedHiveNativeCommands();
                this.state = 1334;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 143, this.context);
                while (alternative !== 1 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1 + 1) {
                        {
                        {
                        this.state = 1331;
                        this.matchWildcard();
                        }
                        }
                    }
                    this.state = 1336;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 143, this.context);
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public timezone(): TimezoneContext {
        let localContext = new TimezoneContext(this.context, this.state);
        this.enterRule(localContext, 6, SparkSqlParser.RULE_timezone);
        try {
            this.state = 1341;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.STRING_LITERAL:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1339;
                this.stringLit();
                }
                break;
            case SparkSqlParser.KW_LOCAL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1340;
                this.match(SparkSqlParser.KW_LOCAL);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public configKey(): ConfigKeyContext {
        let localContext = new ConfigKeyContext(this.context, this.state);
        this.enterRule(localContext, 8, SparkSqlParser.RULE_configKey);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1343;
            this.quotedIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public configValue(): ConfigValueContext {
        let localContext = new ConfigValueContext(this.context, this.state);
        this.enterRule(localContext, 10, SparkSqlParser.RULE_configValue);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1345;
            this.backQuotedIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext {
        let localContext = new UnsupportedHiveNativeCommandsContext(this.context, this.state);
        this.enterRule(localContext, 12, SparkSqlParser.RULE_unsupportedHiveNativeCommands);
        let _la: number;
        try {
            this.state = 1515;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 153, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1347;
                localContext._kw1 = this.match(SparkSqlParser.KW_CREATE);
                this.state = 1348;
                localContext._kw2 = this.match(SparkSqlParser.KW_ROLE);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1349;
                localContext._kw1 = this.match(SparkSqlParser.KW_DROP);
                this.state = 1350;
                localContext._kw2 = this.match(SparkSqlParser.KW_ROLE);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1351;
                localContext._kw1 = this.match(SparkSqlParser.KW_GRANT);
                this.state = 1353;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 146, this.context) ) {
                case 1:
                    {
                    this.state = 1352;
                    localContext._kw2 = this.match(SparkSqlParser.KW_ROLE);
                    }
                    break;
                }
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1355;
                localContext._kw1 = this.match(SparkSqlParser.KW_REVOKE);
                this.state = 1357;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 147, this.context) ) {
                case 1:
                    {
                    this.state = 1356;
                    localContext._kw2 = this.match(SparkSqlParser.KW_ROLE);
                    }
                    break;
                }
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1359;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1360;
                localContext._kw2 = this.match(SparkSqlParser.KW_GRANT);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 1361;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1362;
                localContext._kw2 = this.match(SparkSqlParser.KW_ROLE);
                this.state = 1364;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 148, this.context) ) {
                case 1:
                    {
                    this.state = 1363;
                    localContext._kw3 = this.match(SparkSqlParser.KW_GRANT);
                    }
                    break;
                }
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 1366;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1367;
                localContext._kw2 = this.match(SparkSqlParser.KW_PRINCIPALS);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 1368;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1369;
                localContext._kw2 = this.match(SparkSqlParser.KW_ROLES);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 1370;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1371;
                localContext._kw2 = this.match(SparkSqlParser.KW_CURRENT);
                this.state = 1372;
                localContext._kw3 = this.match(SparkSqlParser.KW_ROLES);
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 1373;
                localContext._kw1 = this.match(SparkSqlParser.KW_EXPORT);
                this.state = 1374;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                }
                break;
            case 11:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 1375;
                localContext._kw1 = this.match(SparkSqlParser.KW_IMPORT);
                this.state = 1376;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                }
                break;
            case 12:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 1377;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1378;
                localContext._kw2 = this.match(SparkSqlParser.KW_COMPACTIONS);
                }
                break;
            case 13:
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 1379;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1380;
                localContext._kw2 = this.match(SparkSqlParser.KW_CREATE);
                this.state = 1381;
                localContext._kw3 = this.match(SparkSqlParser.KW_TABLE);
                }
                break;
            case 14:
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 1382;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1383;
                localContext._kw2 = this.match(SparkSqlParser.KW_TRANSACTIONS);
                }
                break;
            case 15:
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 1384;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1385;
                localContext._kw2 = this.match(SparkSqlParser.KW_INDEXES);
                }
                break;
            case 16:
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 1386;
                localContext._kw1 = this.match(SparkSqlParser.KW_SHOW);
                this.state = 1387;
                localContext._kw2 = this.match(SparkSqlParser.KW_LOCKS);
                }
                break;
            case 17:
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 1388;
                localContext._kw1 = this.match(SparkSqlParser.KW_CREATE);
                this.state = 1389;
                localContext._kw2 = this.match(SparkSqlParser.KW_INDEX);
                }
                break;
            case 18:
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 1390;
                localContext._kw1 = this.match(SparkSqlParser.KW_DROP);
                this.state = 1391;
                localContext._kw2 = this.match(SparkSqlParser.KW_INDEX);
                }
                break;
            case 19:
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 1392;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1393;
                localContext._kw2 = this.match(SparkSqlParser.KW_INDEX);
                }
                break;
            case 20:
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 1394;
                localContext._kw1 = this.match(SparkSqlParser.KW_LOCK);
                this.state = 1395;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                }
                break;
            case 21:
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 1396;
                localContext._kw1 = this.match(SparkSqlParser.KW_LOCK);
                this.state = 1397;
                localContext._kw2 = this.match(SparkSqlParser.KW_DATABASE);
                }
                break;
            case 22:
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 1398;
                localContext._kw1 = this.match(SparkSqlParser.KW_UNLOCK);
                this.state = 1399;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                }
                break;
            case 23:
                this.enterOuterAlt(localContext, 23);
                {
                this.state = 1400;
                localContext._kw1 = this.match(SparkSqlParser.KW_UNLOCK);
                this.state = 1401;
                localContext._kw2 = this.match(SparkSqlParser.KW_DATABASE);
                }
                break;
            case 24:
                this.enterOuterAlt(localContext, 24);
                {
                this.state = 1402;
                localContext._kw1 = this.match(SparkSqlParser.KW_CREATE);
                this.state = 1403;
                localContext._kw2 = this.match(SparkSqlParser.KW_TEMPORARY);
                this.state = 1404;
                localContext._kw3 = this.match(SparkSqlParser.KW_MACRO);
                }
                break;
            case 25:
                this.enterOuterAlt(localContext, 25);
                {
                this.state = 1405;
                localContext._kw1 = this.match(SparkSqlParser.KW_DROP);
                this.state = 1406;
                localContext._kw2 = this.match(SparkSqlParser.KW_TEMPORARY);
                this.state = 1407;
                localContext._kw3 = this.match(SparkSqlParser.KW_MACRO);
                }
                break;
            case 26:
                this.enterOuterAlt(localContext, 26);
                {
                this.state = 1408;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1409;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1410;
                this.tableName();
                this.state = 1411;
                localContext._kw3 = this.match(SparkSqlParser.KW_NOT);
                this.state = 1412;
                localContext._kw4 = this.match(SparkSqlParser.KW_CLUSTERED);
                }
                break;
            case 27:
                this.enterOuterAlt(localContext, 27);
                {
                this.state = 1414;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1415;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1416;
                this.tableName();
                this.state = 1417;
                localContext._kw3 = this.match(SparkSqlParser.KW_CLUSTERED);
                this.state = 1418;
                localContext._kw4 = this.match(SparkSqlParser.KW_BY);
                }
                break;
            case 28:
                this.enterOuterAlt(localContext, 28);
                {
                this.state = 1420;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1421;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1422;
                this.tableName();
                this.state = 1423;
                localContext._kw3 = this.match(SparkSqlParser.KW_NOT);
                this.state = 1424;
                localContext._kw4 = this.match(SparkSqlParser.KW_SORTED);
                }
                break;
            case 29:
                this.enterOuterAlt(localContext, 29);
                {
                this.state = 1426;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1427;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1428;
                this.tableName();
                this.state = 1429;
                localContext._kw3 = this.match(SparkSqlParser.KW_SKEWED);
                this.state = 1430;
                localContext._kw4 = this.match(SparkSqlParser.KW_BY);
                }
                break;
            case 30:
                this.enterOuterAlt(localContext, 30);
                {
                this.state = 1432;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1433;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1434;
                this.tableName();
                this.state = 1435;
                localContext._kw3 = this.match(SparkSqlParser.KW_NOT);
                this.state = 1436;
                localContext._kw4 = this.match(SparkSqlParser.KW_SKEWED);
                }
                break;
            case 31:
                this.enterOuterAlt(localContext, 31);
                {
                this.state = 1438;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1439;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1440;
                this.tableName();
                this.state = 1441;
                localContext._kw3 = this.match(SparkSqlParser.KW_NOT);
                this.state = 1442;
                localContext._kw4 = this.match(SparkSqlParser.KW_STORED);
                this.state = 1443;
                localContext._kw5 = this.match(SparkSqlParser.KW_AS);
                this.state = 1444;
                localContext._kw6 = this.match(SparkSqlParser.KW_DIRECTORIES);
                }
                break;
            case 32:
                this.enterOuterAlt(localContext, 32);
                {
                this.state = 1446;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1447;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1448;
                this.tableName();
                this.state = 1449;
                localContext._kw3 = this.match(SparkSqlParser.KW_SET);
                this.state = 1450;
                localContext._kw4 = this.match(SparkSqlParser.KW_SKEWED);
                this.state = 1451;
                localContext._kw5 = this.match(SparkSqlParser.KW_LOCATION);
                }
                break;
            case 33:
                this.enterOuterAlt(localContext, 33);
                {
                this.state = 1453;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1454;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1455;
                this.tableName();
                this.state = 1456;
                localContext._kw3 = this.match(SparkSqlParser.KW_EXCHANGE);
                this.state = 1457;
                localContext._kw4 = this.match(SparkSqlParser.KW_PARTITION);
                }
                break;
            case 34:
                this.enterOuterAlt(localContext, 34);
                {
                this.state = 1459;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1460;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1461;
                this.tableName();
                this.state = 1462;
                localContext._kw3 = this.match(SparkSqlParser.KW_ARCHIVE);
                this.state = 1463;
                localContext._kw4 = this.match(SparkSqlParser.KW_PARTITION);
                }
                break;
            case 35:
                this.enterOuterAlt(localContext, 35);
                {
                this.state = 1465;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1466;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1467;
                this.tableName();
                this.state = 1468;
                localContext._kw3 = this.match(SparkSqlParser.KW_UNARCHIVE);
                this.state = 1469;
                localContext._kw4 = this.match(SparkSqlParser.KW_PARTITION);
                }
                break;
            case 36:
                this.enterOuterAlt(localContext, 36);
                {
                this.state = 1471;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1472;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1473;
                this.tableName();
                this.state = 1474;
                localContext._kw3 = this.match(SparkSqlParser.KW_TOUCH);
                }
                break;
            case 37:
                this.enterOuterAlt(localContext, 37);
                {
                this.state = 1476;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1477;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1478;
                this.tableName();
                this.state = 1480;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1479;
                    this.partitionSpec();
                    }
                }

                this.state = 1482;
                localContext._kw3 = this.match(SparkSqlParser.KW_COMPACT);
                }
                break;
            case 38:
                this.enterOuterAlt(localContext, 38);
                {
                this.state = 1484;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1485;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1486;
                this.tableName();
                this.state = 1488;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1487;
                    this.partitionSpec();
                    }
                }

                this.state = 1490;
                localContext._kw3 = this.match(SparkSqlParser.KW_CONCATENATE);
                }
                break;
            case 39:
                this.enterOuterAlt(localContext, 39);
                {
                this.state = 1492;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1493;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1494;
                this.tableName();
                this.state = 1496;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1495;
                    this.partitionSpec();
                    }
                }

                this.state = 1498;
                localContext._kw3 = this.match(SparkSqlParser.KW_SET);
                this.state = 1499;
                localContext._kw4 = this.match(SparkSqlParser.KW_FILEFORMAT);
                }
                break;
            case 40:
                this.enterOuterAlt(localContext, 40);
                {
                this.state = 1501;
                localContext._kw1 = this.match(SparkSqlParser.KW_ALTER);
                this.state = 1502;
                localContext._kw2 = this.match(SparkSqlParser.KW_TABLE);
                this.state = 1503;
                this.tableName();
                this.state = 1505;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1504;
                    this.partitionSpec();
                    }
                }

                this.state = 1507;
                localContext._kw3 = this.match(SparkSqlParser.KW_REPLACE);
                this.state = 1508;
                localContext._kw4 = this.match(SparkSqlParser.KW_COLUMNS);
                }
                break;
            case 41:
                this.enterOuterAlt(localContext, 41);
                {
                this.state = 1510;
                localContext._kw1 = this.match(SparkSqlParser.KW_START);
                this.state = 1511;
                localContext._kw2 = this.match(SparkSqlParser.KW_TRANSACTION);
                }
                break;
            case 42:
                this.enterOuterAlt(localContext, 42);
                {
                this.state = 1512;
                localContext._kw1 = this.match(SparkSqlParser.KW_COMMIT);
                }
                break;
            case 43:
                this.enterOuterAlt(localContext, 43);
                {
                this.state = 1513;
                localContext._kw1 = this.match(SparkSqlParser.KW_ROLLBACK);
                }
                break;
            case 44:
                this.enterOuterAlt(localContext, 44);
                {
                this.state = 1514;
                localContext._kw1 = this.match(SparkSqlParser.KW_DFS);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public createTableHeader(): CreateTableHeaderContext {
        let localContext = new CreateTableHeaderContext(this.context, this.state);
        this.enterRule(localContext, 14, SparkSqlParser.RULE_createTableHeader);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1517;
            this.match(SparkSqlParser.KW_CREATE);
            this.state = 1519;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 298) {
                {
                this.state = 1518;
                this.match(SparkSqlParser.KW_TEMPORARY);
                }
            }

            this.state = 1522;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 109) {
                {
                this.state = 1521;
                this.match(SparkSqlParser.KW_EXTERNAL);
                }
            }

            this.state = 1524;
            this.match(SparkSqlParser.KW_TABLE);
            this.state = 1526;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 156, this.context) ) {
            case 1:
                {
                this.state = 1525;
                this.ifNotExists();
                }
                break;
            }
            this.state = 1528;
            this.tableNameCreate();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public replaceTableHeader(): ReplaceTableHeaderContext {
        let localContext = new ReplaceTableHeaderContext(this.context, this.state);
        this.enterRule(localContext, 16, SparkSqlParser.RULE_replaceTableHeader);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1532;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 59) {
                {
                this.state = 1530;
                this.match(SparkSqlParser.KW_CREATE);
                this.state = 1531;
                this.match(SparkSqlParser.KW_OR);
                }
            }

            this.state = 1534;
            this.match(SparkSqlParser.KW_REPLACE);
            this.state = 1535;
            this.match(SparkSqlParser.KW_TABLE);
            this.state = 1536;
            this.tableNameCreate();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public bucketSpec(): BucketSpecContext {
        let localContext = new BucketSpecContext(this.context, this.state);
        this.enterRule(localContext, 18, SparkSqlParser.RULE_bucketSpec);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1538;
            this.match(SparkSqlParser.KW_CLUSTERED);
            this.state = 1539;
            this.match(SparkSqlParser.KW_BY);
            this.state = 1540;
            this.identifierList();
            this.state = 1544;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 279) {
                {
                this.state = 1541;
                this.match(SparkSqlParser.KW_SORTED);
                this.state = 1542;
                this.match(SparkSqlParser.KW_BY);
                this.state = 1543;
                this.orderedIdentifierList();
                }
            }

            this.state = 1546;
            this.match(SparkSqlParser.KW_INTO);
            this.state = 1547;
            this.match(SparkSqlParser.INTEGER_VALUE);
            this.state = 1548;
            this.match(SparkSqlParser.KW_BUCKETS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public skewSpec(): SkewSpecContext {
        let localContext = new SkewSpecContext(this.context, this.state);
        this.enterRule(localContext, 20, SparkSqlParser.RULE_skewSpec);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1550;
            this.match(SparkSqlParser.KW_SKEWED);
            this.state = 1551;
            this.match(SparkSqlParser.KW_BY);
            this.state = 1552;
            this.identifierList();
            this.state = 1553;
            this.match(SparkSqlParser.KW_ON);
            this.state = 1556;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 159, this.context) ) {
            case 1:
                {
                this.state = 1554;
                this.constantList();
                }
                break;
            case 2:
                {
                this.state = 1555;
                this.nestedConstantList();
                }
                break;
            }
            this.state = 1561;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 160, this.context) ) {
            case 1:
                {
                this.state = 1558;
                this.match(SparkSqlParser.KW_STORED);
                this.state = 1559;
                this.match(SparkSqlParser.KW_AS);
                this.state = 1560;
                this.match(SparkSqlParser.KW_DIRECTORIES);
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public locationSpec(): LocationSpecContext {
        let localContext = new LocationSpecContext(this.context, this.state);
        this.enterRule(localContext, 22, SparkSqlParser.RULE_locationSpec);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1563;
            this.match(SparkSqlParser.KW_LOCATION);
            this.state = 1564;
            this.stringLit();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public commentSpec(): CommentSpecContext {
        let localContext = new CommentSpecContext(this.context, this.state);
        this.enterRule(localContext, 24, SparkSqlParser.RULE_commentSpec);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1566;
            this.match(SparkSqlParser.KW_COMMENT);
            this.state = 1567;
            this.stringLit();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public query(): QueryContext {
        let localContext = new QueryContext(this.context, this.state);
        this.enterRule(localContext, 26, SparkSqlParser.RULE_query);
        let _la: number;
        try {
            localContext = new QueryStatementContext(localContext);
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1570;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 346) {
                {
                this.state = 1569;
                this.ctes();
                }
            }

            this.state = 1572;
            this.queryTerm(0);
            this.state = 1573;
            this.queryOrganization();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public insertInto(): InsertIntoContext {
        let localContext = new InsertIntoContext(this.context, this.state);
        this.enterRule(localContext, 28, SparkSqlParser.RULE_insertInto);
        let _la: number;
        try {
            this.state = 1651;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 177, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1575;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 1576;
                this.match(SparkSqlParser.KW_OVERWRITE);
                this.state = 1578;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 293) {
                    {
                    this.state = 1577;
                    this.match(SparkSqlParser.KW_TABLE);
                    }
                }

                this.state = 1580;
                this.tableName();
                this.state = 1585;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1581;
                    this.partitionSpec();
                    this.state = 1583;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 137) {
                        {
                        this.state = 1582;
                        this.ifNotExists();
                        }
                    }

                    }
                }

                this.state = 1593;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 165, this.context) ) {
                case 1:
                    {
                    {
                    this.state = 1587;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 1588;
                    this.match(SparkSqlParser.KW_NAME);
                    }
                    }
                    break;
                case 2:
                    {
                    {
                    this.state = 1589;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 1590;
                    this.columnNameSeq();
                    this.state = 1591;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    }
                    break;
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1595;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 1596;
                this.match(SparkSqlParser.KW_INTO);
                this.state = 1598;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 293) {
                    {
                    this.state = 1597;
                    this.match(SparkSqlParser.KW_TABLE);
                    }
                }

                this.state = 1600;
                this.tableName();
                this.state = 1602;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 217) {
                    {
                    this.state = 1601;
                    this.partitionSpec();
                    }
                }

                this.state = 1605;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 137) {
                    {
                    this.state = 1604;
                    this.ifNotExists();
                    }
                }

                this.state = 1613;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 169, this.context) ) {
                case 1:
                    {
                    {
                    this.state = 1607;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 1608;
                    this.match(SparkSqlParser.KW_NAME);
                    }
                    }
                    break;
                case 2:
                    {
                    {
                    this.state = 1609;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 1610;
                    this.columnNameSeq();
                    this.state = 1611;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    }
                    break;
                }
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1615;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 1616;
                this.match(SparkSqlParser.KW_INTO);
                this.state = 1618;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 293) {
                    {
                    this.state = 1617;
                    this.match(SparkSqlParser.KW_TABLE);
                    }
                }

                this.state = 1620;
                this.tableName();
                this.state = 1621;
                this.match(SparkSqlParser.KW_REPLACE);
                this.state = 1622;
                this.whereClause();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1624;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 1625;
                this.match(SparkSqlParser.KW_OVERWRITE);
                this.state = 1627;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 169) {
                    {
                    this.state = 1626;
                    this.match(SparkSqlParser.KW_LOCAL);
                    }
                }

                this.state = 1629;
                this.match(SparkSqlParser.KW_DIRECTORY);
                this.state = 1630;
                localContext._path = this.stringLit();
                this.state = 1632;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 257) {
                    {
                    this.state = 1631;
                    this.rowFormat();
                    }
                }

                this.state = 1635;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 283) {
                    {
                    this.state = 1634;
                    this.createFileFormat();
                    }
                }

                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1637;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 1638;
                this.match(SparkSqlParser.KW_OVERWRITE);
                this.state = 1640;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 169) {
                    {
                    this.state = 1639;
                    this.match(SparkSqlParser.KW_LOCAL);
                    }
                }

                this.state = 1642;
                this.match(SparkSqlParser.KW_DIRECTORY);
                this.state = 1644;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 377 || _la === 378) {
                    {
                    this.state = 1643;
                    localContext._path = this.stringLit();
                    }
                }

                this.state = 1646;
                this.tableProvider();
                this.state = 1649;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 207) {
                    {
                    this.state = 1647;
                    this.match(SparkSqlParser.KW_OPTIONS);
                    this.state = 1648;
                    localContext._options = this.propertyList();
                    }
                }

                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public partitionSpecLocation(): PartitionSpecLocationContext {
        let localContext = new PartitionSpecLocationContext(this.context, this.state);
        this.enterRule(localContext, 30, SparkSqlParser.RULE_partitionSpecLocation);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1653;
            this.partitionSpec();
            this.state = 1655;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 170) {
                {
                this.state = 1654;
                this.locationSpec();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public partitionSpec(): PartitionSpecContext {
        let localContext = new PartitionSpecContext(this.context, this.state);
        this.enterRule(localContext, 32, SparkSqlParser.RULE_partitionSpec);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1657;
            this.match(SparkSqlParser.KW_PARTITION);
            this.state = 1658;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 1659;
            this.partitionVal();
            this.state = 1664;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1660;
                this.match(SparkSqlParser.COMMA);
                this.state = 1661;
                this.partitionVal();
                }
                }
                this.state = 1666;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1667;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public partitionVal(): PartitionValContext {
        let localContext = new PartitionValContext(this.context, this.state);
        this.enterRule(localContext, 34, SparkSqlParser.RULE_partitionVal);
        let _la: number;
        try {
            this.state = 1678;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 181, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1669;
                this.identifier();
                this.state = 1672;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 352) {
                    {
                    this.state = 1670;
                    this.match(SparkSqlParser.EQ);
                    this.state = 1671;
                    this.constant();
                    }
                }

                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1674;
                this.identifier();
                this.state = 1675;
                this.match(SparkSqlParser.EQ);
                this.state = 1676;
                this.match(SparkSqlParser.KW_DEFAULT);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namespace(): NamespaceContext {
        let localContext = new NamespaceContext(this.context, this.state);
        this.enterRule(localContext, 36, SparkSqlParser.RULE_namespace);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1680;
            _la = this.tokenStream.LA(1);
            if(!(_la === 72 || _la === 190 || _la === 261)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namespaces(): NamespacesContext {
        let localContext = new NamespacesContext(this.context, this.state);
        this.enterRule(localContext, 38, SparkSqlParser.RULE_namespaces);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1682;
            _la = this.tokenStream.LA(1);
            if(!(_la === 73 || _la === 191 || _la === 262)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public describeFuncName(): DescribeFuncNameContext {
        let localContext = new DescribeFuncNameContext(this.context, this.state);
        this.enterRule(localContext, 40, SparkSqlParser.RULE_describeFuncName);
        try {
            this.state = 1689;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 182, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1684;
                this.identifierReference();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1685;
                this.stringLit();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1686;
                this.comparisonOperator();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1687;
                this.arithmeticOperator();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1688;
                this.predicateOperator();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public describeColName(): DescribeColNameContext {
        let localContext = new DescribeColNameContext(this.context, this.state);
        this.enterRule(localContext, 42, SparkSqlParser.RULE_describeColName);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1691;
            localContext._identifier = this.identifier();
            localContext._nameParts.push(localContext._identifier);
            this.state = 1696;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 5) {
                {
                {
                this.state = 1692;
                this.match(SparkSqlParser.DOT);
                this.state = 1693;
                localContext._identifier = this.identifier();
                localContext._nameParts.push(localContext._identifier);
                }
                }
                this.state = 1698;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ctes(): CtesContext {
        let localContext = new CtesContext(this.context, this.state);
        this.enterRule(localContext, 44, SparkSqlParser.RULE_ctes);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1699;
            this.match(SparkSqlParser.KW_WITH);
            this.state = 1700;
            this.namedQuery();
            this.state = 1705;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1701;
                this.match(SparkSqlParser.COMMA);
                this.state = 1702;
                this.namedQuery();
                }
                }
                this.state = 1707;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namedQuery(): NamedQueryContext {
        let localContext = new NamedQueryContext(this.context, this.state);
        this.enterRule(localContext, 46, SparkSqlParser.RULE_namedQuery);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1708;
            localContext._name = this.errorCapturingIdentifier();
            this.state = 1710;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 185, this.context) ) {
            case 1:
                {
                this.state = 1709;
                localContext._columnAliases = this.identifierList();
                }
                break;
            }
            this.state = 1713;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 20) {
                {
                this.state = 1712;
                this.match(SparkSqlParser.KW_AS);
                }
            }

            this.state = 1715;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 1716;
            this.query();
            this.state = 1717;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableProvider(): TableProviderContext {
        let localContext = new TableProviderContext(this.context, this.state);
        this.enterRule(localContext, 48, SparkSqlParser.RULE_tableProvider);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1719;
            this.match(SparkSqlParser.KW_USING);
            this.state = 1720;
            this.multipartIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public createTableClauses(): CreateTableClausesContext {
        let localContext = new CreateTableClausesContext(this.context, this.state);
        this.enterRule(localContext, 50, SparkSqlParser.RULE_createTableClauses);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1738;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 188, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    this.state = 1736;
                    this.errorHandler.sync(this);
                    switch (this.tokenStream.LA(1)) {
                    case SparkSqlParser.KW_OPTIONS:
                        {
                        {
                        this.state = 1722;
                        this.match(SparkSqlParser.KW_OPTIONS);
                        this.state = 1723;
                        localContext._options = this.expressionPropertyList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_PARTITIONED:
                        {
                        {
                        this.state = 1724;
                        this.match(SparkSqlParser.KW_PARTITIONED);
                        this.state = 1725;
                        this.match(SparkSqlParser.KW_BY);
                        this.state = 1726;
                        localContext._partitioning = this.partitionFieldList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_SKEWED:
                        {
                        this.state = 1727;
                        this.skewSpec();
                        }
                        break;
                    case SparkSqlParser.KW_CLUSTERED:
                        {
                        this.state = 1728;
                        this.bucketSpec();
                        }
                        break;
                    case SparkSqlParser.KW_ROW:
                        {
                        this.state = 1729;
                        this.rowFormat();
                        }
                        break;
                    case SparkSqlParser.KW_STORED:
                        {
                        this.state = 1730;
                        this.createFileFormat();
                        }
                        break;
                    case SparkSqlParser.KW_LOCATION:
                        {
                        this.state = 1731;
                        this.locationSpec();
                        }
                        break;
                    case SparkSqlParser.KW_COMMENT:
                        {
                        this.state = 1732;
                        this.commentSpec();
                        }
                        break;
                    case SparkSqlParser.KW_TBLPROPERTIES:
                        {
                        {
                        this.state = 1733;
                        this.match(SparkSqlParser.KW_TBLPROPERTIES);
                        this.state = 1734;
                        localContext._tableProps = this.propertyList();
                        }
                        }
                        break;
                    case SparkSqlParser.KW_LIFECYCLE:
                        {
                        this.state = 1735;
                        this.tableLifecycle();
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    }
                }
                this.state = 1740;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 188, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableLifecycle(): TableLifecycleContext {
        let localContext = new TableLifecycleContext(this.context, this.state);
        this.enterRule(localContext, 52, SparkSqlParser.RULE_tableLifecycle);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1741;
            this.match(SparkSqlParser.KW_LIFECYCLE);
            this.state = 1742;
            this.match(SparkSqlParser.INTEGER_VALUE);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public propertyList(): PropertyListContext {
        let localContext = new PropertyListContext(this.context, this.state);
        this.enterRule(localContext, 54, SparkSqlParser.RULE_propertyList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1744;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 1745;
            this.property();
            this.state = 1750;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1746;
                this.match(SparkSqlParser.COMMA);
                this.state = 1747;
                this.property();
                }
                }
                this.state = 1752;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1753;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public property(): PropertyContext {
        let localContext = new PropertyContext(this.context, this.state);
        this.enterRule(localContext, 56, SparkSqlParser.RULE_property);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1755;
            localContext._key = this.propertyKey();
            this.state = 1760;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 111 || _la === 316 || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 1174405121) !== 0) || _la === 384) {
                {
                this.state = 1757;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 352) {
                    {
                    this.state = 1756;
                    this.match(SparkSqlParser.EQ);
                    }
                }

                this.state = 1759;
                localContext._value = this.propertyValue();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public propertyKey(): PropertyKeyContext {
        let localContext = new PropertyKeyContext(this.context, this.state);
        this.enterRule(localContext, 58, SparkSqlParser.RULE_propertyKey);
        let _la: number;
        try {
            this.state = 1771;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 193, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1762;
                this.identifier();
                this.state = 1767;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 5) {
                    {
                    {
                    this.state = 1763;
                    this.match(SparkSqlParser.DOT);
                    this.state = 1764;
                    this.identifier();
                    }
                    }
                    this.state = 1769;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1770;
                this.stringLit();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public propertyValue(): PropertyValueContext {
        let localContext = new PropertyValueContext(this.context, this.state);
        this.enterRule(localContext, 60, SparkSqlParser.RULE_propertyValue);
        try {
            this.state = 1777;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.INTEGER_VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1773;
                this.match(SparkSqlParser.INTEGER_VALUE);
                }
                break;
            case SparkSqlParser.DECIMAL_VALUE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1774;
                this.match(SparkSqlParser.DECIMAL_VALUE);
                }
                break;
            case SparkSqlParser.KW_FALSE:
            case SparkSqlParser.KW_TRUE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1775;
                this.booleanValue();
                }
                break;
            case SparkSqlParser.STRING_LITERAL:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1776;
                this.stringLit();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public expressionPropertyList(): ExpressionPropertyListContext {
        let localContext = new ExpressionPropertyListContext(this.context, this.state);
        this.enterRule(localContext, 62, SparkSqlParser.RULE_expressionPropertyList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1779;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 1780;
            this.expressionProperty();
            this.state = 1785;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1781;
                this.match(SparkSqlParser.COMMA);
                this.state = 1782;
                this.expressionProperty();
                }
                }
                this.state = 1787;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1788;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public expressionProperty(): ExpressionPropertyContext {
        let localContext = new ExpressionPropertyContext(this.context, this.state);
        this.enterRule(localContext, 64, SparkSqlParser.RULE_expressionProperty);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1790;
            localContext._key = this.propertyKey();
            this.state = 1795;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (((((_la - 2)) & ~0x1F) === 0 && ((1 << (_la - 2)) & 4294967233) !== 0) || ((((_la - 34)) & ~0x1F) === 0 && ((1 << (_la - 34)) & 4294967295) !== 0) || ((((_la - 66)) & ~0x1F) === 0 && ((1 << (_la - 66)) & 4294967295) !== 0) || ((((_la - 98)) & ~0x1F) === 0 && ((1 << (_la - 98)) & 4261412863) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & 4294967295) !== 0) || ((((_la - 162)) & ~0x1F) === 0 && ((1 << (_la - 162)) & 4294967295) !== 0) || ((((_la - 194)) & ~0x1F) === 0 && ((1 << (_la - 194)) & 4294967291) !== 0) || ((((_la - 226)) & ~0x1F) === 0 && ((1 << (_la - 226)) & 4294967295) !== 0) || ((((_la - 258)) & ~0x1F) === 0 && ((1 << (_la - 258)) & 4294967263) !== 0) || ((((_la - 290)) & ~0x1F) === 0 && ((1 << (_la - 290)) & 4294967287) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & 2147483647) !== 0) || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 1073678415) !== 0)) {
                {
                this.state = 1792;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 352) {
                    {
                    this.state = 1791;
                    this.match(SparkSqlParser.EQ);
                    }
                }

                this.state = 1794;
                localContext._value = this.expression();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public constantList(): ConstantListContext {
        let localContext = new ConstantListContext(this.context, this.state);
        this.enterRule(localContext, 66, SparkSqlParser.RULE_constantList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1797;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 1798;
            this.constant();
            this.state = 1803;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1799;
                this.match(SparkSqlParser.COMMA);
                this.state = 1800;
                this.constant();
                }
                }
                this.state = 1805;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1806;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nestedConstantList(): NestedConstantListContext {
        let localContext = new NestedConstantListContext(this.context, this.state);
        this.enterRule(localContext, 68, SparkSqlParser.RULE_nestedConstantList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1808;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 1809;
            this.constantList();
            this.state = 1814;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1810;
                this.match(SparkSqlParser.COMMA);
                this.state = 1811;
                this.constantList();
                }
                }
                this.state = 1816;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 1817;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public createFileFormat(): CreateFileFormatContext {
        let localContext = new CreateFileFormatContext(this.context, this.state);
        this.enterRule(localContext, 70, SparkSqlParser.RULE_createFileFormat);
        try {
            this.state = 1825;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 200, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1819;
                this.match(SparkSqlParser.KW_STORED);
                this.state = 1820;
                this.match(SparkSqlParser.KW_AS);
                this.state = 1821;
                this.fileFormat();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1822;
                this.match(SparkSqlParser.KW_STORED);
                this.state = 1823;
                this.match(SparkSqlParser.KW_BY);
                this.state = 1824;
                this.storageHandler();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public fileFormat(): FileFormatContext {
        let localContext = new FileFormatContext(this.context, this.state);
        this.enterRule(localContext, 72, SparkSqlParser.RULE_fileFormat);
        try {
            this.state = 1833;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 201, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1827;
                this.match(SparkSqlParser.KW_INPUTFORMAT);
                this.state = 1828;
                localContext._inFmt = this.stringLit();
                this.state = 1829;
                this.match(SparkSqlParser.KW_OUTPUTFORMAT);
                this.state = 1830;
                localContext._outFmt = this.stringLit();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1832;
                this.identifier();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public storageHandler(): StorageHandlerContext {
        let localContext = new StorageHandlerContext(this.context, this.state);
        this.enterRule(localContext, 74, SparkSqlParser.RULE_storageHandler);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1835;
            this.stringLit();
            this.state = 1839;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 202, this.context) ) {
            case 1:
                {
                this.state = 1836;
                this.match(SparkSqlParser.KW_WITH);
                this.state = 1837;
                this.match(SparkSqlParser.KW_SERDEPROPERTIES);
                this.state = 1838;
                this.propertyList();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public resource(): ResourceContext {
        let localContext = new ResourceContext(this.context, this.state);
        this.enterRule(localContext, 76, SparkSqlParser.RULE_resource);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1841;
            this.identifier();
            this.state = 1842;
            this.stringLit();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dmlStatementNoWith(): DmlStatementNoWithContext {
        let localContext = new DmlStatementNoWithContext(this.context, this.state);
        this.enterRule(localContext, 78, SparkSqlParser.RULE_dmlStatementNoWith);
        let _la: number;
        try {
            let alternative: number;
            this.state = 1900;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_INSERT:
                localContext = new InsertFromQueryContext(localContext);
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1844;
                this.insertInto();
                this.state = 1845;
                this.query();
                }
                break;
            case SparkSqlParser.KW_FROM:
                localContext = new MultipleInsertContext(localContext);
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1847;
                this.fromClause();
                this.state = 1849;
                this.errorHandler.sync(this);
                alternative = 1;
                do {
                    switch (alternative) {
                    case 1:
                        {
                        {
                        this.state = 1848;
                        this.multiInsertQueryBody();
                        }
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    this.state = 1851;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 203, this.context);
                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
                }
                break;
            case SparkSqlParser.KW_DELETE:
                localContext = new DeleteFromTableContext(localContext);
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 1853;
                this.match(SparkSqlParser.KW_DELETE);
                this.state = 1854;
                this.match(SparkSqlParser.KW_FROM);
                this.state = 1855;
                this.tableName();
                this.state = 1856;
                this.tableAlias();
                this.state = 1858;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 344) {
                    {
                    this.state = 1857;
                    this.whereClause();
                    }
                }

                }
                break;
            case SparkSqlParser.KW_UPDATE:
                localContext = new UpdateTableContext(localContext);
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 1860;
                this.match(SparkSqlParser.KW_UPDATE);
                this.state = 1861;
                this.tableName();
                this.state = 1862;
                this.tableAlias();
                this.state = 1863;
                this.setClause();
                this.state = 1865;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 344) {
                    {
                    this.state = 1864;
                    this.whereClause();
                    }
                }

                }
                break;
            case SparkSqlParser.KW_MERGE:
                localContext = new MergeIntoTableContext(localContext);
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 1867;
                this.match(SparkSqlParser.KW_MERGE);
                this.state = 1868;
                this.match(SparkSqlParser.KW_INTO);
                this.state = 1869;
                (localContext as MergeIntoTableContext)._target = this.tableName();
                this.state = 1870;
                (localContext as MergeIntoTableContext)._targetAlias = this.tableAlias();
                this.state = 1871;
                this.match(SparkSqlParser.KW_USING);
                this.state = 1877;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_ADD:
                case SparkSqlParser.KW_AFTER:
                case SparkSqlParser.KW_ALL:
                case SparkSqlParser.KW_ALTER:
                case SparkSqlParser.KW_ALWAYS:
                case SparkSqlParser.KW_ANALYZE:
                case SparkSqlParser.KW_AND:
                case SparkSqlParser.KW_ANTI:
                case SparkSqlParser.KW_ANY:
                case SparkSqlParser.KW_ANY_VALUE:
                case SparkSqlParser.KW_ARCHIVE:
                case SparkSqlParser.KW_ARRAY:
                case SparkSqlParser.KW_AS:
                case SparkSqlParser.KW_ASC:
                case SparkSqlParser.KW_AT:
                case SparkSqlParser.KW_AUTHORIZATION:
                case SparkSqlParser.KW_BETWEEN:
                case SparkSqlParser.KW_BIGINT:
                case SparkSqlParser.KW_BINARY:
                case SparkSqlParser.KW_BOOLEAN:
                case SparkSqlParser.KW_BOTH:
                case SparkSqlParser.KW_BUCKET:
                case SparkSqlParser.KW_BUCKETS:
                case SparkSqlParser.KW_BY:
                case SparkSqlParser.KW_BYTE:
                case SparkSqlParser.KW_CACHE:
                case SparkSqlParser.KW_CASCADE:
                case SparkSqlParser.KW_CASE:
                case SparkSqlParser.KW_CAST:
                case SparkSqlParser.KW_CATALOG:
                case SparkSqlParser.KW_CATALOGS:
                case SparkSqlParser.KW_CHANGE:
                case SparkSqlParser.KW_CHAR:
                case SparkSqlParser.KW_CHARACTER:
                case SparkSqlParser.KW_CHECK:
                case SparkSqlParser.KW_CLEAR:
                case SparkSqlParser.KW_CLUSTER:
                case SparkSqlParser.KW_CLUSTERED:
                case SparkSqlParser.KW_CODEGEN:
                case SparkSqlParser.KW_COLLATE:
                case SparkSqlParser.KW_COLLECTION:
                case SparkSqlParser.KW_COLUMN:
                case SparkSqlParser.KW_COLUMNS:
                case SparkSqlParser.KW_COMMENT:
                case SparkSqlParser.KW_COMMIT:
                case SparkSqlParser.KW_COMPACT:
                case SparkSqlParser.KW_COMPACTIONS:
                case SparkSqlParser.KW_COMPUTE:
                case SparkSqlParser.KW_CONCATENATE:
                case SparkSqlParser.KW_CONSTRAINT:
                case SparkSqlParser.KW_COST:
                case SparkSqlParser.KW_CREATE:
                case SparkSqlParser.KW_CROSS:
                case SparkSqlParser.KW_CUBE:
                case SparkSqlParser.KW_CURRENT:
                case SparkSqlParser.KW_CURRENT_DATE:
                case SparkSqlParser.KW_CURRENT_TIME:
                case SparkSqlParser.KW_CURRENT_TIMESTAMP:
                case SparkSqlParser.KW_CURRENT_USER:
                case SparkSqlParser.KW_DAY:
                case SparkSqlParser.KW_DAYS:
                case SparkSqlParser.KW_DAYOFYEAR:
                case SparkSqlParser.KW_DATA:
                case SparkSqlParser.KW_DATE:
                case SparkSqlParser.KW_DATABASE:
                case SparkSqlParser.KW_DATABASES:
                case SparkSqlParser.KW_DATEADD:
                case SparkSqlParser.KW_DATE_ADD:
                case SparkSqlParser.KW_DATEDIFF:
                case SparkSqlParser.KW_DATE_DIFF:
                case SparkSqlParser.KW_DBPROPERTIES:
                case SparkSqlParser.KW_DEC:
                case SparkSqlParser.KW_DECIMAL:
                case SparkSqlParser.KW_DECLARE:
                case SparkSqlParser.KW_DEFAULT:
                case SparkSqlParser.KW_DEFINED:
                case SparkSqlParser.KW_DELETE:
                case SparkSqlParser.KW_DELIMITED:
                case SparkSqlParser.KW_DESC:
                case SparkSqlParser.KW_DESCRIBE:
                case SparkSqlParser.KW_DFS:
                case SparkSqlParser.KW_DIRECTORIES:
                case SparkSqlParser.KW_DIRECTORY:
                case SparkSqlParser.KW_DISABLE:
                case SparkSqlParser.KW_DISTINCT:
                case SparkSqlParser.KW_DISTRIBUTE:
                case SparkSqlParser.KW_DIV:
                case SparkSqlParser.KW_DOUBLE:
                case SparkSqlParser.KW_DROP:
                case SparkSqlParser.KW_ELSE:
                case SparkSqlParser.KW_ENABLE:
                case SparkSqlParser.KW_END:
                case SparkSqlParser.KW_ESCAPE:
                case SparkSqlParser.KW_ESCAPED:
                case SparkSqlParser.KW_EXCEPT:
                case SparkSqlParser.KW_EXCHANGE:
                case SparkSqlParser.KW_EXCLUDE:
                case SparkSqlParser.KW_EXISTS:
                case SparkSqlParser.KW_EXPLAIN:
                case SparkSqlParser.KW_EXPORT:
                case SparkSqlParser.KW_EXTENDED:
                case SparkSqlParser.KW_EXTERNAL:
                case SparkSqlParser.KW_EXTRACT:
                case SparkSqlParser.KW_FALSE:
                case SparkSqlParser.KW_FETCH:
                case SparkSqlParser.KW_FIELDS:
                case SparkSqlParser.KW_FILTER:
                case SparkSqlParser.KW_FILEFORMAT:
                case SparkSqlParser.KW_FIRST:
                case SparkSqlParser.KW_FLOAT:
                case SparkSqlParser.KW_FOLLOWING:
                case SparkSqlParser.KW_FOR:
                case SparkSqlParser.KW_FOREIGN:
                case SparkSqlParser.KW_FORMAT:
                case SparkSqlParser.KW_FORMATTED:
                case SparkSqlParser.KW_FULL:
                case SparkSqlParser.KW_FUNCTION:
                case SparkSqlParser.KW_FUNCTIONS:
                case SparkSqlParser.KW_GENERATED:
                case SparkSqlParser.KW_GLOBAL:
                case SparkSqlParser.KW_GRANT:
                case SparkSqlParser.KW_GROUP:
                case SparkSqlParser.KW_GROUPING:
                case SparkSqlParser.KW_HAVING:
                case SparkSqlParser.KW_BINARY_HEX:
                case SparkSqlParser.KW_HOUR:
                case SparkSqlParser.KW_HOURS:
                case SparkSqlParser.KW_IDENTIFIER:
                case SparkSqlParser.KW_IF:
                case SparkSqlParser.KW_IGNORE:
                case SparkSqlParser.KW_IMPORT:
                case SparkSqlParser.KW_IN:
                case SparkSqlParser.KW_INCLUDE:
                case SparkSqlParser.KW_INDEX:
                case SparkSqlParser.KW_INDEXES:
                case SparkSqlParser.KW_INNER:
                case SparkSqlParser.KW_INPATH:
                case SparkSqlParser.KW_INPUTFORMAT:
                case SparkSqlParser.KW_INSERT:
                case SparkSqlParser.KW_INTERSECT:
                case SparkSqlParser.KW_INTERVAL:
                case SparkSqlParser.KW_INT:
                case SparkSqlParser.KW_INTEGER:
                case SparkSqlParser.KW_INTO:
                case SparkSqlParser.KW_IS:
                case SparkSqlParser.KW_ITEMS:
                case SparkSqlParser.KW_JOIN:
                case SparkSqlParser.KW_KEYS:
                case SparkSqlParser.KW_LAST:
                case SparkSqlParser.KW_LATERAL:
                case SparkSqlParser.KW_LAZY:
                case SparkSqlParser.KW_LEADING:
                case SparkSqlParser.KW_LEFT:
                case SparkSqlParser.KW_LIFECYCLE:
                case SparkSqlParser.KW_LIKE:
                case SparkSqlParser.KW_ILIKE:
                case SparkSqlParser.KW_LIMIT:
                case SparkSqlParser.KW_LINES:
                case SparkSqlParser.KW_LIST:
                case SparkSqlParser.KW_LOAD:
                case SparkSqlParser.KW_LOCAL:
                case SparkSqlParser.KW_LOCATION:
                case SparkSqlParser.KW_LOCK:
                case SparkSqlParser.KW_LOCKS:
                case SparkSqlParser.KW_LOGICAL:
                case SparkSqlParser.KW_LONG:
                case SparkSqlParser.KW_MACRO:
                case SparkSqlParser.KW_MATERIALIZED:
                case SparkSqlParser.KW_MAP:
                case SparkSqlParser.KW_MATCHED:
                case SparkSqlParser.KW_MERGE:
                case SparkSqlParser.KW_MICROSECOND:
                case SparkSqlParser.KW_MICROSECONDS:
                case SparkSqlParser.KW_MILLISECOND:
                case SparkSqlParser.KW_MILLISECONDS:
                case SparkSqlParser.KW_MINUTE:
                case SparkSqlParser.KW_MINUTES:
                case SparkSqlParser.KW_MONTH:
                case SparkSqlParser.KW_MONTHS:
                case SparkSqlParser.KW_MSCK:
                case SparkSqlParser.KW_NAME:
                case SparkSqlParser.KW_NAMESPACE:
                case SparkSqlParser.KW_NAMESPACES:
                case SparkSqlParser.KW_NANOSECOND:
                case SparkSqlParser.KW_NANOSECONDS:
                case SparkSqlParser.KW_NATURAL:
                case SparkSqlParser.KW_NO:
                case SparkSqlParser.KW_NOT:
                case SparkSqlParser.KW_NULL:
                case SparkSqlParser.KW_NULLS:
                case SparkSqlParser.KW_NUMERIC:
                case SparkSqlParser.KW_OF:
                case SparkSqlParser.KW_OFFSET:
                case SparkSqlParser.KW_ON:
                case SparkSqlParser.KW_ONLY:
                case SparkSqlParser.KW_OPTIMIZE:
                case SparkSqlParser.KW_OPTION:
                case SparkSqlParser.KW_OPTIONS:
                case SparkSqlParser.KW_OR:
                case SparkSqlParser.KW_ORDER:
                case SparkSqlParser.KW_OUT:
                case SparkSqlParser.KW_OUTER:
                case SparkSqlParser.KW_OUTPUTFORMAT:
                case SparkSqlParser.KW_OVER:
                case SparkSqlParser.KW_OVERLAPS:
                case SparkSqlParser.KW_OVERLAY:
                case SparkSqlParser.KW_OVERWRITE:
                case SparkSqlParser.KW_PARTITION:
                case SparkSqlParser.KW_PARTITIONED:
                case SparkSqlParser.KW_PARTITIONS:
                case SparkSqlParser.KW_PERCENTILE_CONT:
                case SparkSqlParser.KW_PERCENTILE_DISC:
                case SparkSqlParser.KW_PERCENTLIT:
                case SparkSqlParser.KW_PIVOT:
                case SparkSqlParser.KW_PLACING:
                case SparkSqlParser.KW_POSITION:
                case SparkSqlParser.KW_PRECEDING:
                case SparkSqlParser.KW_PRIMARY:
                case SparkSqlParser.KW_PRINCIPALS:
                case SparkSqlParser.KW_PROPERTIES:
                case SparkSqlParser.KW_PURGE:
                case SparkSqlParser.KW_QUARTER:
                case SparkSqlParser.KW_QUERY:
                case SparkSqlParser.KW_RANGE:
                case SparkSqlParser.KW_REAL:
                case SparkSqlParser.KW_RECORDREADER:
                case SparkSqlParser.KW_RECORDWRITER:
                case SparkSqlParser.KW_RECOVER:
                case SparkSqlParser.KW_REDUCE:
                case SparkSqlParser.KW_REFERENCES:
                case SparkSqlParser.KW_REFRESH:
                case SparkSqlParser.KW_RENAME:
                case SparkSqlParser.KW_REPAIR:
                case SparkSqlParser.KW_REPEATABLE:
                case SparkSqlParser.KW_REPLACE:
                case SparkSqlParser.KW_RESET:
                case SparkSqlParser.KW_RESPECT:
                case SparkSqlParser.KW_RESTRICT:
                case SparkSqlParser.KW_REWRITE:
                case SparkSqlParser.KW_REVOKE:
                case SparkSqlParser.KW_RIGHT:
                case SparkSqlParser.KW_RLIKE:
                case SparkSqlParser.KW_REGEXP:
                case SparkSqlParser.KW_ROLE:
                case SparkSqlParser.KW_ROLES:
                case SparkSqlParser.KW_ROLLBACK:
                case SparkSqlParser.KW_ROLLUP:
                case SparkSqlParser.KW_ROW:
                case SparkSqlParser.KW_ROWS:
                case SparkSqlParser.KW_SECOND:
                case SparkSqlParser.KW_SECONDS:
                case SparkSqlParser.KW_SCHEMA:
                case SparkSqlParser.KW_SCHEMAS:
                case SparkSqlParser.KW_SEMI:
                case SparkSqlParser.KW_SEPARATED:
                case SparkSqlParser.KW_SERDE:
                case SparkSqlParser.KW_SERDEPROPERTIES:
                case SparkSqlParser.KW_SESSION_USER:
                case SparkSqlParser.KW_SET:
                case SparkSqlParser.KW_MINUS:
                case SparkSqlParser.KW_SETS:
                case SparkSqlParser.KW_SHORT:
                case SparkSqlParser.KW_SHOW:
                case SparkSqlParser.KW_SINGLE:
                case SparkSqlParser.KW_SKEWED:
                case SparkSqlParser.KW_SMALLINT:
                case SparkSqlParser.KW_SOME:
                case SparkSqlParser.KW_SORT:
                case SparkSqlParser.KW_SORTED:
                case SparkSqlParser.KW_SOURCE:
                case SparkSqlParser.KW_START:
                case SparkSqlParser.KW_STATISTICS:
                case SparkSqlParser.KW_STORED:
                case SparkSqlParser.KW_STRATIFY:
                case SparkSqlParser.KW_STRING:
                case SparkSqlParser.KW_STRUCT:
                case SparkSqlParser.KW_SUBSTR:
                case SparkSqlParser.KW_SUBSTRING:
                case SparkSqlParser.KW_SYNC:
                case SparkSqlParser.KW_SYSTEM:
                case SparkSqlParser.KW_SYSTEM_TIME:
                case SparkSqlParser.KW_SYSTEM_VERSION:
                case SparkSqlParser.KW_TABLES:
                case SparkSqlParser.KW_TABLESAMPLE:
                case SparkSqlParser.KW_TARGET:
                case SparkSqlParser.KW_TBLPROPERTIES:
                case SparkSqlParser.KW_TEMPORARY:
                case SparkSqlParser.KW_TERMINATED:
                case SparkSqlParser.KW_THEN:
                case SparkSqlParser.KW_TIME:
                case SparkSqlParser.KW_TIMEDIFF:
                case SparkSqlParser.KW_TIMESTAMP:
                case SparkSqlParser.KW_TIMESTAMP_LTZ:
                case SparkSqlParser.KW_TIMESTAMP_NTZ:
                case SparkSqlParser.KW_TIMESTAMPADD:
                case SparkSqlParser.KW_TIMESTAMPDIFF:
                case SparkSqlParser.KW_TINYINT:
                case SparkSqlParser.KW_TO:
                case SparkSqlParser.KW_TOUCH:
                case SparkSqlParser.KW_TRAILING:
                case SparkSqlParser.KW_TRANSACTION:
                case SparkSqlParser.KW_TRANSACTIONS:
                case SparkSqlParser.KW_TRANSFORM:
                case SparkSqlParser.KW_TRIM:
                case SparkSqlParser.KW_TRUE:
                case SparkSqlParser.KW_TRUNCATE:
                case SparkSqlParser.KW_TRY_CAST:
                case SparkSqlParser.KW_TYPE:
                case SparkSqlParser.KW_UNARCHIVE:
                case SparkSqlParser.KW_UNBOUNDED:
                case SparkSqlParser.KW_UNCACHE:
                case SparkSqlParser.KW_UNION:
                case SparkSqlParser.KW_UNIQUE:
                case SparkSqlParser.KW_UNKNOWN:
                case SparkSqlParser.KW_UNLOCK:
                case SparkSqlParser.KW_UNPIVOT:
                case SparkSqlParser.KW_UNSET:
                case SparkSqlParser.KW_UPDATE:
                case SparkSqlParser.KW_USE:
                case SparkSqlParser.KW_USER:
                case SparkSqlParser.KW_USING:
                case SparkSqlParser.KW_VALUES:
                case SparkSqlParser.KW_VARCHAR:
                case SparkSqlParser.KW_VAR:
                case SparkSqlParser.KW_VARIABLE:
                case SparkSqlParser.KW_VERSION:
                case SparkSqlParser.KW_VIEW:
                case SparkSqlParser.KW_VIEWS:
                case SparkSqlParser.KW_VOID:
                case SparkSqlParser.KW_WEEK:
                case SparkSqlParser.KW_WEEKS:
                case SparkSqlParser.KW_WHEN:
                case SparkSqlParser.KW_WHERE:
                case SparkSqlParser.KW_WINDOW:
                case SparkSqlParser.KW_WITH:
                case SparkSqlParser.KW_WITHIN:
                case SparkSqlParser.KW_YEAR:
                case SparkSqlParser.KW_YEARS:
                case SparkSqlParser.KW_ZONE:
                case SparkSqlParser.KW_ZORDER:
                case SparkSqlParser.DOUBLEQUOTED_STRING:
                case SparkSqlParser.IDENTIFIER:
                case SparkSqlParser.BACKQUOTED_IDENTIFIER:
                    {
                    this.state = 1872;
                    (localContext as MergeIntoTableContext)._source = this.identifierReference();
                    }
                    break;
                case SparkSqlParser.LEFT_PAREN:
                    {
                    this.state = 1873;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 1874;
                    (localContext as MergeIntoTableContext)._sourceQuery = this.query();
                    this.state = 1875;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 1879;
                (localContext as MergeIntoTableContext)._sourceAlias = this.tableAlias();
                this.state = 1880;
                this.match(SparkSqlParser.KW_ON);
                this.state = 1881;
                (localContext as MergeIntoTableContext)._mergeCondition = this.booleanExpression(0);
                this.state = 1885;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 207, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 1882;
                        this.matchedClause();
                        }
                        }
                    }
                    this.state = 1887;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 207, this.context);
                }
                this.state = 1891;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 208, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 1888;
                        this.notMatchedClause();
                        }
                        }
                    }
                    this.state = 1893;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 208, this.context);
                }
                this.state = 1897;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 343) {
                    {
                    {
                    this.state = 1894;
                    this.notMatchedBySourceClause();
                    }
                    }
                    this.state = 1899;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namespaceName(): NamespaceNameContext {
        let localContext = new NamespaceNameContext(this.context, this.state);
        this.enterRule(localContext, 80, SparkSqlParser.RULE_namespaceName);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1902;
            this.identifierReference();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namespaceNameCreate(): NamespaceNameCreateContext {
        let localContext = new NamespaceNameCreateContext(this.context, this.state);
        this.enterRule(localContext, 82, SparkSqlParser.RULE_namespaceNameCreate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1904;
            this.identifierReference();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableNameCreate(): TableNameCreateContext {
        let localContext = new TableNameCreateContext(this.context, this.state);
        this.enterRule(localContext, 84, SparkSqlParser.RULE_tableNameCreate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1906;
            this.tableIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableName(): TableNameContext {
        let localContext = new TableNameContext(this.context, this.state);
        this.enterRule(localContext, 86, SparkSqlParser.RULE_tableName);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1908;
            this.tableIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public viewNameCreate(): ViewNameCreateContext {
        let localContext = new ViewNameCreateContext(this.context, this.state);
        this.enterRule(localContext, 88, SparkSqlParser.RULE_viewNameCreate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1910;
            this.viewIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public viewName(): ViewNameContext {
        let localContext = new ViewNameContext(this.context, this.state);
        this.enterRule(localContext, 90, SparkSqlParser.RULE_viewName);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1912;
            this.viewIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public columnName(): ColumnNameContext {
        let localContext = new ColumnNameContext(this.context, this.state);
        this.enterRule(localContext, 92, SparkSqlParser.RULE_columnName);
        try {
            this.state = 1916;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 211, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1914;
                this.multipartIdentifier();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1915;
                if (!(this.shouldMatchEmpty())) {
                    throw this.createFailedPredicateException("this.shouldMatchEmpty()");
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public columnNameSeq(): ColumnNameSeqContext {
        let localContext = new ColumnNameSeqContext(this.context, this.state);
        this.enterRule(localContext, 94, SparkSqlParser.RULE_columnNameSeq);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1918;
            this.columnName();
            this.state = 1923;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 1919;
                this.match(SparkSqlParser.COMMA);
                this.state = 1920;
                this.columnName();
                }
                }
                this.state = 1925;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public columnNameCreate(): ColumnNameCreateContext {
        let localContext = new ColumnNameCreateContext(this.context, this.state);
        this.enterRule(localContext, 96, SparkSqlParser.RULE_columnNameCreate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1926;
            this.errorCapturingIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifierReference(): IdentifierReferenceContext {
        let localContext = new IdentifierReferenceContext(this.context, this.state);
        this.enterRule(localContext, 98, SparkSqlParser.RULE_identifierReference);
        try {
            this.state = 1934;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 213, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 1928;
                this.match(SparkSqlParser.KW_IDENTIFIER);
                this.state = 1929;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 1930;
                this.expression();
                this.state = 1931;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 1933;
                this.multipartIdentifier();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public queryOrganization(): QueryOrganizationContext {
        let localContext = new QueryOrganizationContext(this.context, this.state);
        this.enterRule(localContext, 100, SparkSqlParser.RULE_queryOrganization);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1946;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 215, this.context) ) {
            case 1:
                {
                this.state = 1936;
                this.match(SparkSqlParser.KW_ORDER);
                this.state = 1937;
                this.match(SparkSqlParser.KW_BY);
                this.state = 1938;
                localContext._sortItem = this.sortItem();
                localContext._order.push(localContext._sortItem);
                this.state = 1943;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 214, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 1939;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 1940;
                        localContext._sortItem = this.sortItem();
                        localContext._order.push(localContext._sortItem);
                        }
                        }
                    }
                    this.state = 1945;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 214, this.context);
                }
                }
                break;
            }
            this.state = 1958;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 217, this.context) ) {
            case 1:
                {
                this.state = 1948;
                this.match(SparkSqlParser.KW_CLUSTER);
                this.state = 1949;
                this.match(SparkSqlParser.KW_BY);
                this.state = 1950;
                localContext._expression = this.expression();
                localContext._clusterBy.push(localContext._expression);
                this.state = 1955;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 216, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 1951;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 1952;
                        localContext._expression = this.expression();
                        localContext._clusterBy.push(localContext._expression);
                        }
                        }
                    }
                    this.state = 1957;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 216, this.context);
                }
                }
                break;
            }
            this.state = 1970;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 219, this.context) ) {
            case 1:
                {
                this.state = 1960;
                this.match(SparkSqlParser.KW_DISTRIBUTE);
                this.state = 1961;
                this.match(SparkSqlParser.KW_BY);
                this.state = 1962;
                localContext._expression = this.expression();
                localContext._distributeBy.push(localContext._expression);
                this.state = 1967;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 218, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 1963;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 1964;
                        localContext._expression = this.expression();
                        localContext._distributeBy.push(localContext._expression);
                        }
                        }
                    }
                    this.state = 1969;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 218, this.context);
                }
                }
                break;
            }
            this.state = 1982;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 221, this.context) ) {
            case 1:
                {
                this.state = 1972;
                this.match(SparkSqlParser.KW_SORT);
                this.state = 1973;
                this.match(SparkSqlParser.KW_BY);
                this.state = 1974;
                localContext._sortItem = this.sortItem();
                localContext._sort.push(localContext._sortItem);
                this.state = 1979;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 220, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 1975;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 1976;
                        localContext._sortItem = this.sortItem();
                        localContext._sort.push(localContext._sortItem);
                        }
                        }
                    }
                    this.state = 1981;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 220, this.context);
                }
                }
                break;
            }
            this.state = 1985;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 222, this.context) ) {
            case 1:
                {
                this.state = 1984;
                this.windowClause();
                }
                break;
            }
            this.state = 1992;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 224, this.context) ) {
            case 1:
                {
                this.state = 1987;
                this.match(SparkSqlParser.KW_LIMIT);
                this.state = 1990;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 223, this.context) ) {
                case 1:
                    {
                    this.state = 1988;
                    this.match(SparkSqlParser.KW_ALL);
                    }
                    break;
                case 2:
                    {
                    this.state = 1989;
                    localContext._limit = this.expression();
                    }
                    break;
                }
                }
                break;
            }
            this.state = 1996;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 225, this.context) ) {
            case 1:
                {
                this.state = 1994;
                this.match(SparkSqlParser.KW_OFFSET);
                this.state = 1995;
                localContext._offset = this.expression();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public multiInsertQueryBody(): MultiInsertQueryBodyContext {
        let localContext = new MultiInsertQueryBodyContext(this.context, this.state);
        this.enterRule(localContext, 102, SparkSqlParser.RULE_multiInsertQueryBody);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 1998;
            this.insertInto();
            this.state = 1999;
            this.fromStatementBody();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

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

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new QueryTermContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 104;
        this.enterRecursionRule(localContext, 104, SparkSqlParser.RULE_queryTerm, _p);
        let _la: number;
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            {
            this.state = 2002;
            this.queryPrimary();
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 2024;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 230, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this._parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    this.state = 2022;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 229, this.context) ) {
                    case 1:
                        {
                        localContext = new QueryTermContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_queryTerm);
                        this.state = 2004;
                        if (!(this.precpred(this.context, 3))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 3)");
                        }
                        this.state = 2005;
                        localContext._operator = this.tokenStream.LT(1);
                        _la = this.tokenStream.LA(1);
                        if(!(_la === 102 || _la === 148 || _la === 270 || _la === 323)) {
                            localContext._operator = this.errorHandler.recoverInline(this);
                        }
                        else {
                            this.errorHandler.reportMatch(this);
                            this.consume();
                        }
                        this.state = 2007;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                        if (_la === 10 || _la === 92) {
                            {
                            this.state = 2006;
                            this.setQuantifier();
                            }
                        }

                        this.state = 2009;
                        localContext._right = this.queryTerm(4);
                        }
                        break;
                    case 2:
                        {
                        localContext = new QueryTermContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_queryTerm);
                        this.state = 2010;
                        if (!(this.precpred(this.context, 2))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
                        }
                        this.state = 2011;
                        localContext._operator = this.match(SparkSqlParser.KW_INTERSECT);
                        this.state = 2013;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                        if (_la === 10 || _la === 92) {
                            {
                            this.state = 2012;
                            this.setQuantifier();
                            }
                        }

                        this.state = 2015;
                        localContext._right = this.queryTerm(3);
                        }
                        break;
                    case 3:
                        {
                        localContext = new QueryTermContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_queryTerm);
                        this.state = 2016;
                        if (!(this.precpred(this.context, 1))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 1)");
                        }
                        this.state = 2017;
                        localContext._operator = this.tokenStream.LT(1);
                        _la = this.tokenStream.LA(1);
                        if(!(_la === 102 || _la === 270 || _la === 323)) {
                            localContext._operator = this.errorHandler.recoverInline(this);
                        }
                        else {
                            this.errorHandler.reportMatch(this);
                            this.consume();
                        }
                        this.state = 2019;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                        if (_la === 10 || _la === 92) {
                            {
                            this.state = 2018;
                            this.setQuantifier();
                            }
                        }

                        this.state = 2021;
                        localContext._right = this.queryTerm(2);
                        }
                        break;
                    }
                    }
                }
                this.state = 2026;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 230, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public queryPrimary(): QueryPrimaryContext {
        let localContext = new QueryPrimaryContext(this.context, this.state);
        this.enterRule(localContext, 106, SparkSqlParser.RULE_queryPrimary);
        try {
            this.state = 2036;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_MAP:
            case SparkSqlParser.KW_REDUCE:
            case SparkSqlParser.KW_SELECT:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2027;
                this.querySpecification();
                }
                break;
            case SparkSqlParser.KW_FROM:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2028;
                this.fromStatement();
                }
                break;
            case SparkSqlParser.KW_TABLE:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2029;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 2030;
                this.tableName();
                }
                break;
            case SparkSqlParser.KW_VALUES:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2031;
                this.inlineTable();
                }
                break;
            case SparkSqlParser.LEFT_PAREN:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2032;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2033;
                this.query();
                this.state = 2034;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public sortItem(): SortItemContext {
        let localContext = new SortItemContext(this.context, this.state);
        this.enterRule(localContext, 108, SparkSqlParser.RULE_sortItem);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2040;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 232, this.context) ) {
            case 1:
                {
                this.state = 2038;
                this.columnName();
                }
                break;
            case 2:
                {
                this.state = 2039;
                this.expression();
                }
                break;
            }
            this.state = 2043;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 233, this.context) ) {
            case 1:
                {
                this.state = 2042;
                localContext._ordering = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 21 || _la === 86)) {
                    localContext._ordering = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            }
            this.state = 2047;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 234, this.context) ) {
            case 1:
                {
                this.state = 2045;
                this.match(SparkSqlParser.KW_NULLS);
                this.state = 2046;
                localContext._nullOrder = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 116 || _la === 157)) {
                    localContext._nullOrder = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public fromStatement(): FromStatementContext {
        let localContext = new FromStatementContext(this.context, this.state);
        this.enterRule(localContext, 110, SparkSqlParser.RULE_fromStatement);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2049;
            this.fromClause();
            this.state = 2051;
            this.errorHandler.sync(this);
            alternative = 1;
            do {
                switch (alternative) {
                case 1:
                    {
                    {
                    this.state = 2050;
                    this.fromStatementBody();
                    }
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 2053;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 235, this.context);
            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public fromStatementBody(): FromStatementBodyContext {
        let localContext = new FromStatementBodyContext(this.context, this.state);
        this.enterRule(localContext, 112, SparkSqlParser.RULE_fromStatementBody);
        try {
            let alternative: number;
            this.state = 2082;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 242, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2055;
                this.transformClause();
                this.state = 2057;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 236, this.context) ) {
                case 1:
                    {
                    this.state = 2056;
                    this.whereClause();
                    }
                    break;
                }
                this.state = 2059;
                this.queryOrganization();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2061;
                this.selectClause();
                this.state = 2065;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 237, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2062;
                        this.lateralView();
                        }
                        }
                    }
                    this.state = 2067;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 237, this.context);
                }
                this.state = 2069;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 238, this.context) ) {
                case 1:
                    {
                    this.state = 2068;
                    this.whereClause();
                    }
                    break;
                }
                this.state = 2072;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 239, this.context) ) {
                case 1:
                    {
                    this.state = 2071;
                    this.aggregationClause();
                    }
                    break;
                }
                this.state = 2075;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 240, this.context) ) {
                case 1:
                    {
                    this.state = 2074;
                    this.havingClause();
                    }
                    break;
                }
                this.state = 2078;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 241, this.context) ) {
                case 1:
                    {
                    this.state = 2077;
                    this.windowClause();
                    }
                    break;
                }
                this.state = 2080;
                this.queryOrganization();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public querySpecification(): QuerySpecificationContext {
        let localContext = new QuerySpecificationContext(this.context, this.state);
        this.enterRule(localContext, 114, SparkSqlParser.RULE_querySpecification);
        try {
            let alternative: number;
            this.state = 2128;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 255, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2084;
                this.transformClause();
                this.state = 2086;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 243, this.context) ) {
                case 1:
                    {
                    this.state = 2085;
                    this.fromClause();
                    }
                    break;
                }
                this.state = 2091;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 244, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2088;
                        this.lateralView();
                        }
                        }
                    }
                    this.state = 2093;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 244, this.context);
                }
                this.state = 2095;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 245, this.context) ) {
                case 1:
                    {
                    this.state = 2094;
                    this.whereClause();
                    }
                    break;
                }
                this.state = 2098;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 246, this.context) ) {
                case 1:
                    {
                    this.state = 2097;
                    this.aggregationClause();
                    }
                    break;
                }
                this.state = 2101;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 247, this.context) ) {
                case 1:
                    {
                    this.state = 2100;
                    this.havingClause();
                    }
                    break;
                }
                this.state = 2104;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 248, this.context) ) {
                case 1:
                    {
                    this.state = 2103;
                    this.windowClause();
                    }
                    break;
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2106;
                this.selectClause();
                this.state = 2108;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 249, this.context) ) {
                case 1:
                    {
                    this.state = 2107;
                    this.fromClause();
                    }
                    break;
                }
                this.state = 2113;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 250, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2110;
                        this.lateralView();
                        }
                        }
                    }
                    this.state = 2115;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 250, this.context);
                }
                this.state = 2117;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 251, this.context) ) {
                case 1:
                    {
                    this.state = 2116;
                    this.whereClause();
                    }
                    break;
                }
                this.state = 2120;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 252, this.context) ) {
                case 1:
                    {
                    this.state = 2119;
                    this.aggregationClause();
                    }
                    break;
                }
                this.state = 2123;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 253, this.context) ) {
                case 1:
                    {
                    this.state = 2122;
                    this.havingClause();
                    }
                    break;
                }
                this.state = 2126;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 254, this.context) ) {
                case 1:
                    {
                    this.state = 2125;
                    this.windowClause();
                    }
                    break;
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public transformClause(): TransformClauseContext {
        let localContext = new TransformClauseContext(this.context, this.state);
        this.enterRule(localContext, 116, SparkSqlParser.RULE_transformClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2149;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_SELECT:
                {
                this.state = 2130;
                this.match(SparkSqlParser.KW_SELECT);
                this.state = 2131;
                localContext._kind = this.match(SparkSqlParser.KW_TRANSFORM);
                this.state = 2132;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2134;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 256, this.context) ) {
                case 1:
                    {
                    this.state = 2133;
                    this.setQuantifier();
                    }
                    break;
                }
                this.state = 2136;
                this.expressionSeq();
                this.state = 2137;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case SparkSqlParser.KW_MAP:
                {
                this.state = 2139;
                localContext._kind = this.match(SparkSqlParser.KW_MAP);
                this.state = 2141;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 257, this.context) ) {
                case 1:
                    {
                    this.state = 2140;
                    this.setQuantifier();
                    }
                    break;
                }
                this.state = 2143;
                this.expressionSeq();
                }
                break;
            case SparkSqlParser.KW_REDUCE:
                {
                this.state = 2144;
                localContext._kind = this.match(SparkSqlParser.KW_REDUCE);
                this.state = 2146;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 258, this.context) ) {
                case 1:
                    {
                    this.state = 2145;
                    this.setQuantifier();
                    }
                    break;
                }
                this.state = 2148;
                this.expressionSeq();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            this.state = 2152;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 257) {
                {
                this.state = 2151;
                localContext._inRowFormat = this.rowFormat();
                }
            }

            this.state = 2156;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 236) {
                {
                this.state = 2154;
                this.match(SparkSqlParser.KW_RECORDWRITER);
                this.state = 2155;
                localContext._recordWriter = this.stringLit();
                }
            }

            this.state = 2158;
            this.match(SparkSqlParser.KW_USING);
            this.state = 2159;
            localContext._script = this.stringLit();
            this.state = 2172;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 264, this.context) ) {
            case 1:
                {
                this.state = 2160;
                this.match(SparkSqlParser.KW_AS);
                this.state = 2170;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 263, this.context) ) {
                case 1:
                    {
                    this.state = 2161;
                    this.identifierSeq();
                    }
                    break;
                case 2:
                    {
                    this.state = 2162;
                    this.colTypeList();
                    }
                    break;
                case 3:
                    {
                    {
                    this.state = 2163;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 2166;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 262, this.context) ) {
                    case 1:
                        {
                        this.state = 2164;
                        this.identifierSeq();
                        }
                        break;
                    case 2:
                        {
                        this.state = 2165;
                        this.colTypeList();
                        }
                        break;
                    }
                    this.state = 2168;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    }
                    break;
                }
                }
                break;
            }
            this.state = 2175;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 265, this.context) ) {
            case 1:
                {
                this.state = 2174;
                localContext._outRowFormat = this.rowFormat();
                }
                break;
            }
            this.state = 2179;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 266, this.context) ) {
            case 1:
                {
                this.state = 2177;
                this.match(SparkSqlParser.KW_RECORDREADER);
                this.state = 2178;
                localContext._recordReader = this.stringLit();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public selectClause(): SelectClauseContext {
        let localContext = new SelectClauseContext(this.context, this.state);
        this.enterRule(localContext, 118, SparkSqlParser.RULE_selectClause);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2181;
            this.match(SparkSqlParser.KW_SELECT);
            this.state = 2185;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 267, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 2182;
                    localContext._hint = this.hint();
                    localContext._hints.push(localContext._hint);
                    }
                    }
                }
                this.state = 2187;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 267, this.context);
            }
            this.state = 2189;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 268, this.context) ) {
            case 1:
                {
                this.state = 2188;
                this.setQuantifier();
                }
                break;
            }
            this.state = 2191;
            this.namedExpressionSeq();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public setClause(): SetClauseContext {
        let localContext = new SetClauseContext(this.context, this.state);
        this.enterRule(localContext, 120, SparkSqlParser.RULE_setClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2193;
            this.match(SparkSqlParser.KW_SET);
            this.state = 2194;
            this.assignmentList();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public matchedClause(): MatchedClauseContext {
        let localContext = new MatchedClauseContext(this.context, this.state);
        this.enterRule(localContext, 122, SparkSqlParser.RULE_matchedClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2196;
            this.match(SparkSqlParser.KW_WHEN);
            this.state = 2197;
            this.match(SparkSqlParser.KW_MATCHED);
            this.state = 2200;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 14) {
                {
                this.state = 2198;
                this.match(SparkSqlParser.KW_AND);
                this.state = 2199;
                localContext._matchedCond = this.booleanExpression(0);
                }
            }

            this.state = 2202;
            this.match(SparkSqlParser.KW_THEN);
            this.state = 2203;
            this.matchedAction();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public notMatchedClause(): NotMatchedClauseContext {
        let localContext = new NotMatchedClauseContext(this.context, this.state);
        this.enterRule(localContext, 124, SparkSqlParser.RULE_notMatchedClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2205;
            this.match(SparkSqlParser.KW_WHEN);
            this.state = 2206;
            this.match(SparkSqlParser.KW_NOT);
            this.state = 2207;
            this.match(SparkSqlParser.KW_MATCHED);
            this.state = 2210;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 31) {
                {
                this.state = 2208;
                this.match(SparkSqlParser.KW_BY);
                this.state = 2209;
                this.match(SparkSqlParser.KW_TARGET);
                }
            }

            this.state = 2214;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 14) {
                {
                this.state = 2212;
                this.match(SparkSqlParser.KW_AND);
                this.state = 2213;
                localContext._notMatchedCond = this.booleanExpression(0);
                }
            }

            this.state = 2216;
            this.match(SparkSqlParser.KW_THEN);
            this.state = 2217;
            this.notMatchedAction();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public notMatchedBySourceClause(): NotMatchedBySourceClauseContext {
        let localContext = new NotMatchedBySourceClauseContext(this.context, this.state);
        this.enterRule(localContext, 126, SparkSqlParser.RULE_notMatchedBySourceClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2219;
            this.match(SparkSqlParser.KW_WHEN);
            this.state = 2220;
            this.match(SparkSqlParser.KW_NOT);
            this.state = 2221;
            this.match(SparkSqlParser.KW_MATCHED);
            this.state = 2222;
            this.match(SparkSqlParser.KW_BY);
            this.state = 2223;
            this.match(SparkSqlParser.KW_SOURCE);
            this.state = 2226;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 14) {
                {
                this.state = 2224;
                this.match(SparkSqlParser.KW_AND);
                this.state = 2225;
                localContext._notMatchedBySourceCond = this.booleanExpression(0);
                }
            }

            this.state = 2228;
            this.match(SparkSqlParser.KW_THEN);
            this.state = 2229;
            this.notMatchedBySourceAction();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public matchedAction(): MatchedActionContext {
        let localContext = new MatchedActionContext(this.context, this.state);
        this.enterRule(localContext, 128, SparkSqlParser.RULE_matchedAction);
        try {
            this.state = 2238;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 273, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2231;
                this.match(SparkSqlParser.KW_DELETE);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2232;
                this.match(SparkSqlParser.KW_UPDATE);
                this.state = 2233;
                this.match(SparkSqlParser.KW_SET);
                this.state = 2234;
                this.match(SparkSqlParser.ASTERISK);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2235;
                this.match(SparkSqlParser.KW_UPDATE);
                this.state = 2236;
                this.match(SparkSqlParser.KW_SET);
                this.state = 2237;
                this.assignmentList();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public notMatchedAction(): NotMatchedActionContext {
        let localContext = new NotMatchedActionContext(this.context, this.state);
        this.enterRule(localContext, 130, SparkSqlParser.RULE_notMatchedAction);
        let _la: number;
        try {
            this.state = 2258;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 275, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2240;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 2241;
                this.match(SparkSqlParser.ASTERISK);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2242;
                this.match(SparkSqlParser.KW_INSERT);
                this.state = 2243;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2244;
                this.multipartIdentifierList();
                this.state = 2245;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 2246;
                this.match(SparkSqlParser.KW_VALUES);
                this.state = 2247;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2248;
                this.expression();
                this.state = 2253;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2249;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2250;
                    this.expression();
                    }
                    }
                    this.state = 2255;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 2256;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public notMatchedBySourceAction(): NotMatchedBySourceActionContext {
        let localContext = new NotMatchedBySourceActionContext(this.context, this.state);
        this.enterRule(localContext, 132, SparkSqlParser.RULE_notMatchedBySourceAction);
        try {
            this.state = 2264;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_DELETE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2260;
                this.match(SparkSqlParser.KW_DELETE);
                }
                break;
            case SparkSqlParser.KW_UPDATE:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2261;
                this.match(SparkSqlParser.KW_UPDATE);
                this.state = 2262;
                this.match(SparkSqlParser.KW_SET);
                this.state = 2263;
                this.assignmentList();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public assignmentList(): AssignmentListContext {
        let localContext = new AssignmentListContext(this.context, this.state);
        this.enterRule(localContext, 134, SparkSqlParser.RULE_assignmentList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2266;
            this.assignment();
            this.state = 2271;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2267;
                this.match(SparkSqlParser.COMMA);
                this.state = 2268;
                this.assignment();
                }
                }
                this.state = 2273;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public assignment(): AssignmentContext {
        let localContext = new AssignmentContext(this.context, this.state);
        this.enterRule(localContext, 136, SparkSqlParser.RULE_assignment);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2274;
            localContext._key = this.multipartIdentifier();
            this.state = 2275;
            this.match(SparkSqlParser.EQ);
            this.state = 2276;
            localContext._value = this.expression();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public whereClause(): WhereClauseContext {
        let localContext = new WhereClauseContext(this.context, this.state);
        this.enterRule(localContext, 138, SparkSqlParser.RULE_whereClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2278;
            this.match(SparkSqlParser.KW_WHERE);
            this.state = 2279;
            this.booleanExpression(0);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public havingClause(): HavingClauseContext {
        let localContext = new HavingClauseContext(this.context, this.state);
        this.enterRule(localContext, 140, SparkSqlParser.RULE_havingClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2281;
            this.match(SparkSqlParser.KW_HAVING);
            this.state = 2282;
            this.booleanExpression(0);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public hint(): HintContext {
        let localContext = new HintContext(this.context, this.state);
        this.enterRule(localContext, 142, SparkSqlParser.RULE_hint);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2284;
            this.match(SparkSqlParser.HENT_START);
            this.state = 2285;
            localContext._hintStatement = this.hintStatement();
            localContext._hintStatements.push(localContext._hintStatement);
            this.state = 2292;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967056) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 3073) !== 0)) {
                {
                {
                this.state = 2287;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 4) {
                    {
                    this.state = 2286;
                    this.match(SparkSqlParser.COMMA);
                    }
                }

                this.state = 2289;
                localContext._hintStatement = this.hintStatement();
                localContext._hintStatements.push(localContext._hintStatement);
                }
                }
                this.state = 2294;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2295;
            this.match(SparkSqlParser.HENT_END);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public hintStatement(): HintStatementContext {
        let localContext = new HintStatementContext(this.context, this.state);
        this.enterRule(localContext, 144, SparkSqlParser.RULE_hintStatement);
        let _la: number;
        try {
            this.state = 2310;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 281, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2297;
                localContext._hintName = this.identifier();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2298;
                localContext._hintName = this.identifier();
                this.state = 2299;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2300;
                localContext._primaryExpression = this.primaryExpression(0);
                localContext._parameters.push(localContext._primaryExpression);
                this.state = 2305;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2301;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2302;
                    localContext._primaryExpression = this.primaryExpression(0);
                    localContext._parameters.push(localContext._primaryExpression);
                    }
                    }
                    this.state = 2307;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 2308;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public fromClause(): FromClauseContext {
        let localContext = new FromClauseContext(this.context, this.state);
        this.enterRule(localContext, 146, SparkSqlParser.RULE_fromClause);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2312;
            this.match(SparkSqlParser.KW_FROM);
            this.state = 2313;
            this.relation();
            this.state = 2318;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 282, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 2314;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2315;
                    this.relation();
                    }
                    }
                }
                this.state = 2320;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 282, this.context);
            }
            this.state = 2324;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 283, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 2321;
                    this.lateralView();
                    }
                    }
                }
                this.state = 2326;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 283, this.context);
            }
            this.state = 2328;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 284, this.context) ) {
            case 1:
                {
                this.state = 2327;
                this.pivotClause();
                }
                break;
            }
            this.state = 2331;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 285, this.context) ) {
            case 1:
                {
                this.state = 2330;
                this.unpivotClause();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionKind(): FunctionKindContext {
        let localContext = new FunctionKindContext(this.context, this.state);
        this.enterRule(localContext, 148, SparkSqlParser.RULE_functionKind);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2333;
            _la = this.tokenStream.LA(1);
            if(!(_la === 10 || _la === 290 || _la === 331)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public temporalClause(): TemporalClauseContext {
        let localContext = new TemporalClauseContext(this.context, this.state);
        this.enterRule(localContext, 150, SparkSqlParser.RULE_temporalClause);
        let _la: number;
        try {
            this.state = 2349;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 288, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2336;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 119) {
                    {
                    this.state = 2335;
                    this.match(SparkSqlParser.KW_FOR);
                    }
                }

                this.state = 2338;
                _la = this.tokenStream.LA(1);
                if(!(_la === 292 || _la === 337)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 2339;
                this.match(SparkSqlParser.KW_AS);
                this.state = 2340;
                this.match(SparkSqlParser.KW_OF);
                this.state = 2341;
                this.version();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2343;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 119) {
                    {
                    this.state = 2342;
                    this.match(SparkSqlParser.KW_FOR);
                    }
                }

                this.state = 2345;
                _la = this.tokenStream.LA(1);
                if(!(_la === 291 || _la === 303)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 2346;
                this.match(SparkSqlParser.KW_AS);
                this.state = 2347;
                this.match(SparkSqlParser.KW_OF);
                this.state = 2348;
                localContext._timestamp = this.valueExpression(0);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public aggregationClause(): AggregationClauseContext {
        let localContext = new AggregationClauseContext(this.context, this.state);
        this.enterRule(localContext, 152, SparkSqlParser.RULE_aggregationClause);
        let _la: number;
        try {
            let alternative: number;
            this.state = 2390;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 293, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2351;
                this.match(SparkSqlParser.KW_GROUP);
                this.state = 2352;
                this.match(SparkSqlParser.KW_BY);
                this.state = 2353;
                localContext._groupByClause = this.groupByClause();
                localContext._groupingExpressionsWithGroupingAnalytics.push(localContext._groupByClause);
                this.state = 2358;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 289, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2354;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2355;
                        localContext._groupByClause = this.groupByClause();
                        localContext._groupingExpressionsWithGroupingAnalytics.push(localContext._groupByClause);
                        }
                        }
                    }
                    this.state = 2360;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 289, this.context);
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2361;
                this.match(SparkSqlParser.KW_GROUP);
                this.state = 2362;
                this.match(SparkSqlParser.KW_BY);
                this.state = 2363;
                localContext._expression = this.expression();
                localContext._groupingExpressions.push(localContext._expression);
                this.state = 2368;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 290, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2364;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2365;
                        localContext._expression = this.expression();
                        localContext._groupingExpressions.push(localContext._expression);
                        }
                        }
                    }
                    this.state = 2370;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 290, this.context);
                }
                this.state = 2388;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 292, this.context) ) {
                case 1:
                    {
                    this.state = 2371;
                    this.match(SparkSqlParser.KW_WITH);
                    this.state = 2372;
                    localContext._kind = this.match(SparkSqlParser.KW_ROLLUP);
                    }
                    break;
                case 2:
                    {
                    this.state = 2373;
                    this.match(SparkSqlParser.KW_WITH);
                    this.state = 2374;
                    localContext._kind = this.match(SparkSqlParser.KW_CUBE);
                    }
                    break;
                case 3:
                    {
                    this.state = 2375;
                    localContext._kind = this.match(SparkSqlParser.KW_GROUPING);
                    this.state = 2376;
                    this.match(SparkSqlParser.KW_SETS);
                    this.state = 2377;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 2378;
                    this.groupingSet();
                    this.state = 2383;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 2379;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2380;
                        this.groupingSet();
                        }
                        }
                        this.state = 2385;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 2386;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public groupByClause(): GroupByClauseContext {
        let localContext = new GroupByClauseContext(this.context, this.state);
        this.enterRule(localContext, 154, SparkSqlParser.RULE_groupByClause);
        try {
            this.state = 2395;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 294, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2392;
                this.columnName();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2393;
                this.groupingAnalytics();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2394;
                this.expression();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public groupingAnalytics(): GroupingAnalyticsContext {
        let localContext = new GroupingAnalyticsContext(this.context, this.state);
        this.enterRule(localContext, 156, SparkSqlParser.RULE_groupingAnalytics);
        let _la: number;
        try {
            this.state = 2422;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_CUBE:
            case SparkSqlParser.KW_ROLLUP:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2397;
                _la = this.tokenStream.LA(1);
                if(!(_la === 61 || _la === 256)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 2398;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2399;
                this.groupingSet();
                this.state = 2404;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2400;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2401;
                    this.groupingSet();
                    }
                    }
                    this.state = 2406;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 2407;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case SparkSqlParser.KW_GROUPING:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2409;
                this.match(SparkSqlParser.KW_GROUPING);
                this.state = 2410;
                this.match(SparkSqlParser.KW_SETS);
                this.state = 2411;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2412;
                this.groupingElement();
                this.state = 2417;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2413;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2414;
                    this.groupingElement();
                    }
                    }
                    this.state = 2419;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 2420;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public groupingElement(): GroupingElementContext {
        let localContext = new GroupingElementContext(this.context, this.state);
        this.enterRule(localContext, 158, SparkSqlParser.RULE_groupingElement);
        try {
            this.state = 2426;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 298, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2424;
                this.groupingAnalytics();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2425;
                this.groupingSet();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public groupingSet(): GroupingSetContext {
        let localContext = new GroupingSetContext(this.context, this.state);
        this.enterRule(localContext, 160, SparkSqlParser.RULE_groupingSet);
        let _la: number;
        try {
            this.state = 2448;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 303, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2428;
                this.columnName();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2429;
                this.expression();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2430;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2445;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 302, this.context) ) {
                case 1:
                    {
                    this.state = 2433;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 299, this.context) ) {
                    case 1:
                        {
                        this.state = 2431;
                        this.columnName();
                        }
                        break;
                    case 2:
                        {
                        this.state = 2432;
                        this.expression();
                        }
                        break;
                    }
                    this.state = 2442;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 2435;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2438;
                        this.errorHandler.sync(this);
                        switch (this.interpreter.adaptivePredict(this.tokenStream, 300, this.context) ) {
                        case 1:
                            {
                            this.state = 2436;
                            this.columnName();
                            }
                            break;
                        case 2:
                            {
                            this.state = 2437;
                            this.expression();
                            }
                            break;
                        }
                        }
                        }
                        this.state = 2444;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                    break;
                }
                this.state = 2447;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pivotClause(): PivotClauseContext {
        let localContext = new PivotClauseContext(this.context, this.state);
        this.enterRule(localContext, 162, SparkSqlParser.RULE_pivotClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2450;
            this.match(SparkSqlParser.KW_PIVOT);
            this.state = 2451;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2452;
            localContext._aggregates = this.namedExpressionSeq();
            this.state = 2453;
            this.match(SparkSqlParser.KW_FOR);
            this.state = 2454;
            this.pivotColumn();
            this.state = 2455;
            this.match(SparkSqlParser.KW_IN);
            this.state = 2456;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2457;
            localContext._pivotValue = this.pivotValue();
            localContext._pivotValues.push(localContext._pivotValue);
            this.state = 2462;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2458;
                this.match(SparkSqlParser.COMMA);
                this.state = 2459;
                localContext._pivotValue = this.pivotValue();
                localContext._pivotValues.push(localContext._pivotValue);
                }
                }
                this.state = 2464;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2465;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2466;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pivotColumn(): PivotColumnContext {
        let localContext = new PivotColumnContext(this.context, this.state);
        this.enterRule(localContext, 164, SparkSqlParser.RULE_pivotColumn);
        let _la: number;
        try {
            this.state = 2480;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_ADD:
            case SparkSqlParser.KW_AFTER:
            case SparkSqlParser.KW_ALL:
            case SparkSqlParser.KW_ALTER:
            case SparkSqlParser.KW_ALWAYS:
            case SparkSqlParser.KW_ANALYZE:
            case SparkSqlParser.KW_AND:
            case SparkSqlParser.KW_ANTI:
            case SparkSqlParser.KW_ANY:
            case SparkSqlParser.KW_ANY_VALUE:
            case SparkSqlParser.KW_ARCHIVE:
            case SparkSqlParser.KW_ARRAY:
            case SparkSqlParser.KW_AS:
            case SparkSqlParser.KW_ASC:
            case SparkSqlParser.KW_AT:
            case SparkSqlParser.KW_AUTHORIZATION:
            case SparkSqlParser.KW_BETWEEN:
            case SparkSqlParser.KW_BIGINT:
            case SparkSqlParser.KW_BINARY:
            case SparkSqlParser.KW_BOOLEAN:
            case SparkSqlParser.KW_BOTH:
            case SparkSqlParser.KW_BUCKET:
            case SparkSqlParser.KW_BUCKETS:
            case SparkSqlParser.KW_BY:
            case SparkSqlParser.KW_BYTE:
            case SparkSqlParser.KW_CACHE:
            case SparkSqlParser.KW_CASCADE:
            case SparkSqlParser.KW_CASE:
            case SparkSqlParser.KW_CAST:
            case SparkSqlParser.KW_CATALOG:
            case SparkSqlParser.KW_CATALOGS:
            case SparkSqlParser.KW_CHANGE:
            case SparkSqlParser.KW_CHAR:
            case SparkSqlParser.KW_CHARACTER:
            case SparkSqlParser.KW_CHECK:
            case SparkSqlParser.KW_CLEAR:
            case SparkSqlParser.KW_CLUSTER:
            case SparkSqlParser.KW_CLUSTERED:
            case SparkSqlParser.KW_CODEGEN:
            case SparkSqlParser.KW_COLLATE:
            case SparkSqlParser.KW_COLLECTION:
            case SparkSqlParser.KW_COLUMN:
            case SparkSqlParser.KW_COLUMNS:
            case SparkSqlParser.KW_COMMENT:
            case SparkSqlParser.KW_COMMIT:
            case SparkSqlParser.KW_COMPACT:
            case SparkSqlParser.KW_COMPACTIONS:
            case SparkSqlParser.KW_COMPUTE:
            case SparkSqlParser.KW_CONCATENATE:
            case SparkSqlParser.KW_CONSTRAINT:
            case SparkSqlParser.KW_COST:
            case SparkSqlParser.KW_CREATE:
            case SparkSqlParser.KW_CROSS:
            case SparkSqlParser.KW_CUBE:
            case SparkSqlParser.KW_CURRENT:
            case SparkSqlParser.KW_CURRENT_DATE:
            case SparkSqlParser.KW_CURRENT_TIME:
            case SparkSqlParser.KW_CURRENT_TIMESTAMP:
            case SparkSqlParser.KW_CURRENT_USER:
            case SparkSqlParser.KW_DAY:
            case SparkSqlParser.KW_DAYS:
            case SparkSqlParser.KW_DAYOFYEAR:
            case SparkSqlParser.KW_DATA:
            case SparkSqlParser.KW_DATE:
            case SparkSqlParser.KW_DATABASE:
            case SparkSqlParser.KW_DATABASES:
            case SparkSqlParser.KW_DATEADD:
            case SparkSqlParser.KW_DATE_ADD:
            case SparkSqlParser.KW_DATEDIFF:
            case SparkSqlParser.KW_DATE_DIFF:
            case SparkSqlParser.KW_DBPROPERTIES:
            case SparkSqlParser.KW_DEC:
            case SparkSqlParser.KW_DECIMAL:
            case SparkSqlParser.KW_DECLARE:
            case SparkSqlParser.KW_DEFAULT:
            case SparkSqlParser.KW_DEFINED:
            case SparkSqlParser.KW_DELETE:
            case SparkSqlParser.KW_DELIMITED:
            case SparkSqlParser.KW_DESC:
            case SparkSqlParser.KW_DESCRIBE:
            case SparkSqlParser.KW_DFS:
            case SparkSqlParser.KW_DIRECTORIES:
            case SparkSqlParser.KW_DIRECTORY:
            case SparkSqlParser.KW_DISABLE:
            case SparkSqlParser.KW_DISTINCT:
            case SparkSqlParser.KW_DISTRIBUTE:
            case SparkSqlParser.KW_DIV:
            case SparkSqlParser.KW_DOUBLE:
            case SparkSqlParser.KW_DROP:
            case SparkSqlParser.KW_ELSE:
            case SparkSqlParser.KW_ENABLE:
            case SparkSqlParser.KW_END:
            case SparkSqlParser.KW_ESCAPE:
            case SparkSqlParser.KW_ESCAPED:
            case SparkSqlParser.KW_EXCEPT:
            case SparkSqlParser.KW_EXCHANGE:
            case SparkSqlParser.KW_EXCLUDE:
            case SparkSqlParser.KW_EXISTS:
            case SparkSqlParser.KW_EXPLAIN:
            case SparkSqlParser.KW_EXPORT:
            case SparkSqlParser.KW_EXTENDED:
            case SparkSqlParser.KW_EXTERNAL:
            case SparkSqlParser.KW_EXTRACT:
            case SparkSqlParser.KW_FALSE:
            case SparkSqlParser.KW_FETCH:
            case SparkSqlParser.KW_FIELDS:
            case SparkSqlParser.KW_FILTER:
            case SparkSqlParser.KW_FILEFORMAT:
            case SparkSqlParser.KW_FIRST:
            case SparkSqlParser.KW_FLOAT:
            case SparkSqlParser.KW_FOLLOWING:
            case SparkSqlParser.KW_FOR:
            case SparkSqlParser.KW_FOREIGN:
            case SparkSqlParser.KW_FORMAT:
            case SparkSqlParser.KW_FORMATTED:
            case SparkSqlParser.KW_FULL:
            case SparkSqlParser.KW_FUNCTION:
            case SparkSqlParser.KW_FUNCTIONS:
            case SparkSqlParser.KW_GENERATED:
            case SparkSqlParser.KW_GLOBAL:
            case SparkSqlParser.KW_GRANT:
            case SparkSqlParser.KW_GROUP:
            case SparkSqlParser.KW_GROUPING:
            case SparkSqlParser.KW_HAVING:
            case SparkSqlParser.KW_BINARY_HEX:
            case SparkSqlParser.KW_HOUR:
            case SparkSqlParser.KW_HOURS:
            case SparkSqlParser.KW_IDENTIFIER:
            case SparkSqlParser.KW_IF:
            case SparkSqlParser.KW_IGNORE:
            case SparkSqlParser.KW_IMPORT:
            case SparkSqlParser.KW_IN:
            case SparkSqlParser.KW_INCLUDE:
            case SparkSqlParser.KW_INDEX:
            case SparkSqlParser.KW_INDEXES:
            case SparkSqlParser.KW_INNER:
            case SparkSqlParser.KW_INPATH:
            case SparkSqlParser.KW_INPUTFORMAT:
            case SparkSqlParser.KW_INSERT:
            case SparkSqlParser.KW_INTERSECT:
            case SparkSqlParser.KW_INTERVAL:
            case SparkSqlParser.KW_INT:
            case SparkSqlParser.KW_INTEGER:
            case SparkSqlParser.KW_INTO:
            case SparkSqlParser.KW_IS:
            case SparkSqlParser.KW_ITEMS:
            case SparkSqlParser.KW_JOIN:
            case SparkSqlParser.KW_KEYS:
            case SparkSqlParser.KW_LAST:
            case SparkSqlParser.KW_LATERAL:
            case SparkSqlParser.KW_LAZY:
            case SparkSqlParser.KW_LEADING:
            case SparkSqlParser.KW_LEFT:
            case SparkSqlParser.KW_LIFECYCLE:
            case SparkSqlParser.KW_LIKE:
            case SparkSqlParser.KW_ILIKE:
            case SparkSqlParser.KW_LIMIT:
            case SparkSqlParser.KW_LINES:
            case SparkSqlParser.KW_LIST:
            case SparkSqlParser.KW_LOAD:
            case SparkSqlParser.KW_LOCAL:
            case SparkSqlParser.KW_LOCATION:
            case SparkSqlParser.KW_LOCK:
            case SparkSqlParser.KW_LOCKS:
            case SparkSqlParser.KW_LOGICAL:
            case SparkSqlParser.KW_LONG:
            case SparkSqlParser.KW_MACRO:
            case SparkSqlParser.KW_MATERIALIZED:
            case SparkSqlParser.KW_MAP:
            case SparkSqlParser.KW_MATCHED:
            case SparkSqlParser.KW_MERGE:
            case SparkSqlParser.KW_MICROSECOND:
            case SparkSqlParser.KW_MICROSECONDS:
            case SparkSqlParser.KW_MILLISECOND:
            case SparkSqlParser.KW_MILLISECONDS:
            case SparkSqlParser.KW_MINUTE:
            case SparkSqlParser.KW_MINUTES:
            case SparkSqlParser.KW_MONTH:
            case SparkSqlParser.KW_MONTHS:
            case SparkSqlParser.KW_MSCK:
            case SparkSqlParser.KW_NAME:
            case SparkSqlParser.KW_NAMESPACE:
            case SparkSqlParser.KW_NAMESPACES:
            case SparkSqlParser.KW_NANOSECOND:
            case SparkSqlParser.KW_NANOSECONDS:
            case SparkSqlParser.KW_NATURAL:
            case SparkSqlParser.KW_NO:
            case SparkSqlParser.KW_NOT:
            case SparkSqlParser.KW_NULL:
            case SparkSqlParser.KW_NULLS:
            case SparkSqlParser.KW_NUMERIC:
            case SparkSqlParser.KW_OF:
            case SparkSqlParser.KW_OFFSET:
            case SparkSqlParser.KW_ON:
            case SparkSqlParser.KW_ONLY:
            case SparkSqlParser.KW_OPTIMIZE:
            case SparkSqlParser.KW_OPTION:
            case SparkSqlParser.KW_OPTIONS:
            case SparkSqlParser.KW_OR:
            case SparkSqlParser.KW_ORDER:
            case SparkSqlParser.KW_OUT:
            case SparkSqlParser.KW_OUTER:
            case SparkSqlParser.KW_OUTPUTFORMAT:
            case SparkSqlParser.KW_OVER:
            case SparkSqlParser.KW_OVERLAPS:
            case SparkSqlParser.KW_OVERLAY:
            case SparkSqlParser.KW_OVERWRITE:
            case SparkSqlParser.KW_PARTITION:
            case SparkSqlParser.KW_PARTITIONED:
            case SparkSqlParser.KW_PARTITIONS:
            case SparkSqlParser.KW_PERCENTILE_CONT:
            case SparkSqlParser.KW_PERCENTILE_DISC:
            case SparkSqlParser.KW_PERCENTLIT:
            case SparkSqlParser.KW_PIVOT:
            case SparkSqlParser.KW_PLACING:
            case SparkSqlParser.KW_POSITION:
            case SparkSqlParser.KW_PRECEDING:
            case SparkSqlParser.KW_PRIMARY:
            case SparkSqlParser.KW_PRINCIPALS:
            case SparkSqlParser.KW_PROPERTIES:
            case SparkSqlParser.KW_PURGE:
            case SparkSqlParser.KW_QUARTER:
            case SparkSqlParser.KW_QUERY:
            case SparkSqlParser.KW_RANGE:
            case SparkSqlParser.KW_REAL:
            case SparkSqlParser.KW_RECORDREADER:
            case SparkSqlParser.KW_RECORDWRITER:
            case SparkSqlParser.KW_RECOVER:
            case SparkSqlParser.KW_REDUCE:
            case SparkSqlParser.KW_REFERENCES:
            case SparkSqlParser.KW_REFRESH:
            case SparkSqlParser.KW_RENAME:
            case SparkSqlParser.KW_REPAIR:
            case SparkSqlParser.KW_REPEATABLE:
            case SparkSqlParser.KW_REPLACE:
            case SparkSqlParser.KW_RESET:
            case SparkSqlParser.KW_RESPECT:
            case SparkSqlParser.KW_RESTRICT:
            case SparkSqlParser.KW_REWRITE:
            case SparkSqlParser.KW_REVOKE:
            case SparkSqlParser.KW_RIGHT:
            case SparkSqlParser.KW_RLIKE:
            case SparkSqlParser.KW_REGEXP:
            case SparkSqlParser.KW_ROLE:
            case SparkSqlParser.KW_ROLES:
            case SparkSqlParser.KW_ROLLBACK:
            case SparkSqlParser.KW_ROLLUP:
            case SparkSqlParser.KW_ROW:
            case SparkSqlParser.KW_ROWS:
            case SparkSqlParser.KW_SECOND:
            case SparkSqlParser.KW_SECONDS:
            case SparkSqlParser.KW_SCHEMA:
            case SparkSqlParser.KW_SCHEMAS:
            case SparkSqlParser.KW_SEMI:
            case SparkSqlParser.KW_SEPARATED:
            case SparkSqlParser.KW_SERDE:
            case SparkSqlParser.KW_SERDEPROPERTIES:
            case SparkSqlParser.KW_SESSION_USER:
            case SparkSqlParser.KW_SET:
            case SparkSqlParser.KW_MINUS:
            case SparkSqlParser.KW_SETS:
            case SparkSqlParser.KW_SHORT:
            case SparkSqlParser.KW_SHOW:
            case SparkSqlParser.KW_SINGLE:
            case SparkSqlParser.KW_SKEWED:
            case SparkSqlParser.KW_SMALLINT:
            case SparkSqlParser.KW_SOME:
            case SparkSqlParser.KW_SORT:
            case SparkSqlParser.KW_SORTED:
            case SparkSqlParser.KW_SOURCE:
            case SparkSqlParser.KW_START:
            case SparkSqlParser.KW_STATISTICS:
            case SparkSqlParser.KW_STORED:
            case SparkSqlParser.KW_STRATIFY:
            case SparkSqlParser.KW_STRING:
            case SparkSqlParser.KW_STRUCT:
            case SparkSqlParser.KW_SUBSTR:
            case SparkSqlParser.KW_SUBSTRING:
            case SparkSqlParser.KW_SYNC:
            case SparkSqlParser.KW_SYSTEM:
            case SparkSqlParser.KW_SYSTEM_TIME:
            case SparkSqlParser.KW_SYSTEM_VERSION:
            case SparkSqlParser.KW_TABLES:
            case SparkSqlParser.KW_TABLESAMPLE:
            case SparkSqlParser.KW_TARGET:
            case SparkSqlParser.KW_TBLPROPERTIES:
            case SparkSqlParser.KW_TEMPORARY:
            case SparkSqlParser.KW_TERMINATED:
            case SparkSqlParser.KW_THEN:
            case SparkSqlParser.KW_TIME:
            case SparkSqlParser.KW_TIMEDIFF:
            case SparkSqlParser.KW_TIMESTAMP:
            case SparkSqlParser.KW_TIMESTAMP_LTZ:
            case SparkSqlParser.KW_TIMESTAMP_NTZ:
            case SparkSqlParser.KW_TIMESTAMPADD:
            case SparkSqlParser.KW_TIMESTAMPDIFF:
            case SparkSqlParser.KW_TINYINT:
            case SparkSqlParser.KW_TO:
            case SparkSqlParser.KW_TOUCH:
            case SparkSqlParser.KW_TRAILING:
            case SparkSqlParser.KW_TRANSACTION:
            case SparkSqlParser.KW_TRANSACTIONS:
            case SparkSqlParser.KW_TRANSFORM:
            case SparkSqlParser.KW_TRIM:
            case SparkSqlParser.KW_TRUE:
            case SparkSqlParser.KW_TRUNCATE:
            case SparkSqlParser.KW_TRY_CAST:
            case SparkSqlParser.KW_TYPE:
            case SparkSqlParser.KW_UNARCHIVE:
            case SparkSqlParser.KW_UNBOUNDED:
            case SparkSqlParser.KW_UNCACHE:
            case SparkSqlParser.KW_UNION:
            case SparkSqlParser.KW_UNIQUE:
            case SparkSqlParser.KW_UNKNOWN:
            case SparkSqlParser.KW_UNLOCK:
            case SparkSqlParser.KW_UNPIVOT:
            case SparkSqlParser.KW_UNSET:
            case SparkSqlParser.KW_UPDATE:
            case SparkSqlParser.KW_USE:
            case SparkSqlParser.KW_USER:
            case SparkSqlParser.KW_USING:
            case SparkSqlParser.KW_VALUES:
            case SparkSqlParser.KW_VARCHAR:
            case SparkSqlParser.KW_VAR:
            case SparkSqlParser.KW_VARIABLE:
            case SparkSqlParser.KW_VERSION:
            case SparkSqlParser.KW_VIEW:
            case SparkSqlParser.KW_VIEWS:
            case SparkSqlParser.KW_VOID:
            case SparkSqlParser.KW_WEEK:
            case SparkSqlParser.KW_WEEKS:
            case SparkSqlParser.KW_WHEN:
            case SparkSqlParser.KW_WHERE:
            case SparkSqlParser.KW_WINDOW:
            case SparkSqlParser.KW_WITH:
            case SparkSqlParser.KW_WITHIN:
            case SparkSqlParser.KW_YEAR:
            case SparkSqlParser.KW_YEARS:
            case SparkSqlParser.KW_ZONE:
            case SparkSqlParser.KW_ZORDER:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
            case SparkSqlParser.IDENTIFIER:
            case SparkSqlParser.BACKQUOTED_IDENTIFIER:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2468;
                localContext._identifier = this.identifier();
                localContext._identifiers.push(localContext._identifier);
                }
                break;
            case SparkSqlParser.LEFT_PAREN:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2469;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2470;
                localContext._identifier = this.identifier();
                localContext._identifiers.push(localContext._identifier);
                this.state = 2475;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2471;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2472;
                    localContext._identifier = this.identifier();
                    localContext._identifiers.push(localContext._identifier);
                    }
                    }
                    this.state = 2477;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 2478;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public pivotValue(): PivotValueContext {
        let localContext = new PivotValueContext(this.context, this.state);
        this.enterRule(localContext, 166, SparkSqlParser.RULE_pivotValue);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2482;
            this.expression();
            this.state = 2487;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 3073) !== 0)) {
                {
                this.state = 2484;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 307, this.context) ) {
                case 1:
                    {
                    this.state = 2483;
                    this.match(SparkSqlParser.KW_AS);
                    }
                    break;
                }
                this.state = 2486;
                this.identifier();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotClause(): UnpivotClauseContext {
        let localContext = new UnpivotClauseContext(this.context, this.state);
        this.enterRule(localContext, 168, SparkSqlParser.RULE_unpivotClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2489;
            this.match(SparkSqlParser.KW_UNPIVOT);
            this.state = 2491;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 104 || _la === 141) {
                {
                this.state = 2490;
                localContext._nullOperator = this.unpivotNullClause();
                }
            }

            this.state = 2493;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2494;
            localContext._operator = this.unpivotOperator();
            this.state = 2495;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2500;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 311, this.context) ) {
            case 1:
                {
                this.state = 2497;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 310, this.context) ) {
                case 1:
                    {
                    this.state = 2496;
                    this.match(SparkSqlParser.KW_AS);
                    }
                    break;
                }
                this.state = 2499;
                this.identifier();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotNullClause(): UnpivotNullClauseContext {
        let localContext = new UnpivotNullClauseContext(this.context, this.state);
        this.enterRule(localContext, 170, SparkSqlParser.RULE_unpivotNullClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2502;
            _la = this.tokenStream.LA(1);
            if(!(_la === 104 || _la === 141)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            this.state = 2503;
            this.match(SparkSqlParser.KW_NULLS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotOperator(): UnpivotOperatorContext {
        let localContext = new UnpivotOperatorContext(this.context, this.state);
        this.enterRule(localContext, 172, SparkSqlParser.RULE_unpivotOperator);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2507;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_ADD:
            case SparkSqlParser.KW_AFTER:
            case SparkSqlParser.KW_ALL:
            case SparkSqlParser.KW_ALTER:
            case SparkSqlParser.KW_ALWAYS:
            case SparkSqlParser.KW_ANALYZE:
            case SparkSqlParser.KW_AND:
            case SparkSqlParser.KW_ANTI:
            case SparkSqlParser.KW_ANY:
            case SparkSqlParser.KW_ANY_VALUE:
            case SparkSqlParser.KW_ARCHIVE:
            case SparkSqlParser.KW_ARRAY:
            case SparkSqlParser.KW_AS:
            case SparkSqlParser.KW_ASC:
            case SparkSqlParser.KW_AT:
            case SparkSqlParser.KW_AUTHORIZATION:
            case SparkSqlParser.KW_BETWEEN:
            case SparkSqlParser.KW_BIGINT:
            case SparkSqlParser.KW_BINARY:
            case SparkSqlParser.KW_BOOLEAN:
            case SparkSqlParser.KW_BOTH:
            case SparkSqlParser.KW_BUCKET:
            case SparkSqlParser.KW_BUCKETS:
            case SparkSqlParser.KW_BY:
            case SparkSqlParser.KW_BYTE:
            case SparkSqlParser.KW_CACHE:
            case SparkSqlParser.KW_CASCADE:
            case SparkSqlParser.KW_CASE:
            case SparkSqlParser.KW_CAST:
            case SparkSqlParser.KW_CATALOG:
            case SparkSqlParser.KW_CATALOGS:
            case SparkSqlParser.KW_CHANGE:
            case SparkSqlParser.KW_CHAR:
            case SparkSqlParser.KW_CHARACTER:
            case SparkSqlParser.KW_CHECK:
            case SparkSqlParser.KW_CLEAR:
            case SparkSqlParser.KW_CLUSTER:
            case SparkSqlParser.KW_CLUSTERED:
            case SparkSqlParser.KW_CODEGEN:
            case SparkSqlParser.KW_COLLATE:
            case SparkSqlParser.KW_COLLECTION:
            case SparkSqlParser.KW_COLUMN:
            case SparkSqlParser.KW_COLUMNS:
            case SparkSqlParser.KW_COMMENT:
            case SparkSqlParser.KW_COMMIT:
            case SparkSqlParser.KW_COMPACT:
            case SparkSqlParser.KW_COMPACTIONS:
            case SparkSqlParser.KW_COMPUTE:
            case SparkSqlParser.KW_CONCATENATE:
            case SparkSqlParser.KW_CONSTRAINT:
            case SparkSqlParser.KW_COST:
            case SparkSqlParser.KW_CREATE:
            case SparkSqlParser.KW_CROSS:
            case SparkSqlParser.KW_CUBE:
            case SparkSqlParser.KW_CURRENT:
            case SparkSqlParser.KW_CURRENT_DATE:
            case SparkSqlParser.KW_CURRENT_TIME:
            case SparkSqlParser.KW_CURRENT_TIMESTAMP:
            case SparkSqlParser.KW_CURRENT_USER:
            case SparkSqlParser.KW_DAY:
            case SparkSqlParser.KW_DAYS:
            case SparkSqlParser.KW_DAYOFYEAR:
            case SparkSqlParser.KW_DATA:
            case SparkSqlParser.KW_DATE:
            case SparkSqlParser.KW_DATABASE:
            case SparkSqlParser.KW_DATABASES:
            case SparkSqlParser.KW_DATEADD:
            case SparkSqlParser.KW_DATE_ADD:
            case SparkSqlParser.KW_DATEDIFF:
            case SparkSqlParser.KW_DATE_DIFF:
            case SparkSqlParser.KW_DBPROPERTIES:
            case SparkSqlParser.KW_DEC:
            case SparkSqlParser.KW_DECIMAL:
            case SparkSqlParser.KW_DECLARE:
            case SparkSqlParser.KW_DEFAULT:
            case SparkSqlParser.KW_DEFINED:
            case SparkSqlParser.KW_DELETE:
            case SparkSqlParser.KW_DELIMITED:
            case SparkSqlParser.KW_DESC:
            case SparkSqlParser.KW_DESCRIBE:
            case SparkSqlParser.KW_DFS:
            case SparkSqlParser.KW_DIRECTORIES:
            case SparkSqlParser.KW_DIRECTORY:
            case SparkSqlParser.KW_DISABLE:
            case SparkSqlParser.KW_DISTINCT:
            case SparkSqlParser.KW_DISTRIBUTE:
            case SparkSqlParser.KW_DIV:
            case SparkSqlParser.KW_DOUBLE:
            case SparkSqlParser.KW_DROP:
            case SparkSqlParser.KW_ELSE:
            case SparkSqlParser.KW_ENABLE:
            case SparkSqlParser.KW_END:
            case SparkSqlParser.KW_ESCAPE:
            case SparkSqlParser.KW_ESCAPED:
            case SparkSqlParser.KW_EXCEPT:
            case SparkSqlParser.KW_EXCHANGE:
            case SparkSqlParser.KW_EXCLUDE:
            case SparkSqlParser.KW_EXISTS:
            case SparkSqlParser.KW_EXPLAIN:
            case SparkSqlParser.KW_EXPORT:
            case SparkSqlParser.KW_EXTENDED:
            case SparkSqlParser.KW_EXTERNAL:
            case SparkSqlParser.KW_EXTRACT:
            case SparkSqlParser.KW_FALSE:
            case SparkSqlParser.KW_FETCH:
            case SparkSqlParser.KW_FIELDS:
            case SparkSqlParser.KW_FILTER:
            case SparkSqlParser.KW_FILEFORMAT:
            case SparkSqlParser.KW_FIRST:
            case SparkSqlParser.KW_FLOAT:
            case SparkSqlParser.KW_FOLLOWING:
            case SparkSqlParser.KW_FOR:
            case SparkSqlParser.KW_FOREIGN:
            case SparkSqlParser.KW_FORMAT:
            case SparkSqlParser.KW_FORMATTED:
            case SparkSqlParser.KW_FULL:
            case SparkSqlParser.KW_FUNCTION:
            case SparkSqlParser.KW_FUNCTIONS:
            case SparkSqlParser.KW_GENERATED:
            case SparkSqlParser.KW_GLOBAL:
            case SparkSqlParser.KW_GRANT:
            case SparkSqlParser.KW_GROUP:
            case SparkSqlParser.KW_GROUPING:
            case SparkSqlParser.KW_HAVING:
            case SparkSqlParser.KW_BINARY_HEX:
            case SparkSqlParser.KW_HOUR:
            case SparkSqlParser.KW_HOURS:
            case SparkSqlParser.KW_IDENTIFIER:
            case SparkSqlParser.KW_IF:
            case SparkSqlParser.KW_IGNORE:
            case SparkSqlParser.KW_IMPORT:
            case SparkSqlParser.KW_IN:
            case SparkSqlParser.KW_INCLUDE:
            case SparkSqlParser.KW_INDEX:
            case SparkSqlParser.KW_INDEXES:
            case SparkSqlParser.KW_INNER:
            case SparkSqlParser.KW_INPATH:
            case SparkSqlParser.KW_INPUTFORMAT:
            case SparkSqlParser.KW_INSERT:
            case SparkSqlParser.KW_INTERSECT:
            case SparkSqlParser.KW_INTERVAL:
            case SparkSqlParser.KW_INT:
            case SparkSqlParser.KW_INTEGER:
            case SparkSqlParser.KW_INTO:
            case SparkSqlParser.KW_IS:
            case SparkSqlParser.KW_ITEMS:
            case SparkSqlParser.KW_JOIN:
            case SparkSqlParser.KW_KEYS:
            case SparkSqlParser.KW_LAST:
            case SparkSqlParser.KW_LATERAL:
            case SparkSqlParser.KW_LAZY:
            case SparkSqlParser.KW_LEADING:
            case SparkSqlParser.KW_LEFT:
            case SparkSqlParser.KW_LIFECYCLE:
            case SparkSqlParser.KW_LIKE:
            case SparkSqlParser.KW_ILIKE:
            case SparkSqlParser.KW_LIMIT:
            case SparkSqlParser.KW_LINES:
            case SparkSqlParser.KW_LIST:
            case SparkSqlParser.KW_LOAD:
            case SparkSqlParser.KW_LOCAL:
            case SparkSqlParser.KW_LOCATION:
            case SparkSqlParser.KW_LOCK:
            case SparkSqlParser.KW_LOCKS:
            case SparkSqlParser.KW_LOGICAL:
            case SparkSqlParser.KW_LONG:
            case SparkSqlParser.KW_MACRO:
            case SparkSqlParser.KW_MATERIALIZED:
            case SparkSqlParser.KW_MAP:
            case SparkSqlParser.KW_MATCHED:
            case SparkSqlParser.KW_MERGE:
            case SparkSqlParser.KW_MICROSECOND:
            case SparkSqlParser.KW_MICROSECONDS:
            case SparkSqlParser.KW_MILLISECOND:
            case SparkSqlParser.KW_MILLISECONDS:
            case SparkSqlParser.KW_MINUTE:
            case SparkSqlParser.KW_MINUTES:
            case SparkSqlParser.KW_MONTH:
            case SparkSqlParser.KW_MONTHS:
            case SparkSqlParser.KW_MSCK:
            case SparkSqlParser.KW_NAME:
            case SparkSqlParser.KW_NAMESPACE:
            case SparkSqlParser.KW_NAMESPACES:
            case SparkSqlParser.KW_NANOSECOND:
            case SparkSqlParser.KW_NANOSECONDS:
            case SparkSqlParser.KW_NATURAL:
            case SparkSqlParser.KW_NO:
            case SparkSqlParser.KW_NOT:
            case SparkSqlParser.KW_NULL:
            case SparkSqlParser.KW_NULLS:
            case SparkSqlParser.KW_NUMERIC:
            case SparkSqlParser.KW_OF:
            case SparkSqlParser.KW_OFFSET:
            case SparkSqlParser.KW_ON:
            case SparkSqlParser.KW_ONLY:
            case SparkSqlParser.KW_OPTIMIZE:
            case SparkSqlParser.KW_OPTION:
            case SparkSqlParser.KW_OPTIONS:
            case SparkSqlParser.KW_OR:
            case SparkSqlParser.KW_ORDER:
            case SparkSqlParser.KW_OUT:
            case SparkSqlParser.KW_OUTER:
            case SparkSqlParser.KW_OUTPUTFORMAT:
            case SparkSqlParser.KW_OVER:
            case SparkSqlParser.KW_OVERLAPS:
            case SparkSqlParser.KW_OVERLAY:
            case SparkSqlParser.KW_OVERWRITE:
            case SparkSqlParser.KW_PARTITION:
            case SparkSqlParser.KW_PARTITIONED:
            case SparkSqlParser.KW_PARTITIONS:
            case SparkSqlParser.KW_PERCENTILE_CONT:
            case SparkSqlParser.KW_PERCENTILE_DISC:
            case SparkSqlParser.KW_PERCENTLIT:
            case SparkSqlParser.KW_PIVOT:
            case SparkSqlParser.KW_PLACING:
            case SparkSqlParser.KW_POSITION:
            case SparkSqlParser.KW_PRECEDING:
            case SparkSqlParser.KW_PRIMARY:
            case SparkSqlParser.KW_PRINCIPALS:
            case SparkSqlParser.KW_PROPERTIES:
            case SparkSqlParser.KW_PURGE:
            case SparkSqlParser.KW_QUARTER:
            case SparkSqlParser.KW_QUERY:
            case SparkSqlParser.KW_RANGE:
            case SparkSqlParser.KW_REAL:
            case SparkSqlParser.KW_RECORDREADER:
            case SparkSqlParser.KW_RECORDWRITER:
            case SparkSqlParser.KW_RECOVER:
            case SparkSqlParser.KW_REDUCE:
            case SparkSqlParser.KW_REFERENCES:
            case SparkSqlParser.KW_REFRESH:
            case SparkSqlParser.KW_RENAME:
            case SparkSqlParser.KW_REPAIR:
            case SparkSqlParser.KW_REPEATABLE:
            case SparkSqlParser.KW_REPLACE:
            case SparkSqlParser.KW_RESET:
            case SparkSqlParser.KW_RESPECT:
            case SparkSqlParser.KW_RESTRICT:
            case SparkSqlParser.KW_REWRITE:
            case SparkSqlParser.KW_REVOKE:
            case SparkSqlParser.KW_RIGHT:
            case SparkSqlParser.KW_RLIKE:
            case SparkSqlParser.KW_REGEXP:
            case SparkSqlParser.KW_ROLE:
            case SparkSqlParser.KW_ROLES:
            case SparkSqlParser.KW_ROLLBACK:
            case SparkSqlParser.KW_ROLLUP:
            case SparkSqlParser.KW_ROW:
            case SparkSqlParser.KW_ROWS:
            case SparkSqlParser.KW_SECOND:
            case SparkSqlParser.KW_SECONDS:
            case SparkSqlParser.KW_SCHEMA:
            case SparkSqlParser.KW_SCHEMAS:
            case SparkSqlParser.KW_SEMI:
            case SparkSqlParser.KW_SEPARATED:
            case SparkSqlParser.KW_SERDE:
            case SparkSqlParser.KW_SERDEPROPERTIES:
            case SparkSqlParser.KW_SESSION_USER:
            case SparkSqlParser.KW_SET:
            case SparkSqlParser.KW_MINUS:
            case SparkSqlParser.KW_SETS:
            case SparkSqlParser.KW_SHORT:
            case SparkSqlParser.KW_SHOW:
            case SparkSqlParser.KW_SINGLE:
            case SparkSqlParser.KW_SKEWED:
            case SparkSqlParser.KW_SMALLINT:
            case SparkSqlParser.KW_SOME:
            case SparkSqlParser.KW_SORT:
            case SparkSqlParser.KW_SORTED:
            case SparkSqlParser.KW_SOURCE:
            case SparkSqlParser.KW_START:
            case SparkSqlParser.KW_STATISTICS:
            case SparkSqlParser.KW_STORED:
            case SparkSqlParser.KW_STRATIFY:
            case SparkSqlParser.KW_STRING:
            case SparkSqlParser.KW_STRUCT:
            case SparkSqlParser.KW_SUBSTR:
            case SparkSqlParser.KW_SUBSTRING:
            case SparkSqlParser.KW_SYNC:
            case SparkSqlParser.KW_SYSTEM:
            case SparkSqlParser.KW_SYSTEM_TIME:
            case SparkSqlParser.KW_SYSTEM_VERSION:
            case SparkSqlParser.KW_TABLES:
            case SparkSqlParser.KW_TABLESAMPLE:
            case SparkSqlParser.KW_TARGET:
            case SparkSqlParser.KW_TBLPROPERTIES:
            case SparkSqlParser.KW_TEMPORARY:
            case SparkSqlParser.KW_TERMINATED:
            case SparkSqlParser.KW_THEN:
            case SparkSqlParser.KW_TIME:
            case SparkSqlParser.KW_TIMEDIFF:
            case SparkSqlParser.KW_TIMESTAMP:
            case SparkSqlParser.KW_TIMESTAMP_LTZ:
            case SparkSqlParser.KW_TIMESTAMP_NTZ:
            case SparkSqlParser.KW_TIMESTAMPADD:
            case SparkSqlParser.KW_TIMESTAMPDIFF:
            case SparkSqlParser.KW_TINYINT:
            case SparkSqlParser.KW_TO:
            case SparkSqlParser.KW_TOUCH:
            case SparkSqlParser.KW_TRAILING:
            case SparkSqlParser.KW_TRANSACTION:
            case SparkSqlParser.KW_TRANSACTIONS:
            case SparkSqlParser.KW_TRANSFORM:
            case SparkSqlParser.KW_TRIM:
            case SparkSqlParser.KW_TRUE:
            case SparkSqlParser.KW_TRUNCATE:
            case SparkSqlParser.KW_TRY_CAST:
            case SparkSqlParser.KW_TYPE:
            case SparkSqlParser.KW_UNARCHIVE:
            case SparkSqlParser.KW_UNBOUNDED:
            case SparkSqlParser.KW_UNCACHE:
            case SparkSqlParser.KW_UNION:
            case SparkSqlParser.KW_UNIQUE:
            case SparkSqlParser.KW_UNKNOWN:
            case SparkSqlParser.KW_UNLOCK:
            case SparkSqlParser.KW_UNPIVOT:
            case SparkSqlParser.KW_UNSET:
            case SparkSqlParser.KW_UPDATE:
            case SparkSqlParser.KW_USE:
            case SparkSqlParser.KW_USER:
            case SparkSqlParser.KW_USING:
            case SparkSqlParser.KW_VALUES:
            case SparkSqlParser.KW_VARCHAR:
            case SparkSqlParser.KW_VAR:
            case SparkSqlParser.KW_VARIABLE:
            case SparkSqlParser.KW_VERSION:
            case SparkSqlParser.KW_VIEW:
            case SparkSqlParser.KW_VIEWS:
            case SparkSqlParser.KW_VOID:
            case SparkSqlParser.KW_WEEK:
            case SparkSqlParser.KW_WEEKS:
            case SparkSqlParser.KW_WHEN:
            case SparkSqlParser.KW_WHERE:
            case SparkSqlParser.KW_WINDOW:
            case SparkSqlParser.KW_WITH:
            case SparkSqlParser.KW_WITHIN:
            case SparkSqlParser.KW_YEAR:
            case SparkSqlParser.KW_YEARS:
            case SparkSqlParser.KW_ZONE:
            case SparkSqlParser.KW_ZORDER:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
            case SparkSqlParser.IDENTIFIER:
            case SparkSqlParser.BACKQUOTED_IDENTIFIER:
                {
                this.state = 2505;
                this.unpivotSingleValueColumnClause();
                }
                break;
            case SparkSqlParser.LEFT_PAREN:
                {
                this.state = 2506;
                this.unpivotMultiValueColumnClause();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotSingleValueColumnClause(): UnpivotSingleValueColumnClauseContext {
        let localContext = new UnpivotSingleValueColumnClauseContext(this.context, this.state);
        this.enterRule(localContext, 174, SparkSqlParser.RULE_unpivotSingleValueColumnClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2509;
            this.unpivotValueColumn();
            this.state = 2510;
            this.match(SparkSqlParser.KW_FOR);
            this.state = 2511;
            this.unpivotNameColumn();
            this.state = 2512;
            this.match(SparkSqlParser.KW_IN);
            this.state = 2513;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2514;
            localContext._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
            localContext._unpivotColumns.push(localContext._unpivotColumnAndAlias);
            this.state = 2519;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2515;
                this.match(SparkSqlParser.COMMA);
                this.state = 2516;
                localContext._unpivotColumnAndAlias = this.unpivotColumnAndAlias();
                localContext._unpivotColumns.push(localContext._unpivotColumnAndAlias);
                }
                }
                this.state = 2521;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2522;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotMultiValueColumnClause(): UnpivotMultiValueColumnClauseContext {
        let localContext = new UnpivotMultiValueColumnClauseContext(this.context, this.state);
        this.enterRule(localContext, 176, SparkSqlParser.RULE_unpivotMultiValueColumnClause);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2524;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2525;
            localContext._unpivotValueColumn = this.unpivotValueColumn();
            localContext._unpivotValueColumns.push(localContext._unpivotValueColumn);
            this.state = 2530;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2526;
                this.match(SparkSqlParser.COMMA);
                this.state = 2527;
                localContext._unpivotValueColumn = this.unpivotValueColumn();
                localContext._unpivotValueColumns.push(localContext._unpivotValueColumn);
                }
                }
                this.state = 2532;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2533;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2534;
            this.match(SparkSqlParser.KW_FOR);
            this.state = 2535;
            this.unpivotNameColumn();
            this.state = 2536;
            this.match(SparkSqlParser.KW_IN);
            this.state = 2537;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2538;
            localContext._unpivotColumnSet = this.unpivotColumnSet();
            localContext._unpivotColumnSets.push(localContext._unpivotColumnSet);
            this.state = 2543;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2539;
                this.match(SparkSqlParser.COMMA);
                this.state = 2540;
                localContext._unpivotColumnSet = this.unpivotColumnSet();
                localContext._unpivotColumnSets.push(localContext._unpivotColumnSet);
                }
                }
                this.state = 2545;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2546;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotColumnSet(): UnpivotColumnSetContext {
        let localContext = new UnpivotColumnSetContext(this.context, this.state);
        this.enterRule(localContext, 178, SparkSqlParser.RULE_unpivotColumnSet);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2548;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2549;
            localContext._unpivotColumn = this.unpivotColumn();
            localContext._unpivotColumns.push(localContext._unpivotColumn);
            this.state = 2554;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2550;
                this.match(SparkSqlParser.COMMA);
                this.state = 2551;
                localContext._unpivotColumn = this.unpivotColumn();
                localContext._unpivotColumns.push(localContext._unpivotColumn);
                }
                }
                this.state = 2556;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2557;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2559;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 3073) !== 0)) {
                {
                this.state = 2558;
                this.unpivotAlias();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotValueColumn(): UnpivotValueColumnContext {
        let localContext = new UnpivotValueColumnContext(this.context, this.state);
        this.enterRule(localContext, 180, SparkSqlParser.RULE_unpivotValueColumn);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2561;
            this.identifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotNameColumn(): UnpivotNameColumnContext {
        let localContext = new UnpivotNameColumnContext(this.context, this.state);
        this.enterRule(localContext, 182, SparkSqlParser.RULE_unpivotNameColumn);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2563;
            this.identifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext {
        let localContext = new UnpivotColumnAndAliasContext(this.context, this.state);
        this.enterRule(localContext, 184, SparkSqlParser.RULE_unpivotColumnAndAlias);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2565;
            this.unpivotColumn();
            this.state = 2567;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 3073) !== 0)) {
                {
                this.state = 2566;
                this.unpivotAlias();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotColumn(): UnpivotColumnContext {
        let localContext = new UnpivotColumnContext(this.context, this.state);
        this.enterRule(localContext, 186, SparkSqlParser.RULE_unpivotColumn);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2569;
            this.multipartIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unpivotAlias(): UnpivotAliasContext {
        let localContext = new UnpivotAliasContext(this.context, this.state);
        this.enterRule(localContext, 188, SparkSqlParser.RULE_unpivotAlias);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2572;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 319, this.context) ) {
            case 1:
                {
                this.state = 2571;
                this.match(SparkSqlParser.KW_AS);
                }
                break;
            }
            this.state = 2574;
            this.identifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ifNotExists(): IfNotExistsContext {
        let localContext = new IfNotExistsContext(this.context, this.state);
        this.enterRule(localContext, 190, SparkSqlParser.RULE_ifNotExists);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2576;
            this.match(SparkSqlParser.KW_IF);
            this.state = 2577;
            this.match(SparkSqlParser.KW_NOT);
            this.state = 2578;
            this.match(SparkSqlParser.KW_EXISTS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ifExists(): IfExistsContext {
        let localContext = new IfExistsContext(this.context, this.state);
        this.enterRule(localContext, 192, SparkSqlParser.RULE_ifExists);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2580;
            this.match(SparkSqlParser.KW_IF);
            this.state = 2581;
            this.match(SparkSqlParser.KW_EXISTS);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public lateralView(): LateralViewContext {
        let localContext = new LateralViewContext(this.context, this.state);
        this.enterRule(localContext, 194, SparkSqlParser.RULE_lateralView);
        let _la: number;
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2583;
            this.match(SparkSqlParser.KW_LATERAL);
            this.state = 2584;
            this.match(SparkSqlParser.KW_VIEW);
            this.state = 2586;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 320, this.context) ) {
            case 1:
                {
                this.state = 2585;
                this.match(SparkSqlParser.KW_OUTER);
                }
                break;
            }
            this.state = 2588;
            this.viewName();
            this.state = 2589;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2598;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 1073678415) !== 0)) {
                {
                this.state = 2590;
                this.expression();
                this.state = 2595;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2591;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2592;
                    this.expression();
                    }
                    }
                    this.state = 2597;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 2600;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2601;
            this.tableAlias();
            this.state = 2613;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 325, this.context) ) {
            case 1:
                {
                this.state = 2603;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 323, this.context) ) {
                case 1:
                    {
                    this.state = 2602;
                    this.match(SparkSqlParser.KW_AS);
                    }
                    break;
                }
                this.state = 2605;
                localContext._identifier = this.identifier();
                localContext._colName.push(localContext._identifier);
                this.state = 2610;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 324, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2606;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2607;
                        localContext._identifier = this.identifier();
                        localContext._colName.push(localContext._identifier);
                        }
                        }
                    }
                    this.state = 2612;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 324, this.context);
                }
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public setQuantifier(): SetQuantifierContext {
        let localContext = new SetQuantifierContext(this.context, this.state);
        this.enterRule(localContext, 196, SparkSqlParser.RULE_setQuantifier);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2615;
            _la = this.tokenStream.LA(1);
            if(!(_la === 10 || _la === 92)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relation(): RelationContext {
        let localContext = new RelationContext(this.context, this.state);
        this.enterRule(localContext, 198, SparkSqlParser.RULE_relation);
        try {
            let alternative: number;
            this.state = 2628;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 328, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2617;
                this.tableName();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2619;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 326, this.context) ) {
                case 1:
                    {
                    this.state = 2618;
                    this.match(SparkSqlParser.KW_LATERAL);
                    }
                    break;
                }
                this.state = 2621;
                this.relationPrimary();
                this.state = 2625;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 327, this.context);
                while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                    if (alternative === 1) {
                        {
                        {
                        this.state = 2622;
                        this.relationExtension();
                        }
                        }
                    }
                    this.state = 2627;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 327, this.context);
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relationExtension(): RelationExtensionContext {
        let localContext = new RelationExtensionContext(this.context, this.state);
        this.enterRule(localContext, 200, SparkSqlParser.RULE_relationExtension);
        try {
            this.state = 2633;
            this.errorHandler.sync(this);
            switch (this.tokenStream.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(localContext, 1);
                {
                this.state = 2630;
                this.joinRelation();
                }
                break;
            case SparkSqlParser.KW_PIVOT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2631;
                this.pivotClause();
                }
                break;
            case SparkSqlParser.KW_UNPIVOT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2632;
                this.unpivotClause();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public joinRelation(): JoinRelationContext {
        let localContext = new JoinRelationContext(this.context, this.state);
        this.enterRule(localContext, 202, SparkSqlParser.RULE_joinRelation);
        try {
            this.state = 2652;
            this.errorHandler.sync(this);
            switch (this.tokenStream.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(localContext, 1);
                {
                {
                this.state = 2635;
                this.joinType();
                }
                this.state = 2636;
                this.match(SparkSqlParser.KW_JOIN);
                this.state = 2638;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 330, this.context) ) {
                case 1:
                    {
                    this.state = 2637;
                    this.match(SparkSqlParser.KW_LATERAL);
                    }
                    break;
                }
                this.state = 2640;
                localContext._right = this.relationPrimary();
                this.state = 2642;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 331, this.context) ) {
                case 1:
                    {
                    this.state = 2641;
                    this.joinCriteria();
                    }
                    break;
                }
                }
                break;
            case SparkSqlParser.KW_NATURAL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2644;
                this.match(SparkSqlParser.KW_NATURAL);
                this.state = 2645;
                this.joinType();
                this.state = 2646;
                this.match(SparkSqlParser.KW_JOIN);
                this.state = 2648;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 332, this.context) ) {
                case 1:
                    {
                    this.state = 2647;
                    this.match(SparkSqlParser.KW_LATERAL);
                    }
                    break;
                }
                this.state = 2650;
                localContext._right = this.relationPrimary();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public joinType(): JoinTypeContext {
        let localContext = new JoinTypeContext(this.context, this.state);
        this.enterRule(localContext, 204, SparkSqlParser.RULE_joinType);
        let _la: number;
        try {
            this.state = 2678;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 340, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2655;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 144) {
                    {
                    this.state = 2654;
                    this.match(SparkSqlParser.KW_INNER);
                    }
                }

                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2657;
                this.match(SparkSqlParser.KW_CROSS);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2658;
                this.match(SparkSqlParser.KW_LEFT);
                this.state = 2660;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 211) {
                    {
                    this.state = 2659;
                    this.match(SparkSqlParser.KW_OUTER);
                    }
                }

                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2663;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 161) {
                    {
                    this.state = 2662;
                    this.match(SparkSqlParser.KW_LEFT);
                    }
                }

                this.state = 2665;
                this.match(SparkSqlParser.KW_SEMI);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2666;
                this.match(SparkSqlParser.KW_RIGHT);
                this.state = 2668;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 211) {
                    {
                    this.state = 2667;
                    this.match(SparkSqlParser.KW_OUTER);
                    }
                }

                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 2670;
                this.match(SparkSqlParser.KW_FULL);
                this.state = 2672;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 211) {
                    {
                    this.state = 2671;
                    this.match(SparkSqlParser.KW_OUTER);
                    }
                }

                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 2675;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 161) {
                    {
                    this.state = 2674;
                    this.match(SparkSqlParser.KW_LEFT);
                    }
                }

                this.state = 2677;
                this.match(SparkSqlParser.KW_ANTI);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public joinCriteria(): JoinCriteriaContext {
        let localContext = new JoinCriteriaContext(this.context, this.state);
        this.enterRule(localContext, 206, SparkSqlParser.RULE_joinCriteria);
        try {
            this.state = 2684;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_ON:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2680;
                this.match(SparkSqlParser.KW_ON);
                this.state = 2681;
                this.booleanExpression(0);
                }
                break;
            case SparkSqlParser.KW_USING:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2682;
                this.match(SparkSqlParser.KW_USING);
                this.state = 2683;
                this.identifierList();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public sample(): SampleContext {
        let localContext = new SampleContext(this.context, this.state);
        this.enterRule(localContext, 208, SparkSqlParser.RULE_sample);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2686;
            this.match(SparkSqlParser.KW_TABLESAMPLE);
            this.state = 2687;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2689;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 1073678415) !== 0)) {
                {
                this.state = 2688;
                this.sampleMethod();
                }
            }

            this.state = 2691;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2696;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 343, this.context) ) {
            case 1:
                {
                this.state = 2692;
                this.match(SparkSqlParser.KW_REPEATABLE);
                this.state = 2693;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2694;
                localContext._seed = this.match(SparkSqlParser.INTEGER_VALUE);
                this.state = 2695;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public sampleMethod(): SampleMethodContext {
        let localContext = new SampleMethodContext(this.context, this.state);
        this.enterRule(localContext, 210, SparkSqlParser.RULE_sampleMethod);
        let _la: number;
        try {
            this.state = 2722;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 347, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2699;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 2698;
                    localContext._negativeSign = this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 2701;
                localContext._percentage = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 382 || _la === 384)) {
                    localContext._percentage = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 2702;
                this.match(SparkSqlParser.KW_PERCENTLIT);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2703;
                this.expression();
                this.state = 2704;
                this.match(SparkSqlParser.KW_ROWS);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2706;
                localContext._sampleType = this.match(SparkSqlParser.KW_BUCKET);
                this.state = 2707;
                localContext._numerator = this.match(SparkSqlParser.INTEGER_VALUE);
                this.state = 2708;
                this.match(SparkSqlParser.KW_OUT);
                this.state = 2709;
                this.match(SparkSqlParser.KW_OF);
                this.state = 2710;
                localContext._denominator = this.match(SparkSqlParser.INTEGER_VALUE);
                this.state = 2719;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 203) {
                    {
                    this.state = 2711;
                    this.match(SparkSqlParser.KW_ON);
                    this.state = 2717;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 345, this.context) ) {
                    case 1:
                        {
                        this.state = 2712;
                        this.identifier();
                        }
                        break;
                    case 2:
                        {
                        this.state = 2713;
                        this.qualifiedName();
                        this.state = 2714;
                        this.match(SparkSqlParser.LEFT_PAREN);
                        this.state = 2715;
                        this.match(SparkSqlParser.RIGHT_PAREN);
                        }
                        break;
                    }
                    }
                }

                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2721;
                localContext._bytes = this.expression();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifierList(): IdentifierListContext {
        let localContext = new IdentifierListContext(this.context, this.state);
        this.enterRule(localContext, 212, SparkSqlParser.RULE_identifierList);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2724;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2725;
            this.identifierSeq();
            this.state = 2726;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifierSeq(): IdentifierSeqContext {
        let localContext = new IdentifierSeqContext(this.context, this.state);
        this.enterRule(localContext, 214, SparkSqlParser.RULE_identifierSeq);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2728;
            localContext._errorCapturingIdentifier = this.errorCapturingIdentifier();
            localContext._ident.push(localContext._errorCapturingIdentifier);
            this.state = 2733;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 348, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 2729;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2730;
                    localContext._errorCapturingIdentifier = this.errorCapturingIdentifier();
                    localContext._ident.push(localContext._errorCapturingIdentifier);
                    }
                    }
                }
                this.state = 2735;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 348, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public orderedIdentifierList(): OrderedIdentifierListContext {
        let localContext = new OrderedIdentifierListContext(this.context, this.state);
        this.enterRule(localContext, 216, SparkSqlParser.RULE_orderedIdentifierList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2736;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2737;
            this.orderedIdentifier();
            this.state = 2742;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2738;
                this.match(SparkSqlParser.COMMA);
                this.state = 2739;
                this.orderedIdentifier();
                }
                }
                this.state = 2744;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2745;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public orderedIdentifier(): OrderedIdentifierContext {
        let localContext = new OrderedIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 218, SparkSqlParser.RULE_orderedIdentifier);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2747;
            localContext._ident = this.errorCapturingIdentifier();
            this.state = 2749;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 21 || _la === 86) {
                {
                this.state = 2748;
                localContext._ordering = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 21 || _la === 86)) {
                    localContext._ordering = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifierCommentList(): IdentifierCommentListContext {
        let localContext = new IdentifierCommentListContext(this.context, this.state);
        this.enterRule(localContext, 220, SparkSqlParser.RULE_identifierCommentList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2751;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2752;
            this.identifierComment();
            this.state = 2757;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2753;
                this.match(SparkSqlParser.COMMA);
                this.state = 2754;
                this.identifierComment();
                }
                }
                this.state = 2759;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 2760;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifierComment(): IdentifierCommentContext {
        let localContext = new IdentifierCommentContext(this.context, this.state);
        this.enterRule(localContext, 222, SparkSqlParser.RULE_identifierComment);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2762;
            this.columnNameCreate();
            this.state = 2764;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 51) {
                {
                this.state = 2763;
                this.commentSpec();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public relationPrimary(): RelationPrimaryContext {
        let localContext = new RelationPrimaryContext(this.context, this.state);
        this.enterRule(localContext, 224, SparkSqlParser.RULE_relationPrimary);
        try {
            this.state = 2797;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 358, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2769;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 353, this.context) ) {
                case 1:
                    {
                    this.state = 2766;
                    this.tableName();
                    }
                    break;
                case 2:
                    {
                    this.state = 2767;
                    this.viewName();
                    }
                    break;
                case 3:
                    {
                    this.state = 2768;
                    this.identifierReference();
                    }
                    break;
                }
                this.state = 2772;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 354, this.context) ) {
                case 1:
                    {
                    this.state = 2771;
                    this.temporalClause();
                    }
                    break;
                }
                this.state = 2775;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 355, this.context) ) {
                case 1:
                    {
                    this.state = 2774;
                    this.sample();
                    }
                    break;
                }
                this.state = 2777;
                this.tableAlias();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2779;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2780;
                this.query();
                this.state = 2781;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 2783;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 356, this.context) ) {
                case 1:
                    {
                    this.state = 2782;
                    this.sample();
                    }
                    break;
                }
                this.state = 2785;
                this.tableAlias();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2787;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2788;
                this.relation();
                this.state = 2789;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 2791;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 357, this.context) ) {
                case 1:
                    {
                    this.state = 2790;
                    this.sample();
                    }
                    break;
                }
                this.state = 2793;
                this.tableAlias();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 2795;
                this.inlineTable();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 2796;
                this.functionTable();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public inlineTable(): InlineTableContext {
        let localContext = new InlineTableContext(this.context, this.state);
        this.enterRule(localContext, 226, SparkSqlParser.RULE_inlineTable);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2799;
            this.match(SparkSqlParser.KW_VALUES);
            this.state = 2800;
            this.expression();
            this.state = 2805;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 359, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 2801;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2802;
                    this.expression();
                    }
                    }
                }
                this.state = 2807;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 359, this.context);
            }
            this.state = 2808;
            this.tableAlias();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionTableSubqueryArgument(): FunctionTableSubqueryArgumentContext {
        let localContext = new FunctionTableSubqueryArgumentContext(this.context, this.state);
        this.enterRule(localContext, 228, SparkSqlParser.RULE_functionTableSubqueryArgument);
        let _la: number;
        try {
            this.state = 2829;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 363, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2810;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 2811;
                this.tableName();
                this.state = 2813;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 93 || _la === 217 || _la === 346) {
                    {
                    this.state = 2812;
                    this.tableArgumentPartitioning();
                    }
                }

                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2815;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 2816;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2817;
                this.tableName();
                this.state = 2818;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 2820;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 93 || _la === 217 || _la === 346) {
                    {
                    this.state = 2819;
                    this.tableArgumentPartitioning();
                    }
                }

                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 2822;
                this.match(SparkSqlParser.KW_TABLE);
                this.state = 2823;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 2824;
                this.query();
                this.state = 2825;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 2827;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 93 || _la === 217 || _la === 346) {
                    {
                    this.state = 2826;
                    this.tableArgumentPartitioning();
                    }
                }

                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableArgumentPartitioning(): TableArgumentPartitioningContext {
        let localContext = new TableArgumentPartitioningContext(this.context, this.state);
        this.enterRule(localContext, 230, SparkSqlParser.RULE_tableArgumentPartitioning);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2850;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_WITH:
                {
                {
                this.state = 2831;
                this.match(SparkSqlParser.KW_WITH);
                this.state = 2832;
                this.match(SparkSqlParser.KW_SINGLE);
                this.state = 2833;
                this.match(SparkSqlParser.KW_PARTITION);
                }
                }
                break;
            case SparkSqlParser.KW_DISTRIBUTE:
            case SparkSqlParser.KW_PARTITION:
                {
                {
                this.state = 2834;
                _la = this.tokenStream.LA(1);
                if(!(_la === 93 || _la === 217)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 2835;
                this.match(SparkSqlParser.KW_BY);
                this.state = 2848;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 365, this.context) ) {
                case 1:
                    {
                    {
                    {
                    this.state = 2836;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 2837;
                    localContext._expression = this.expression();
                    localContext._partition.push(localContext._expression);
                    this.state = 2842;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 2838;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2839;
                        localContext._expression = this.expression();
                        localContext._partition.push(localContext._expression);
                        }
                        }
                        this.state = 2844;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 2845;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    }
                    }
                    break;
                case 2:
                    {
                    this.state = 2847;
                    localContext._expression = this.expression();
                    localContext._partition.push(localContext._expression);
                    }
                    break;
                }
                }
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            this.state = 2868;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 209 || _la === 278) {
                {
                this.state = 2852;
                _la = this.tokenStream.LA(1);
                if(!(_la === 209 || _la === 278)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 2853;
                this.match(SparkSqlParser.KW_BY);
                {
                this.state = 2866;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 368, this.context) ) {
                case 1:
                    {
                    {
                    this.state = 2854;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 2855;
                    this.sortItem();
                    this.state = 2860;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 2856;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 2857;
                        this.sortItem();
                        }
                        }
                        this.state = 2862;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 2863;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    }
                    break;
                case 2:
                    {
                    this.state = 2865;
                    this.sortItem();
                    }
                    break;
                }
                }
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionTableNamedArgumentExpression(): FunctionTableNamedArgumentExpressionContext {
        let localContext = new FunctionTableNamedArgumentExpressionContext(this.context, this.state);
        this.enterRule(localContext, 232, SparkSqlParser.RULE_functionTableNamedArgumentExpression);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2870;
            localContext._key = this.identifier();
            this.state = 2871;
            this.match(SparkSqlParser.FAT_ARROW);
            this.state = 2872;
            localContext._table = this.functionTableSubqueryArgument();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionTableReferenceArgument(): FunctionTableReferenceArgumentContext {
        let localContext = new FunctionTableReferenceArgumentContext(this.context, this.state);
        this.enterRule(localContext, 234, SparkSqlParser.RULE_functionTableReferenceArgument);
        try {
            this.state = 2876;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_TABLE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2874;
                this.functionTableSubqueryArgument();
                }
                break;
            case SparkSqlParser.KW_ADD:
            case SparkSqlParser.KW_AFTER:
            case SparkSqlParser.KW_ALL:
            case SparkSqlParser.KW_ALTER:
            case SparkSqlParser.KW_ALWAYS:
            case SparkSqlParser.KW_ANALYZE:
            case SparkSqlParser.KW_AND:
            case SparkSqlParser.KW_ANTI:
            case SparkSqlParser.KW_ANY:
            case SparkSqlParser.KW_ANY_VALUE:
            case SparkSqlParser.KW_ARCHIVE:
            case SparkSqlParser.KW_ARRAY:
            case SparkSqlParser.KW_AS:
            case SparkSqlParser.KW_ASC:
            case SparkSqlParser.KW_AT:
            case SparkSqlParser.KW_AUTHORIZATION:
            case SparkSqlParser.KW_BETWEEN:
            case SparkSqlParser.KW_BIGINT:
            case SparkSqlParser.KW_BINARY:
            case SparkSqlParser.KW_BOOLEAN:
            case SparkSqlParser.KW_BOTH:
            case SparkSqlParser.KW_BUCKET:
            case SparkSqlParser.KW_BUCKETS:
            case SparkSqlParser.KW_BY:
            case SparkSqlParser.KW_BYTE:
            case SparkSqlParser.KW_CACHE:
            case SparkSqlParser.KW_CASCADE:
            case SparkSqlParser.KW_CASE:
            case SparkSqlParser.KW_CAST:
            case SparkSqlParser.KW_CATALOG:
            case SparkSqlParser.KW_CATALOGS:
            case SparkSqlParser.KW_CHANGE:
            case SparkSqlParser.KW_CHAR:
            case SparkSqlParser.KW_CHARACTER:
            case SparkSqlParser.KW_CHECK:
            case SparkSqlParser.KW_CLEAR:
            case SparkSqlParser.KW_CLUSTER:
            case SparkSqlParser.KW_CLUSTERED:
            case SparkSqlParser.KW_CODEGEN:
            case SparkSqlParser.KW_COLLATE:
            case SparkSqlParser.KW_COLLECTION:
            case SparkSqlParser.KW_COLUMN:
            case SparkSqlParser.KW_COLUMNS:
            case SparkSqlParser.KW_COMMENT:
            case SparkSqlParser.KW_COMMIT:
            case SparkSqlParser.KW_COMPACT:
            case SparkSqlParser.KW_COMPACTIONS:
            case SparkSqlParser.KW_COMPUTE:
            case SparkSqlParser.KW_CONCATENATE:
            case SparkSqlParser.KW_CONSTRAINT:
            case SparkSqlParser.KW_COST:
            case SparkSqlParser.KW_CREATE:
            case SparkSqlParser.KW_CROSS:
            case SparkSqlParser.KW_CUBE:
            case SparkSqlParser.KW_CURRENT:
            case SparkSqlParser.KW_CURRENT_DATE:
            case SparkSqlParser.KW_CURRENT_TIME:
            case SparkSqlParser.KW_CURRENT_TIMESTAMP:
            case SparkSqlParser.KW_CURRENT_USER:
            case SparkSqlParser.KW_DAY:
            case SparkSqlParser.KW_DAYS:
            case SparkSqlParser.KW_DAYOFYEAR:
            case SparkSqlParser.KW_DATA:
            case SparkSqlParser.KW_DATE:
            case SparkSqlParser.KW_DATABASE:
            case SparkSqlParser.KW_DATABASES:
            case SparkSqlParser.KW_DATEADD:
            case SparkSqlParser.KW_DATE_ADD:
            case SparkSqlParser.KW_DATEDIFF:
            case SparkSqlParser.KW_DATE_DIFF:
            case SparkSqlParser.KW_DBPROPERTIES:
            case SparkSqlParser.KW_DEC:
            case SparkSqlParser.KW_DECIMAL:
            case SparkSqlParser.KW_DECLARE:
            case SparkSqlParser.KW_DEFAULT:
            case SparkSqlParser.KW_DEFINED:
            case SparkSqlParser.KW_DELETE:
            case SparkSqlParser.KW_DELIMITED:
            case SparkSqlParser.KW_DESC:
            case SparkSqlParser.KW_DESCRIBE:
            case SparkSqlParser.KW_DFS:
            case SparkSqlParser.KW_DIRECTORIES:
            case SparkSqlParser.KW_DIRECTORY:
            case SparkSqlParser.KW_DISABLE:
            case SparkSqlParser.KW_DISTINCT:
            case SparkSqlParser.KW_DISTRIBUTE:
            case SparkSqlParser.KW_DIV:
            case SparkSqlParser.KW_DOUBLE:
            case SparkSqlParser.KW_DROP:
            case SparkSqlParser.KW_ELSE:
            case SparkSqlParser.KW_ENABLE:
            case SparkSqlParser.KW_END:
            case SparkSqlParser.KW_ESCAPE:
            case SparkSqlParser.KW_ESCAPED:
            case SparkSqlParser.KW_EXCEPT:
            case SparkSqlParser.KW_EXCHANGE:
            case SparkSqlParser.KW_EXCLUDE:
            case SparkSqlParser.KW_EXISTS:
            case SparkSqlParser.KW_EXPLAIN:
            case SparkSqlParser.KW_EXPORT:
            case SparkSqlParser.KW_EXTENDED:
            case SparkSqlParser.KW_EXTERNAL:
            case SparkSqlParser.KW_EXTRACT:
            case SparkSqlParser.KW_FALSE:
            case SparkSqlParser.KW_FETCH:
            case SparkSqlParser.KW_FIELDS:
            case SparkSqlParser.KW_FILTER:
            case SparkSqlParser.KW_FILEFORMAT:
            case SparkSqlParser.KW_FIRST:
            case SparkSqlParser.KW_FLOAT:
            case SparkSqlParser.KW_FOLLOWING:
            case SparkSqlParser.KW_FOR:
            case SparkSqlParser.KW_FOREIGN:
            case SparkSqlParser.KW_FORMAT:
            case SparkSqlParser.KW_FORMATTED:
            case SparkSqlParser.KW_FULL:
            case SparkSqlParser.KW_FUNCTION:
            case SparkSqlParser.KW_FUNCTIONS:
            case SparkSqlParser.KW_GENERATED:
            case SparkSqlParser.KW_GLOBAL:
            case SparkSqlParser.KW_GRANT:
            case SparkSqlParser.KW_GROUP:
            case SparkSqlParser.KW_GROUPING:
            case SparkSqlParser.KW_HAVING:
            case SparkSqlParser.KW_BINARY_HEX:
            case SparkSqlParser.KW_HOUR:
            case SparkSqlParser.KW_HOURS:
            case SparkSqlParser.KW_IDENTIFIER:
            case SparkSqlParser.KW_IF:
            case SparkSqlParser.KW_IGNORE:
            case SparkSqlParser.KW_IMPORT:
            case SparkSqlParser.KW_IN:
            case SparkSqlParser.KW_INCLUDE:
            case SparkSqlParser.KW_INDEX:
            case SparkSqlParser.KW_INDEXES:
            case SparkSqlParser.KW_INNER:
            case SparkSqlParser.KW_INPATH:
            case SparkSqlParser.KW_INPUTFORMAT:
            case SparkSqlParser.KW_INSERT:
            case SparkSqlParser.KW_INTERSECT:
            case SparkSqlParser.KW_INTERVAL:
            case SparkSqlParser.KW_INT:
            case SparkSqlParser.KW_INTEGER:
            case SparkSqlParser.KW_INTO:
            case SparkSqlParser.KW_IS:
            case SparkSqlParser.KW_ITEMS:
            case SparkSqlParser.KW_JOIN:
            case SparkSqlParser.KW_KEYS:
            case SparkSqlParser.KW_LAST:
            case SparkSqlParser.KW_LATERAL:
            case SparkSqlParser.KW_LAZY:
            case SparkSqlParser.KW_LEADING:
            case SparkSqlParser.KW_LEFT:
            case SparkSqlParser.KW_LIFECYCLE:
            case SparkSqlParser.KW_LIKE:
            case SparkSqlParser.KW_ILIKE:
            case SparkSqlParser.KW_LIMIT:
            case SparkSqlParser.KW_LINES:
            case SparkSqlParser.KW_LIST:
            case SparkSqlParser.KW_LOAD:
            case SparkSqlParser.KW_LOCAL:
            case SparkSqlParser.KW_LOCATION:
            case SparkSqlParser.KW_LOCK:
            case SparkSqlParser.KW_LOCKS:
            case SparkSqlParser.KW_LOGICAL:
            case SparkSqlParser.KW_LONG:
            case SparkSqlParser.KW_MACRO:
            case SparkSqlParser.KW_MATERIALIZED:
            case SparkSqlParser.KW_MAP:
            case SparkSqlParser.KW_MATCHED:
            case SparkSqlParser.KW_MERGE:
            case SparkSqlParser.KW_MICROSECOND:
            case SparkSqlParser.KW_MICROSECONDS:
            case SparkSqlParser.KW_MILLISECOND:
            case SparkSqlParser.KW_MILLISECONDS:
            case SparkSqlParser.KW_MINUTE:
            case SparkSqlParser.KW_MINUTES:
            case SparkSqlParser.KW_MONTH:
            case SparkSqlParser.KW_MONTHS:
            case SparkSqlParser.KW_MSCK:
            case SparkSqlParser.KW_NAME:
            case SparkSqlParser.KW_NAMESPACE:
            case SparkSqlParser.KW_NAMESPACES:
            case SparkSqlParser.KW_NANOSECOND:
            case SparkSqlParser.KW_NANOSECONDS:
            case SparkSqlParser.KW_NATURAL:
            case SparkSqlParser.KW_NO:
            case SparkSqlParser.KW_NOT:
            case SparkSqlParser.KW_NULL:
            case SparkSqlParser.KW_NULLS:
            case SparkSqlParser.KW_NUMERIC:
            case SparkSqlParser.KW_OF:
            case SparkSqlParser.KW_OFFSET:
            case SparkSqlParser.KW_ON:
            case SparkSqlParser.KW_ONLY:
            case SparkSqlParser.KW_OPTIMIZE:
            case SparkSqlParser.KW_OPTION:
            case SparkSqlParser.KW_OPTIONS:
            case SparkSqlParser.KW_OR:
            case SparkSqlParser.KW_ORDER:
            case SparkSqlParser.KW_OUT:
            case SparkSqlParser.KW_OUTER:
            case SparkSqlParser.KW_OUTPUTFORMAT:
            case SparkSqlParser.KW_OVER:
            case SparkSqlParser.KW_OVERLAPS:
            case SparkSqlParser.KW_OVERLAY:
            case SparkSqlParser.KW_OVERWRITE:
            case SparkSqlParser.KW_PARTITION:
            case SparkSqlParser.KW_PARTITIONED:
            case SparkSqlParser.KW_PARTITIONS:
            case SparkSqlParser.KW_PERCENTILE_CONT:
            case SparkSqlParser.KW_PERCENTILE_DISC:
            case SparkSqlParser.KW_PERCENTLIT:
            case SparkSqlParser.KW_PIVOT:
            case SparkSqlParser.KW_PLACING:
            case SparkSqlParser.KW_POSITION:
            case SparkSqlParser.KW_PRECEDING:
            case SparkSqlParser.KW_PRIMARY:
            case SparkSqlParser.KW_PRINCIPALS:
            case SparkSqlParser.KW_PROPERTIES:
            case SparkSqlParser.KW_PURGE:
            case SparkSqlParser.KW_QUARTER:
            case SparkSqlParser.KW_QUERY:
            case SparkSqlParser.KW_RANGE:
            case SparkSqlParser.KW_REAL:
            case SparkSqlParser.KW_RECORDREADER:
            case SparkSqlParser.KW_RECORDWRITER:
            case SparkSqlParser.KW_RECOVER:
            case SparkSqlParser.KW_REDUCE:
            case SparkSqlParser.KW_REFERENCES:
            case SparkSqlParser.KW_REFRESH:
            case SparkSqlParser.KW_RENAME:
            case SparkSqlParser.KW_REPAIR:
            case SparkSqlParser.KW_REPEATABLE:
            case SparkSqlParser.KW_REPLACE:
            case SparkSqlParser.KW_RESET:
            case SparkSqlParser.KW_RESPECT:
            case SparkSqlParser.KW_RESTRICT:
            case SparkSqlParser.KW_REWRITE:
            case SparkSqlParser.KW_REVOKE:
            case SparkSqlParser.KW_RIGHT:
            case SparkSqlParser.KW_RLIKE:
            case SparkSqlParser.KW_REGEXP:
            case SparkSqlParser.KW_ROLE:
            case SparkSqlParser.KW_ROLES:
            case SparkSqlParser.KW_ROLLBACK:
            case SparkSqlParser.KW_ROLLUP:
            case SparkSqlParser.KW_ROW:
            case SparkSqlParser.KW_ROWS:
            case SparkSqlParser.KW_SECOND:
            case SparkSqlParser.KW_SECONDS:
            case SparkSqlParser.KW_SCHEMA:
            case SparkSqlParser.KW_SCHEMAS:
            case SparkSqlParser.KW_SEMI:
            case SparkSqlParser.KW_SEPARATED:
            case SparkSqlParser.KW_SERDE:
            case SparkSqlParser.KW_SERDEPROPERTIES:
            case SparkSqlParser.KW_SESSION_USER:
            case SparkSqlParser.KW_SET:
            case SparkSqlParser.KW_MINUS:
            case SparkSqlParser.KW_SETS:
            case SparkSqlParser.KW_SHORT:
            case SparkSqlParser.KW_SHOW:
            case SparkSqlParser.KW_SINGLE:
            case SparkSqlParser.KW_SKEWED:
            case SparkSqlParser.KW_SMALLINT:
            case SparkSqlParser.KW_SOME:
            case SparkSqlParser.KW_SORT:
            case SparkSqlParser.KW_SORTED:
            case SparkSqlParser.KW_SOURCE:
            case SparkSqlParser.KW_START:
            case SparkSqlParser.KW_STATISTICS:
            case SparkSqlParser.KW_STORED:
            case SparkSqlParser.KW_STRATIFY:
            case SparkSqlParser.KW_STRING:
            case SparkSqlParser.KW_STRUCT:
            case SparkSqlParser.KW_SUBSTR:
            case SparkSqlParser.KW_SUBSTRING:
            case SparkSqlParser.KW_SYNC:
            case SparkSqlParser.KW_SYSTEM:
            case SparkSqlParser.KW_SYSTEM_TIME:
            case SparkSqlParser.KW_SYSTEM_VERSION:
            case SparkSqlParser.KW_TABLES:
            case SparkSqlParser.KW_TABLESAMPLE:
            case SparkSqlParser.KW_TARGET:
            case SparkSqlParser.KW_TBLPROPERTIES:
            case SparkSqlParser.KW_TEMPORARY:
            case SparkSqlParser.KW_TERMINATED:
            case SparkSqlParser.KW_THEN:
            case SparkSqlParser.KW_TIME:
            case SparkSqlParser.KW_TIMEDIFF:
            case SparkSqlParser.KW_TIMESTAMP:
            case SparkSqlParser.KW_TIMESTAMP_LTZ:
            case SparkSqlParser.KW_TIMESTAMP_NTZ:
            case SparkSqlParser.KW_TIMESTAMPADD:
            case SparkSqlParser.KW_TIMESTAMPDIFF:
            case SparkSqlParser.KW_TINYINT:
            case SparkSqlParser.KW_TO:
            case SparkSqlParser.KW_TOUCH:
            case SparkSqlParser.KW_TRAILING:
            case SparkSqlParser.KW_TRANSACTION:
            case SparkSqlParser.KW_TRANSACTIONS:
            case SparkSqlParser.KW_TRANSFORM:
            case SparkSqlParser.KW_TRIM:
            case SparkSqlParser.KW_TRUE:
            case SparkSqlParser.KW_TRUNCATE:
            case SparkSqlParser.KW_TRY_CAST:
            case SparkSqlParser.KW_TYPE:
            case SparkSqlParser.KW_UNARCHIVE:
            case SparkSqlParser.KW_UNBOUNDED:
            case SparkSqlParser.KW_UNCACHE:
            case SparkSqlParser.KW_UNION:
            case SparkSqlParser.KW_UNIQUE:
            case SparkSqlParser.KW_UNKNOWN:
            case SparkSqlParser.KW_UNLOCK:
            case SparkSqlParser.KW_UNPIVOT:
            case SparkSqlParser.KW_UNSET:
            case SparkSqlParser.KW_UPDATE:
            case SparkSqlParser.KW_USE:
            case SparkSqlParser.KW_USER:
            case SparkSqlParser.KW_USING:
            case SparkSqlParser.KW_VALUES:
            case SparkSqlParser.KW_VARCHAR:
            case SparkSqlParser.KW_VAR:
            case SparkSqlParser.KW_VARIABLE:
            case SparkSqlParser.KW_VERSION:
            case SparkSqlParser.KW_VIEW:
            case SparkSqlParser.KW_VIEWS:
            case SparkSqlParser.KW_VOID:
            case SparkSqlParser.KW_WEEK:
            case SparkSqlParser.KW_WEEKS:
            case SparkSqlParser.KW_WHEN:
            case SparkSqlParser.KW_WHERE:
            case SparkSqlParser.KW_WINDOW:
            case SparkSqlParser.KW_WITH:
            case SparkSqlParser.KW_WITHIN:
            case SparkSqlParser.KW_YEAR:
            case SparkSqlParser.KW_YEARS:
            case SparkSqlParser.KW_ZONE:
            case SparkSqlParser.KW_ZORDER:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
            case SparkSqlParser.IDENTIFIER:
            case SparkSqlParser.BACKQUOTED_IDENTIFIER:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2875;
                this.functionTableNamedArgumentExpression();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionTableArgument(): FunctionTableArgumentContext {
        let localContext = new FunctionTableArgumentContext(this.context, this.state);
        this.enterRule(localContext, 236, SparkSqlParser.RULE_functionTableArgument);
        try {
            this.state = 2880;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 371, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2878;
                this.functionTableReferenceArgument();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2879;
                this.functionArgument();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionTable(): FunctionTableContext {
        let localContext = new FunctionTableContext(this.context, this.state);
        this.enterRule(localContext, 238, SparkSqlParser.RULE_functionTable);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2882;
            this.functionName();
            this.state = 2883;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 2892;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967295) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 1073678415) !== 0)) {
                {
                this.state = 2884;
                this.functionTableArgument();
                this.state = 2889;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 2885;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 2886;
                    this.functionTableArgument();
                    }
                    }
                    this.state = 2891;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                }
            }

            this.state = 2894;
            this.match(SparkSqlParser.RIGHT_PAREN);
            this.state = 2895;
            this.tableAlias();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableAlias(): TableAliasContext {
        let localContext = new TableAliasContext(this.context, this.state);
        this.enterRule(localContext, 240, SparkSqlParser.RULE_tableAlias);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2904;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 376, this.context) ) {
            case 1:
                {
                this.state = 2898;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 374, this.context) ) {
                case 1:
                    {
                    this.state = 2897;
                    this.match(SparkSqlParser.KW_AS);
                    }
                    break;
                }
                this.state = 2900;
                this.strictIdentifier();
                this.state = 2902;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 375, this.context) ) {
                case 1:
                    {
                    this.state = 2901;
                    this.identifierList();
                    }
                    break;
                }
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public rowFormat(): RowFormatContext {
        let localContext = new RowFormatContext(this.context, this.state);
        this.enterRule(localContext, 242, SparkSqlParser.RULE_rowFormat);
        try {
            this.state = 2955;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 384, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 2906;
                this.match(SparkSqlParser.KW_ROW);
                this.state = 2907;
                this.match(SparkSqlParser.KW_FORMAT);
                this.state = 2908;
                this.match(SparkSqlParser.KW_SERDE);
                this.state = 2909;
                localContext._name = this.stringLit();
                this.state = 2913;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 377, this.context) ) {
                case 1:
                    {
                    this.state = 2910;
                    this.match(SparkSqlParser.KW_WITH);
                    this.state = 2911;
                    this.match(SparkSqlParser.KW_SERDEPROPERTIES);
                    this.state = 2912;
                    localContext._props = this.propertyList();
                    }
                    break;
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 2915;
                this.match(SparkSqlParser.KW_ROW);
                this.state = 2916;
                this.match(SparkSqlParser.KW_FORMAT);
                this.state = 2917;
                this.match(SparkSqlParser.KW_DELIMITED);
                this.state = 2927;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 379, this.context) ) {
                case 1:
                    {
                    this.state = 2918;
                    this.match(SparkSqlParser.KW_FIELDS);
                    this.state = 2919;
                    this.match(SparkSqlParser.KW_TERMINATED);
                    this.state = 2920;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 2921;
                    localContext._fieldsTerminatedBy = this.stringLit();
                    this.state = 2925;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 378, this.context) ) {
                    case 1:
                        {
                        this.state = 2922;
                        this.match(SparkSqlParser.KW_ESCAPED);
                        this.state = 2923;
                        this.match(SparkSqlParser.KW_BY);
                        this.state = 2924;
                        localContext._escapedBy = this.stringLit();
                        }
                        break;
                    }
                    }
                    break;
                }
                this.state = 2934;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 380, this.context) ) {
                case 1:
                    {
                    this.state = 2929;
                    this.match(SparkSqlParser.KW_COLLECTION);
                    this.state = 2930;
                    this.match(SparkSqlParser.KW_ITEMS);
                    this.state = 2931;
                    this.match(SparkSqlParser.KW_TERMINATED);
                    this.state = 2932;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 2933;
                    localContext._collectionItemsTerminatedBy = this.stringLit();
                    }
                    break;
                }
                this.state = 2941;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 381, this.context) ) {
                case 1:
                    {
                    this.state = 2936;
                    this.match(SparkSqlParser.KW_MAP);
                    this.state = 2937;
                    this.match(SparkSqlParser.KW_KEYS);
                    this.state = 2938;
                    this.match(SparkSqlParser.KW_TERMINATED);
                    this.state = 2939;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 2940;
                    localContext._keysTerminatedBy = this.stringLit();
                    }
                    break;
                }
                this.state = 2947;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 382, this.context) ) {
                case 1:
                    {
                    this.state = 2943;
                    this.match(SparkSqlParser.KW_LINES);
                    this.state = 2944;
                    this.match(SparkSqlParser.KW_TERMINATED);
                    this.state = 2945;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 2946;
                    localContext._linesSeparatedBy = this.stringLit();
                    }
                    break;
                }
                this.state = 2953;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 383, this.context) ) {
                case 1:
                    {
                    this.state = 2949;
                    this.match(SparkSqlParser.KW_NULL);
                    this.state = 2950;
                    this.match(SparkSqlParser.KW_DEFINED);
                    this.state = 2951;
                    this.match(SparkSqlParser.KW_AS);
                    this.state = 2952;
                    localContext._nullDefinedAs = this.stringLit();
                    }
                    break;
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public multipartIdentifierList(): MultipartIdentifierListContext {
        let localContext = new MultipartIdentifierListContext(this.context, this.state);
        this.enterRule(localContext, 244, SparkSqlParser.RULE_multipartIdentifierList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2957;
            this.multipartIdentifier();
            this.state = 2962;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2958;
                this.match(SparkSqlParser.COMMA);
                this.state = 2959;
                this.multipartIdentifier();
                }
                }
                this.state = 2964;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public multipartIdentifier(): MultipartIdentifierContext {
        let localContext = new MultipartIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 246, SparkSqlParser.RULE_multipartIdentifier);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2965;
            localContext._errorCapturingIdentifier = this.errorCapturingIdentifier();
            localContext._parts.push(localContext._errorCapturingIdentifier);
            this.state = 2970;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 386, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 2966;
                    this.match(SparkSqlParser.DOT);
                    this.state = 2967;
                    localContext._errorCapturingIdentifier = this.errorCapturingIdentifier();
                    localContext._parts.push(localContext._errorCapturingIdentifier);
                    }
                    }
                }
                this.state = 2972;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 386, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext {
        let localContext = new MultipartIdentifierPropertyListContext(this.context, this.state);
        this.enterRule(localContext, 248, SparkSqlParser.RULE_multipartIdentifierPropertyList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2973;
            this.multipartIdentifierProperty();
            this.state = 2978;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 2974;
                this.match(SparkSqlParser.COMMA);
                this.state = 2975;
                this.multipartIdentifierProperty();
                }
                }
                this.state = 2980;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public multipartIdentifierProperty(): MultipartIdentifierPropertyContext {
        let localContext = new MultipartIdentifierPropertyContext(this.context, this.state);
        this.enterRule(localContext, 250, SparkSqlParser.RULE_multipartIdentifierProperty);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2981;
            this.multipartIdentifier();
            this.state = 2984;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 207) {
                {
                this.state = 2982;
                this.match(SparkSqlParser.KW_OPTIONS);
                this.state = 2983;
                localContext._options = this.propertyList();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public tableIdentifier(): TableIdentifierContext {
        let localContext = new TableIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 252, SparkSqlParser.RULE_tableIdentifier);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2989;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 389, this.context) ) {
            case 1:
                {
                this.state = 2986;
                localContext._db = this.errorCapturingIdentifier();
                this.state = 2987;
                this.match(SparkSqlParser.DOT);
                }
                break;
            }
            this.state = 2991;
            localContext._table = this.errorCapturingIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public viewIdentifier(): ViewIdentifierContext {
        let localContext = new ViewIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 254, SparkSqlParser.RULE_viewIdentifier);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 2996;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 390, this.context) ) {
            case 1:
                {
                this.state = 2993;
                localContext._db = this.errorCapturingIdentifier();
                this.state = 2994;
                this.match(SparkSqlParser.DOT);
                }
                break;
            }
            this.state = 2998;
            localContext._view = this.errorCapturingIdentifier();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namedExpression(): NamedExpressionContext {
        let localContext = new NamedExpressionContext(this.context, this.state);
        this.enterRule(localContext, 256, SparkSqlParser.RULE_namedExpression);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3002;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 391, this.context) ) {
            case 1:
                {
                this.state = 3000;
                this.columnName();
                }
                break;
            case 2:
                {
                this.state = 3001;
                this.expression();
                }
                break;
            }
            this.state = 3011;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 394, this.context) ) {
            case 1:
                {
                this.state = 3005;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 392, this.context) ) {
                case 1:
                    {
                    this.state = 3004;
                    this.match(SparkSqlParser.KW_AS);
                    }
                    break;
                }
                this.state = 3009;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_ADD:
                case SparkSqlParser.KW_AFTER:
                case SparkSqlParser.KW_ALL:
                case SparkSqlParser.KW_ALTER:
                case SparkSqlParser.KW_ALWAYS:
                case SparkSqlParser.KW_ANALYZE:
                case SparkSqlParser.KW_AND:
                case SparkSqlParser.KW_ANTI:
                case SparkSqlParser.KW_ANY:
                case SparkSqlParser.KW_ANY_VALUE:
                case SparkSqlParser.KW_ARCHIVE:
                case SparkSqlParser.KW_ARRAY:
                case SparkSqlParser.KW_AS:
                case SparkSqlParser.KW_ASC:
                case SparkSqlParser.KW_AT:
                case SparkSqlParser.KW_AUTHORIZATION:
                case SparkSqlParser.KW_BETWEEN:
                case SparkSqlParser.KW_BIGINT:
                case SparkSqlParser.KW_BINARY:
                case SparkSqlParser.KW_BOOLEAN:
                case SparkSqlParser.KW_BOTH:
                case SparkSqlParser.KW_BUCKET:
                case SparkSqlParser.KW_BUCKETS:
                case SparkSqlParser.KW_BY:
                case SparkSqlParser.KW_BYTE:
                case SparkSqlParser.KW_CACHE:
                case SparkSqlParser.KW_CASCADE:
                case SparkSqlParser.KW_CASE:
                case SparkSqlParser.KW_CAST:
                case SparkSqlParser.KW_CATALOG:
                case SparkSqlParser.KW_CATALOGS:
                case SparkSqlParser.KW_CHANGE:
                case SparkSqlParser.KW_CHAR:
                case SparkSqlParser.KW_CHARACTER:
                case SparkSqlParser.KW_CHECK:
                case SparkSqlParser.KW_CLEAR:
                case SparkSqlParser.KW_CLUSTER:
                case SparkSqlParser.KW_CLUSTERED:
                case SparkSqlParser.KW_CODEGEN:
                case SparkSqlParser.KW_COLLATE:
                case SparkSqlParser.KW_COLLECTION:
                case SparkSqlParser.KW_COLUMN:
                case SparkSqlParser.KW_COLUMNS:
                case SparkSqlParser.KW_COMMENT:
                case SparkSqlParser.KW_COMMIT:
                case SparkSqlParser.KW_COMPACT:
                case SparkSqlParser.KW_COMPACTIONS:
                case SparkSqlParser.KW_COMPUTE:
                case SparkSqlParser.KW_CONCATENATE:
                case SparkSqlParser.KW_CONSTRAINT:
                case SparkSqlParser.KW_COST:
                case SparkSqlParser.KW_CREATE:
                case SparkSqlParser.KW_CROSS:
                case SparkSqlParser.KW_CUBE:
                case SparkSqlParser.KW_CURRENT:
                case SparkSqlParser.KW_CURRENT_DATE:
                case SparkSqlParser.KW_CURRENT_TIME:
                case SparkSqlParser.KW_CURRENT_TIMESTAMP:
                case SparkSqlParser.KW_CURRENT_USER:
                case SparkSqlParser.KW_DAY:
                case SparkSqlParser.KW_DAYS:
                case SparkSqlParser.KW_DAYOFYEAR:
                case SparkSqlParser.KW_DATA:
                case SparkSqlParser.KW_DATE:
                case SparkSqlParser.KW_DATABASE:
                case SparkSqlParser.KW_DATABASES:
                case SparkSqlParser.KW_DATEADD:
                case SparkSqlParser.KW_DATE_ADD:
                case SparkSqlParser.KW_DATEDIFF:
                case SparkSqlParser.KW_DATE_DIFF:
                case SparkSqlParser.KW_DBPROPERTIES:
                case SparkSqlParser.KW_DEC:
                case SparkSqlParser.KW_DECIMAL:
                case SparkSqlParser.KW_DECLARE:
                case SparkSqlParser.KW_DEFAULT:
                case SparkSqlParser.KW_DEFINED:
                case SparkSqlParser.KW_DELETE:
                case SparkSqlParser.KW_DELIMITED:
                case SparkSqlParser.KW_DESC:
                case SparkSqlParser.KW_DESCRIBE:
                case SparkSqlParser.KW_DFS:
                case SparkSqlParser.KW_DIRECTORIES:
                case SparkSqlParser.KW_DIRECTORY:
                case SparkSqlParser.KW_DISABLE:
                case SparkSqlParser.KW_DISTINCT:
                case SparkSqlParser.KW_DISTRIBUTE:
                case SparkSqlParser.KW_DIV:
                case SparkSqlParser.KW_DOUBLE:
                case SparkSqlParser.KW_DROP:
                case SparkSqlParser.KW_ELSE:
                case SparkSqlParser.KW_ENABLE:
                case SparkSqlParser.KW_END:
                case SparkSqlParser.KW_ESCAPE:
                case SparkSqlParser.KW_ESCAPED:
                case SparkSqlParser.KW_EXCEPT:
                case SparkSqlParser.KW_EXCHANGE:
                case SparkSqlParser.KW_EXCLUDE:
                case SparkSqlParser.KW_EXISTS:
                case SparkSqlParser.KW_EXPLAIN:
                case SparkSqlParser.KW_EXPORT:
                case SparkSqlParser.KW_EXTENDED:
                case SparkSqlParser.KW_EXTERNAL:
                case SparkSqlParser.KW_EXTRACT:
                case SparkSqlParser.KW_FALSE:
                case SparkSqlParser.KW_FETCH:
                case SparkSqlParser.KW_FIELDS:
                case SparkSqlParser.KW_FILTER:
                case SparkSqlParser.KW_FILEFORMAT:
                case SparkSqlParser.KW_FIRST:
                case SparkSqlParser.KW_FLOAT:
                case SparkSqlParser.KW_FOLLOWING:
                case SparkSqlParser.KW_FOR:
                case SparkSqlParser.KW_FOREIGN:
                case SparkSqlParser.KW_FORMAT:
                case SparkSqlParser.KW_FORMATTED:
                case SparkSqlParser.KW_FULL:
                case SparkSqlParser.KW_FUNCTION:
                case SparkSqlParser.KW_FUNCTIONS:
                case SparkSqlParser.KW_GENERATED:
                case SparkSqlParser.KW_GLOBAL:
                case SparkSqlParser.KW_GRANT:
                case SparkSqlParser.KW_GROUP:
                case SparkSqlParser.KW_GROUPING:
                case SparkSqlParser.KW_HAVING:
                case SparkSqlParser.KW_BINARY_HEX:
                case SparkSqlParser.KW_HOUR:
                case SparkSqlParser.KW_HOURS:
                case SparkSqlParser.KW_IDENTIFIER:
                case SparkSqlParser.KW_IF:
                case SparkSqlParser.KW_IGNORE:
                case SparkSqlParser.KW_IMPORT:
                case SparkSqlParser.KW_IN:
                case SparkSqlParser.KW_INCLUDE:
                case SparkSqlParser.KW_INDEX:
                case SparkSqlParser.KW_INDEXES:
                case SparkSqlParser.KW_INNER:
                case SparkSqlParser.KW_INPATH:
                case SparkSqlParser.KW_INPUTFORMAT:
                case SparkSqlParser.KW_INSERT:
                case SparkSqlParser.KW_INTERSECT:
                case SparkSqlParser.KW_INTERVAL:
                case SparkSqlParser.KW_INT:
                case SparkSqlParser.KW_INTEGER:
                case SparkSqlParser.KW_INTO:
                case SparkSqlParser.KW_IS:
                case SparkSqlParser.KW_ITEMS:
                case SparkSqlParser.KW_JOIN:
                case SparkSqlParser.KW_KEYS:
                case SparkSqlParser.KW_LAST:
                case SparkSqlParser.KW_LATERAL:
                case SparkSqlParser.KW_LAZY:
                case SparkSqlParser.KW_LEADING:
                case SparkSqlParser.KW_LEFT:
                case SparkSqlParser.KW_LIFECYCLE:
                case SparkSqlParser.KW_LIKE:
                case SparkSqlParser.KW_ILIKE:
                case SparkSqlParser.KW_LIMIT:
                case SparkSqlParser.KW_LINES:
                case SparkSqlParser.KW_LIST:
                case SparkSqlParser.KW_LOAD:
                case SparkSqlParser.KW_LOCAL:
                case SparkSqlParser.KW_LOCATION:
                case SparkSqlParser.KW_LOCK:
                case SparkSqlParser.KW_LOCKS:
                case SparkSqlParser.KW_LOGICAL:
                case SparkSqlParser.KW_LONG:
                case SparkSqlParser.KW_MACRO:
                case SparkSqlParser.KW_MATERIALIZED:
                case SparkSqlParser.KW_MAP:
                case SparkSqlParser.KW_MATCHED:
                case SparkSqlParser.KW_MERGE:
                case SparkSqlParser.KW_MICROSECOND:
                case SparkSqlParser.KW_MICROSECONDS:
                case SparkSqlParser.KW_MILLISECOND:
                case SparkSqlParser.KW_MILLISECONDS:
                case SparkSqlParser.KW_MINUTE:
                case SparkSqlParser.KW_MINUTES:
                case SparkSqlParser.KW_MONTH:
                case SparkSqlParser.KW_MONTHS:
                case SparkSqlParser.KW_MSCK:
                case SparkSqlParser.KW_NAME:
                case SparkSqlParser.KW_NAMESPACE:
                case SparkSqlParser.KW_NAMESPACES:
                case SparkSqlParser.KW_NANOSECOND:
                case SparkSqlParser.KW_NANOSECONDS:
                case SparkSqlParser.KW_NATURAL:
                case SparkSqlParser.KW_NO:
                case SparkSqlParser.KW_NOT:
                case SparkSqlParser.KW_NULL:
                case SparkSqlParser.KW_NULLS:
                case SparkSqlParser.KW_NUMERIC:
                case SparkSqlParser.KW_OF:
                case SparkSqlParser.KW_OFFSET:
                case SparkSqlParser.KW_ON:
                case SparkSqlParser.KW_ONLY:
                case SparkSqlParser.KW_OPTIMIZE:
                case SparkSqlParser.KW_OPTION:
                case SparkSqlParser.KW_OPTIONS:
                case SparkSqlParser.KW_OR:
                case SparkSqlParser.KW_ORDER:
                case SparkSqlParser.KW_OUT:
                case SparkSqlParser.KW_OUTER:
                case SparkSqlParser.KW_OUTPUTFORMAT:
                case SparkSqlParser.KW_OVER:
                case SparkSqlParser.KW_OVERLAPS:
                case SparkSqlParser.KW_OVERLAY:
                case SparkSqlParser.KW_OVERWRITE:
                case SparkSqlParser.KW_PARTITION:
                case SparkSqlParser.KW_PARTITIONED:
                case SparkSqlParser.KW_PARTITIONS:
                case SparkSqlParser.KW_PERCENTILE_CONT:
                case SparkSqlParser.KW_PERCENTILE_DISC:
                case SparkSqlParser.KW_PERCENTLIT:
                case SparkSqlParser.KW_PIVOT:
                case SparkSqlParser.KW_PLACING:
                case SparkSqlParser.KW_POSITION:
                case SparkSqlParser.KW_PRECEDING:
                case SparkSqlParser.KW_PRIMARY:
                case SparkSqlParser.KW_PRINCIPALS:
                case SparkSqlParser.KW_PROPERTIES:
                case SparkSqlParser.KW_PURGE:
                case SparkSqlParser.KW_QUARTER:
                case SparkSqlParser.KW_QUERY:
                case SparkSqlParser.KW_RANGE:
                case SparkSqlParser.KW_REAL:
                case SparkSqlParser.KW_RECORDREADER:
                case SparkSqlParser.KW_RECORDWRITER:
                case SparkSqlParser.KW_RECOVER:
                case SparkSqlParser.KW_REDUCE:
                case SparkSqlParser.KW_REFERENCES:
                case SparkSqlParser.KW_REFRESH:
                case SparkSqlParser.KW_RENAME:
                case SparkSqlParser.KW_REPAIR:
                case SparkSqlParser.KW_REPEATABLE:
                case SparkSqlParser.KW_REPLACE:
                case SparkSqlParser.KW_RESET:
                case SparkSqlParser.KW_RESPECT:
                case SparkSqlParser.KW_RESTRICT:
                case SparkSqlParser.KW_REWRITE:
                case SparkSqlParser.KW_REVOKE:
                case SparkSqlParser.KW_RIGHT:
                case SparkSqlParser.KW_RLIKE:
                case SparkSqlParser.KW_REGEXP:
                case SparkSqlParser.KW_ROLE:
                case SparkSqlParser.KW_ROLES:
                case SparkSqlParser.KW_ROLLBACK:
                case SparkSqlParser.KW_ROLLUP:
                case SparkSqlParser.KW_ROW:
                case SparkSqlParser.KW_ROWS:
                case SparkSqlParser.KW_SECOND:
                case SparkSqlParser.KW_SECONDS:
                case SparkSqlParser.KW_SCHEMA:
                case SparkSqlParser.KW_SCHEMAS:
                case SparkSqlParser.KW_SEMI:
                case SparkSqlParser.KW_SEPARATED:
                case SparkSqlParser.KW_SERDE:
                case SparkSqlParser.KW_SERDEPROPERTIES:
                case SparkSqlParser.KW_SESSION_USER:
                case SparkSqlParser.KW_SET:
                case SparkSqlParser.KW_MINUS:
                case SparkSqlParser.KW_SETS:
                case SparkSqlParser.KW_SHORT:
                case SparkSqlParser.KW_SHOW:
                case SparkSqlParser.KW_SINGLE:
                case SparkSqlParser.KW_SKEWED:
                case SparkSqlParser.KW_SMALLINT:
                case SparkSqlParser.KW_SOME:
                case SparkSqlParser.KW_SORT:
                case SparkSqlParser.KW_SORTED:
                case SparkSqlParser.KW_SOURCE:
                case SparkSqlParser.KW_START:
                case SparkSqlParser.KW_STATISTICS:
                case SparkSqlParser.KW_STORED:
                case SparkSqlParser.KW_STRATIFY:
                case SparkSqlParser.KW_STRING:
                case SparkSqlParser.KW_STRUCT:
                case SparkSqlParser.KW_SUBSTR:
                case SparkSqlParser.KW_SUBSTRING:
                case SparkSqlParser.KW_SYNC:
                case SparkSqlParser.KW_SYSTEM:
                case SparkSqlParser.KW_SYSTEM_TIME:
                case SparkSqlParser.KW_SYSTEM_VERSION:
                case SparkSqlParser.KW_TABLES:
                case SparkSqlParser.KW_TABLESAMPLE:
                case SparkSqlParser.KW_TARGET:
                case SparkSqlParser.KW_TBLPROPERTIES:
                case SparkSqlParser.KW_TEMPORARY:
                case SparkSqlParser.KW_TERMINATED:
                case SparkSqlParser.KW_THEN:
                case SparkSqlParser.KW_TIME:
                case SparkSqlParser.KW_TIMEDIFF:
                case SparkSqlParser.KW_TIMESTAMP:
                case SparkSqlParser.KW_TIMESTAMP_LTZ:
                case SparkSqlParser.KW_TIMESTAMP_NTZ:
                case SparkSqlParser.KW_TIMESTAMPADD:
                case SparkSqlParser.KW_TIMESTAMPDIFF:
                case SparkSqlParser.KW_TINYINT:
                case SparkSqlParser.KW_TO:
                case SparkSqlParser.KW_TOUCH:
                case SparkSqlParser.KW_TRAILING:
                case SparkSqlParser.KW_TRANSACTION:
                case SparkSqlParser.KW_TRANSACTIONS:
                case SparkSqlParser.KW_TRANSFORM:
                case SparkSqlParser.KW_TRIM:
                case SparkSqlParser.KW_TRUE:
                case SparkSqlParser.KW_TRUNCATE:
                case SparkSqlParser.KW_TRY_CAST:
                case SparkSqlParser.KW_TYPE:
                case SparkSqlParser.KW_UNARCHIVE:
                case SparkSqlParser.KW_UNBOUNDED:
                case SparkSqlParser.KW_UNCACHE:
                case SparkSqlParser.KW_UNION:
                case SparkSqlParser.KW_UNIQUE:
                case SparkSqlParser.KW_UNKNOWN:
                case SparkSqlParser.KW_UNLOCK:
                case SparkSqlParser.KW_UNPIVOT:
                case SparkSqlParser.KW_UNSET:
                case SparkSqlParser.KW_UPDATE:
                case SparkSqlParser.KW_USE:
                case SparkSqlParser.KW_USER:
                case SparkSqlParser.KW_USING:
                case SparkSqlParser.KW_VALUES:
                case SparkSqlParser.KW_VARCHAR:
                case SparkSqlParser.KW_VAR:
                case SparkSqlParser.KW_VARIABLE:
                case SparkSqlParser.KW_VERSION:
                case SparkSqlParser.KW_VIEW:
                case SparkSqlParser.KW_VIEWS:
                case SparkSqlParser.KW_VOID:
                case SparkSqlParser.KW_WEEK:
                case SparkSqlParser.KW_WEEKS:
                case SparkSqlParser.KW_WHEN:
                case SparkSqlParser.KW_WHERE:
                case SparkSqlParser.KW_WINDOW:
                case SparkSqlParser.KW_WITH:
                case SparkSqlParser.KW_WITHIN:
                case SparkSqlParser.KW_YEAR:
                case SparkSqlParser.KW_YEARS:
                case SparkSqlParser.KW_ZONE:
                case SparkSqlParser.KW_ZORDER:
                case SparkSqlParser.DOUBLEQUOTED_STRING:
                case SparkSqlParser.IDENTIFIER:
                case SparkSqlParser.BACKQUOTED_IDENTIFIER:
                    {
                    this.state = 3007;
                    localContext._name = this.errorCapturingIdentifier();
                    }
                    break;
                case SparkSqlParser.LEFT_PAREN:
                    {
                    this.state = 3008;
                    this.identifierList();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namedExpressionSeq(): NamedExpressionSeqContext {
        let localContext = new NamedExpressionSeqContext(this.context, this.state);
        this.enterRule(localContext, 258, SparkSqlParser.RULE_namedExpressionSeq);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3013;
            this.namedExpression();
            this.state = 3018;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 395, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 3014;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3015;
                    this.namedExpression();
                    }
                    }
                }
                this.state = 3020;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 395, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public partitionFieldList(): PartitionFieldListContext {
        let localContext = new PartitionFieldListContext(this.context, this.state);
        this.enterRule(localContext, 260, SparkSqlParser.RULE_partitionFieldList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3021;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 3022;
            localContext._partitionField = this.partitionField();
            localContext._fields.push(localContext._partitionField);
            this.state = 3027;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3023;
                this.match(SparkSqlParser.COMMA);
                this.state = 3024;
                localContext._partitionField = this.partitionField();
                localContext._fields.push(localContext._partitionField);
                }
                }
                this.state = 3029;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            this.state = 3030;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public partitionField(): PartitionFieldContext {
        let localContext = new PartitionFieldContext(this.context, this.state);
        this.enterRule(localContext, 262, SparkSqlParser.RULE_partitionField);
        try {
            this.state = 3034;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 397, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3032;
                this.transform();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3033;
                this.colType();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public transform(): TransformContext {
        let localContext = new TransformContext(this.context, this.state);
        this.enterRule(localContext, 264, SparkSqlParser.RULE_transform);
        let _la: number;
        try {
            this.state = 3049;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 399, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3036;
                this.qualifiedName();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3037;
                localContext._transformName = this.identifier();
                this.state = 3038;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3039;
                this.transformArgument();
                this.state = 3044;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 3040;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3041;
                    this.transformArgument();
                    }
                    }
                    this.state = 3046;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 3047;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public transformArgument(): TransformArgumentContext {
        let localContext = new TransformArgumentContext(this.context, this.state);
        this.enterRule(localContext, 266, SparkSqlParser.RULE_transformArgument);
        try {
            this.state = 3053;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 400, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3051;
                this.qualifiedName();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3052;
                this.constant();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public expression(): ExpressionContext {
        let localContext = new ExpressionContext(this.context, this.state);
        this.enterRule(localContext, 268, SparkSqlParser.RULE_expression);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3055;
            this.booleanExpression(0);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namedArgumentExpression(): NamedArgumentExpressionContext {
        let localContext = new NamedArgumentExpressionContext(this.context, this.state);
        this.enterRule(localContext, 270, SparkSqlParser.RULE_namedArgumentExpression);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3057;
            localContext._key = this.identifier();
            this.state = 3058;
            this.match(SparkSqlParser.FAT_ARROW);
            this.state = 3059;
            localContext._value = this.expression();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionArgument(): FunctionArgumentContext {
        let localContext = new FunctionArgumentContext(this.context, this.state);
        this.enterRule(localContext, 272, SparkSqlParser.RULE_functionArgument);
        try {
            this.state = 3063;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 401, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3061;
                this.expression();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3062;
                this.namedArgumentExpression();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public expressionSeq(): ExpressionSeqContext {
        let localContext = new ExpressionSeqContext(this.context, this.state);
        this.enterRule(localContext, 274, SparkSqlParser.RULE_expressionSeq);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3065;
            this.expression();
            this.state = 3070;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3066;
                this.match(SparkSqlParser.COMMA);
                this.state = 3067;
                this.expression();
                }
                }
                this.state = 3072;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

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

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new BooleanExpressionContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 276;
        this.enterRecursionRule(localContext, 276, SparkSqlParser.RULE_booleanExpression, _p);
        let _la: number;
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3085;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 404, this.context) ) {
            case 1:
                {
                this.state = 3074;
                _la = this.tokenStream.LA(1);
                if(!(_la === 197 || _la === 360)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3075;
                this.booleanExpression(5);
                }
                break;
            case 2:
                {
                this.state = 3076;
                this.match(SparkSqlParser.KW_EXISTS);
                this.state = 3077;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3078;
                this.query();
                this.state = 3079;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 3:
                {
                this.state = 3081;
                this.valueExpression(0);
                this.state = 3083;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 403, this.context) ) {
                case 1:
                    {
                    this.state = 3082;
                    this.predicate();
                    }
                    break;
                }
                }
                break;
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 3095;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 406, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this._parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    this.state = 3093;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 405, this.context) ) {
                    case 1:
                        {
                        localContext = new BooleanExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_booleanExpression);
                        this.state = 3087;
                        if (!(this.precpred(this.context, 2))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
                        }
                        this.state = 3088;
                        localContext._operator = this.match(SparkSqlParser.KW_AND);
                        this.state = 3089;
                        localContext._right = this.booleanExpression(3);
                        }
                        break;
                    case 2:
                        {
                        localContext = new BooleanExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_booleanExpression);
                        this.state = 3090;
                        if (!(this.precpred(this.context, 1))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 1)");
                        }
                        this.state = 3091;
                        localContext._operator = this.match(SparkSqlParser.KW_OR);
                        this.state = 3092;
                        localContext._right = this.booleanExpression(2);
                        }
                        break;
                    }
                    }
                }
                this.state = 3097;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 406, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public predicate(): PredicateContext {
        let localContext = new PredicateContext(this.context, this.state);
        this.enterRule(localContext, 278, SparkSqlParser.RULE_predicate);
        let _la: number;
        try {
            this.state = 3180;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 420, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3099;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3098;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3101;
                localContext._kind = this.match(SparkSqlParser.KW_BETWEEN);
                this.state = 3102;
                localContext._lower = this.valueExpression(0);
                this.state = 3103;
                this.match(SparkSqlParser.KW_AND);
                this.state = 3104;
                localContext._upper = this.valueExpression(0);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3107;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3106;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3109;
                localContext._kind = this.match(SparkSqlParser.KW_IN);
                this.state = 3110;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3111;
                this.expression();
                this.state = 3116;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                while (_la === 4) {
                    {
                    {
                    this.state = 3112;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3113;
                    this.expression();
                    }
                    }
                    this.state = 3118;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                }
                this.state = 3119;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3122;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3121;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3124;
                localContext._kind = this.match(SparkSqlParser.KW_IN);
                this.state = 3125;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3126;
                this.query();
                this.state = 3127;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3130;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3129;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3132;
                localContext._kind = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 251 || _la === 252)) {
                    localContext._kind = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3133;
                localContext._pattern = this.valueExpression(0);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3135;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3134;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3137;
                localContext._kind = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 163 || _la === 164)) {
                    localContext._kind = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3138;
                localContext._quantifier = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 10 || _la === 16 || _la === 277)) {
                    localContext._quantifier = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3152;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 414, this.context) ) {
                case 1:
                    {
                    this.state = 3139;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 3140;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                case 2:
                    {
                    this.state = 3141;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 3142;
                    this.expression();
                    this.state = 3147;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 3143;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 3144;
                        this.expression();
                        }
                        }
                        this.state = 3149;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 3150;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3155;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3154;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3157;
                localContext._kind = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 163 || _la === 164)) {
                    localContext._kind = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3158;
                localContext._pattern = this.valueExpression(0);
                this.state = 3161;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 416, this.context) ) {
                case 1:
                    {
                    this.state = 3159;
                    this.match(SparkSqlParser.KW_ESCAPE);
                    this.state = 3160;
                    localContext._escapeChar = this.stringLit();
                    }
                    break;
                }
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3163;
                this.match(SparkSqlParser.KW_IS);
                this.state = 3165;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3164;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3167;
                localContext._kind = this.match(SparkSqlParser.KW_NULL);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 3168;
                this.match(SparkSqlParser.KW_IS);
                this.state = 3170;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3169;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3172;
                localContext._kind = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 111 || _la === 316 || _la === 325)) {
                    localContext._kind = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 3173;
                this.match(SparkSqlParser.KW_IS);
                this.state = 3175;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 197) {
                    {
                    this.state = 3174;
                    this.match(SparkSqlParser.KW_NOT);
                    }
                }

                this.state = 3177;
                localContext._kind = this.match(SparkSqlParser.KW_DISTINCT);
                this.state = 3178;
                this.match(SparkSqlParser.KW_FROM);
                this.state = 3179;
                localContext._right = this.valueExpression(0);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

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

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new ValueExpressionContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 280;
        this.enterRecursionRule(localContext, 280, SparkSqlParser.RULE_valueExpression, _p);
        let _la: number;
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3186;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 421, this.context) ) {
            case 1:
                {
                this.state = 3183;
                this.primaryExpression(0);
                }
                break;
            case 2:
                {
                this.state = 3184;
                localContext._operator = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(((((_la - 361)) & ~0x1F) === 0 && ((1 << (_la - 361)) & 35) !== 0))) {
                    localContext._operator = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3185;
                this.valueExpression(7);
                }
                break;
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 3209;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 423, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this._parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    this.state = 3207;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 422, this.context) ) {
                    case 1:
                        {
                        localContext = new ValueExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_valueExpression);
                        this.state = 3188;
                        if (!(this.precpred(this.context, 6))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 6)");
                        }
                        this.state = 3189;
                        localContext._operator = this.tokenStream.LT(1);
                        _la = this.tokenStream.LA(1);
                        if(!(_la === 94 || ((((_la - 363)) & ~0x1F) === 0 && ((1 << (_la - 363)) & 7) !== 0))) {
                            localContext._operator = this.errorHandler.recoverInline(this);
                        }
                        else {
                            this.errorHandler.reportMatch(this);
                            this.consume();
                        }
                        this.state = 3190;
                        localContext._right = this.valueExpression(7);
                        }
                        break;
                    case 2:
                        {
                        localContext = new ValueExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_valueExpression);
                        this.state = 3191;
                        if (!(this.precpred(this.context, 5))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 5)");
                        }
                        this.state = 3192;
                        localContext._operator = this.tokenStream.LT(1);
                        _la = this.tokenStream.LA(1);
                        if(!(((((_la - 361)) & ~0x1F) === 0 && ((1 << (_la - 361)) & 259) !== 0))) {
                            localContext._operator = this.errorHandler.recoverInline(this);
                        }
                        else {
                            this.errorHandler.reportMatch(this);
                            this.consume();
                        }
                        this.state = 3193;
                        localContext._right = this.valueExpression(6);
                        }
                        break;
                    case 3:
                        {
                        localContext = new ValueExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_valueExpression);
                        this.state = 3194;
                        if (!(this.precpred(this.context, 4))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 4)");
                        }
                        this.state = 3195;
                        localContext._operator = this.match(SparkSqlParser.AMPERSAND);
                        this.state = 3196;
                        localContext._right = this.valueExpression(5);
                        }
                        break;
                    case 4:
                        {
                        localContext = new ValueExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_valueExpression);
                        this.state = 3197;
                        if (!(this.precpred(this.context, 3))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 3)");
                        }
                        this.state = 3198;
                        localContext._operator = this.match(SparkSqlParser.HAT);
                        this.state = 3199;
                        localContext._right = this.valueExpression(4);
                        }
                        break;
                    case 5:
                        {
                        localContext = new ValueExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_valueExpression);
                        this.state = 3200;
                        if (!(this.precpred(this.context, 2))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 2)");
                        }
                        this.state = 3201;
                        localContext._operator = this.match(SparkSqlParser.PIPE);
                        this.state = 3202;
                        localContext._right = this.valueExpression(3);
                        }
                        break;
                    case 6:
                        {
                        localContext = new ValueExpressionContext(parentContext, parentState);
                        localContext._left = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_valueExpression);
                        this.state = 3203;
                        if (!(this.precpred(this.context, 1))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 1)");
                        }
                        this.state = 3204;
                        this.comparisonOperator();
                        this.state = 3205;
                        localContext._right = this.valueExpression(2);
                        }
                        break;
                    }
                    }
                }
                this.state = 3211;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 423, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public datetimeUnit(): DatetimeUnitContext {
        let localContext = new DatetimeUnitContext(this.context, this.state);
        this.enterRule(localContext, 282, SparkSqlParser.RULE_datetimeUnit);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3212;
            _la = this.tokenStream.LA(1);
            if(!(_la === 67 || _la === 69 || _la === 134 || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 85) !== 0) || _la === 231 || _la === 259 || _la === 341 || _la === 348)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

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

        let parentContext = this.context;
        let parentState = this.state;
        let localContext = new PrimaryExpressionContext(this.context, parentState);
        let previousContext = localContext;
        let _startState = 284;
        this.enterRecursionRule(localContext, 284, SparkSqlParser.RULE_primaryExpression, _p);
        let _la: number;
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3463;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 449, this.context) ) {
            case 1:
                {
                this.state = 3215;
                localContext._name = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(((((_la - 63)) & ~0x1F) === 0 && ((1 << (_la - 63)) & 13) !== 0) || _la === 268 || _la === 331)) {
                    localContext._name = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            case 2:
                {
                this.state = 3216;
                localContext._name = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 74 || _la === 75 || _la === 306)) {
                    localContext._name = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3217;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3220;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_DAY:
                case SparkSqlParser.KW_DAYOFYEAR:
                case SparkSqlParser.KW_HOUR:
                case SparkSqlParser.KW_MICROSECOND:
                case SparkSqlParser.KW_MILLISECOND:
                case SparkSqlParser.KW_MINUTE:
                case SparkSqlParser.KW_MONTH:
                case SparkSqlParser.KW_QUARTER:
                case SparkSqlParser.KW_SECOND:
                case SparkSqlParser.KW_WEEK:
                case SparkSqlParser.KW_YEAR:
                    {
                    this.state = 3218;
                    localContext._unit = this.datetimeUnit();
                    }
                    break;
                case SparkSqlParser.STRING_LITERAL:
                case SparkSqlParser.DOUBLEQUOTED_STRING:
                    {
                    this.state = 3219;
                    localContext._invalidUnit = this.stringLit();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3222;
                this.match(SparkSqlParser.COMMA);
                this.state = 3223;
                localContext._unitsAmount = this.valueExpression(0);
                this.state = 3224;
                this.match(SparkSqlParser.COMMA);
                this.state = 3225;
                localContext._timestamp = this.valueExpression(0);
                this.state = 3226;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 3:
                {
                this.state = 3228;
                localContext._name = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 76 || _la === 77 || _la === 302 || _la === 307)) {
                    localContext._name = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3229;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3232;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_DAY:
                case SparkSqlParser.KW_DAYOFYEAR:
                case SparkSqlParser.KW_HOUR:
                case SparkSqlParser.KW_MICROSECOND:
                case SparkSqlParser.KW_MILLISECOND:
                case SparkSqlParser.KW_MINUTE:
                case SparkSqlParser.KW_MONTH:
                case SparkSqlParser.KW_QUARTER:
                case SparkSqlParser.KW_SECOND:
                case SparkSqlParser.KW_WEEK:
                case SparkSqlParser.KW_YEAR:
                    {
                    this.state = 3230;
                    localContext._unit = this.datetimeUnit();
                    }
                    break;
                case SparkSqlParser.STRING_LITERAL:
                case SparkSqlParser.DOUBLEQUOTED_STRING:
                    {
                    this.state = 3231;
                    localContext._invalidUnit = this.stringLit();
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3234;
                this.match(SparkSqlParser.COMMA);
                this.state = 3235;
                localContext._startTimestamp = this.valueExpression(0);
                this.state = 3236;
                this.match(SparkSqlParser.COMMA);
                this.state = 3237;
                localContext._endTimestamp = this.valueExpression(0);
                this.state = 3238;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 4:
                {
                this.state = 3240;
                this.match(SparkSqlParser.KW_CASE);
                this.state = 3242;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                do {
                    {
                    {
                    this.state = 3241;
                    this.whenClause();
                    }
                    }
                    this.state = 3244;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                } while (_la === 343);
                this.state = 3248;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 97) {
                    {
                    this.state = 3246;
                    this.match(SparkSqlParser.KW_ELSE);
                    this.state = 3247;
                    localContext._elseExpression = this.expression();
                    }
                }

                this.state = 3250;
                this.match(SparkSqlParser.KW_END);
                }
                break;
            case 5:
                {
                this.state = 3252;
                this.match(SparkSqlParser.KW_CASE);
                this.state = 3253;
                this.expression();
                this.state = 3255;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                do {
                    {
                    {
                    this.state = 3254;
                    this.whenClause();
                    }
                    }
                    this.state = 3257;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                } while (_la === 343);
                this.state = 3261;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 97) {
                    {
                    this.state = 3259;
                    this.match(SparkSqlParser.KW_ELSE);
                    this.state = 3260;
                    localContext._elseExpression = this.expression();
                    }
                }

                this.state = 3263;
                this.match(SparkSqlParser.KW_END);
                }
                break;
            case 6:
                {
                this.state = 3265;
                localContext._name = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 36 || _la === 318)) {
                    localContext._name = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3266;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3267;
                this.expression();
                this.state = 3268;
                this.match(SparkSqlParser.KW_AS);
                this.state = 3269;
                this.dataType();
                this.state = 3270;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 7:
                {
                this.state = 3272;
                this.match(SparkSqlParser.KW_STRUCT);
                this.state = 3273;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3282;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 431, this.context) ) {
                case 1:
                    {
                    this.state = 3274;
                    this.namedExpression();
                    this.state = 3279;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 3275;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 3276;
                        this.namedExpression();
                        }
                        }
                        this.state = 3281;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                    break;
                }
                this.state = 3284;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 8:
                {
                this.state = 3285;
                this.match(SparkSqlParser.KW_FIRST);
                this.state = 3286;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3287;
                this.expression();
                this.state = 3290;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 138) {
                    {
                    this.state = 3288;
                    this.match(SparkSqlParser.KW_IGNORE);
                    this.state = 3289;
                    this.match(SparkSqlParser.KW_NULLS);
                    }
                }

                this.state = 3292;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 9:
                {
                this.state = 3294;
                this.match(SparkSqlParser.KW_ANY_VALUE);
                this.state = 3295;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3296;
                this.expression();
                this.state = 3299;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 138) {
                    {
                    this.state = 3297;
                    this.match(SparkSqlParser.KW_IGNORE);
                    this.state = 3298;
                    this.match(SparkSqlParser.KW_NULLS);
                    }
                }

                this.state = 3301;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 10:
                {
                this.state = 3303;
                this.match(SparkSqlParser.KW_LAST);
                this.state = 3304;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3305;
                this.expression();
                this.state = 3308;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 138) {
                    {
                    this.state = 3306;
                    this.match(SparkSqlParser.KW_IGNORE);
                    this.state = 3307;
                    this.match(SparkSqlParser.KW_NULLS);
                    }
                }

                this.state = 3310;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 11:
                {
                this.state = 3312;
                this.match(SparkSqlParser.KW_POSITION);
                this.state = 3313;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3314;
                localContext._substr = this.valueExpression(0);
                this.state = 3315;
                this.match(SparkSqlParser.KW_IN);
                this.state = 3316;
                localContext._str = this.valueExpression(0);
                this.state = 3317;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 12:
                {
                this.state = 3319;
                this.constant();
                }
                break;
            case 13:
                {
                this.state = 3320;
                this.match(SparkSqlParser.ASTERISK);
                }
                break;
            case 14:
                {
                this.state = 3321;
                this.qualifiedName();
                this.state = 3322;
                this.match(SparkSqlParser.DOT);
                this.state = 3323;
                this.match(SparkSqlParser.ASTERISK);
                }
                break;
            case 15:
                {
                this.state = 3325;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3326;
                this.namedExpression();
                this.state = 3329;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                do {
                    {
                    {
                    this.state = 3327;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3328;
                    this.namedExpression();
                    }
                    }
                    this.state = 3331;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                } while (_la === 4);
                this.state = 3333;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 16:
                {
                this.state = 3335;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3336;
                this.query();
                this.state = 3337;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 17:
                {
                this.state = 3339;
                this.match(SparkSqlParser.KW_IDENTIFIER);
                this.state = 3340;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3341;
                this.expression();
                this.state = 3342;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 18:
                {
                this.state = 3344;
                this.functionName();
                this.state = 3345;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3357;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 360)) & ~0x1F) === 0 && ((1 << (_la - 360)) & 1073678415) !== 0)) {
                    {
                    this.state = 3347;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 436, this.context) ) {
                    case 1:
                        {
                        this.state = 3346;
                        this.setQuantifier();
                        }
                        break;
                    }
                    this.state = 3349;
                    this.functionArgument();
                    this.state = 3354;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 3350;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 3351;
                        this.functionArgument();
                        }
                        }
                        this.state = 3356;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    }
                }

                this.state = 3359;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 3366;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 439, this.context) ) {
                case 1:
                    {
                    this.state = 3360;
                    this.match(SparkSqlParser.KW_FILTER);
                    this.state = 3361;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 3362;
                    this.match(SparkSqlParser.KW_WHERE);
                    this.state = 3363;
                    localContext._where = this.booleanExpression(0);
                    this.state = 3364;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                this.state = 3370;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 440, this.context) ) {
                case 1:
                    {
                    this.state = 3368;
                    localContext._nullsOption = this.tokenStream.LT(1);
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 138 || _la === 246)) {
                        localContext._nullsOption = this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 3369;
                    this.match(SparkSqlParser.KW_NULLS);
                    }
                    break;
                }
                this.state = 3374;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 441, this.context) ) {
                case 1:
                    {
                    this.state = 3372;
                    this.match(SparkSqlParser.KW_OVER);
                    this.state = 3373;
                    this.windowSpec();
                    }
                    break;
                }
                }
                break;
            case 19:
                {
                this.state = 3376;
                this.identifier();
                this.state = 3377;
                this.match(SparkSqlParser.ARROW);
                this.state = 3378;
                this.expression();
                }
                break;
            case 20:
                {
                this.state = 3380;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3381;
                this.identifier();
                this.state = 3384;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                do {
                    {
                    {
                    this.state = 3382;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3383;
                    this.identifier();
                    }
                    }
                    this.state = 3386;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                } while (_la === 4);
                this.state = 3388;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 3389;
                this.match(SparkSqlParser.ARROW);
                this.state = 3390;
                this.expression();
                }
                break;
            case 21:
                {
                this.state = 3392;
                this.identifier();
                }
                break;
            case 22:
                {
                this.state = 3393;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3394;
                this.expression();
                this.state = 3395;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 23:
                {
                this.state = 3397;
                this.match(SparkSqlParser.KW_EXTRACT);
                this.state = 3398;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3399;
                localContext._field = this.identifier();
                this.state = 3400;
                this.match(SparkSqlParser.KW_FROM);
                this.state = 3401;
                localContext._source = this.valueExpression(0);
                this.state = 3402;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 24:
                {
                this.state = 3404;
                _la = this.tokenStream.LA(1);
                if(!(_la === 287 || _la === 288)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3405;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3406;
                localContext._str = this.valueExpression(0);
                this.state = 3407;
                _la = this.tokenStream.LA(1);
                if(!(_la === 4 || _la === 123)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3408;
                localContext._pos = this.valueExpression(0);
                this.state = 3411;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 4 || _la === 119) {
                    {
                    this.state = 3409;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 4 || _la === 119)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    this.state = 3410;
                    localContext._len = this.valueExpression(0);
                    }
                }

                this.state = 3413;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 25:
                {
                this.state = 3415;
                this.match(SparkSqlParser.KW_TRIM);
                this.state = 3416;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3418;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 444, this.context) ) {
                case 1:
                    {
                    this.state = 3417;
                    localContext._trimOption = this.tokenStream.LT(1);
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 28 || _la === 160 || _la === 311)) {
                        localContext._trimOption = this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    }
                    break;
                }
                this.state = 3421;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967044) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 361)) & ~0x1F) === 0 && ((1 << (_la - 361)) & 536839207) !== 0)) {
                    {
                    this.state = 3420;
                    localContext._trimStr = this.valueExpression(0);
                    }
                }

                this.state = 3423;
                this.match(SparkSqlParser.KW_FROM);
                this.state = 3424;
                localContext._srcStr = this.valueExpression(0);
                this.state = 3425;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 26:
                {
                this.state = 3427;
                this.match(SparkSqlParser.KW_OVERLAY);
                this.state = 3428;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3429;
                localContext._input = this.valueExpression(0);
                this.state = 3430;
                this.match(SparkSqlParser.KW_PLACING);
                this.state = 3431;
                localContext._replace = this.valueExpression(0);
                this.state = 3432;
                this.match(SparkSqlParser.KW_FROM);
                this.state = 3433;
                localContext._position = this.valueExpression(0);
                this.state = 3436;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 119) {
                    {
                    this.state = 3434;
                    this.match(SparkSqlParser.KW_FOR);
                    this.state = 3435;
                    localContext._length = this.valueExpression(0);
                    }
                }

                this.state = 3438;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 27:
                {
                this.state = 3440;
                localContext._name = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 220 || _la === 221)) {
                    localContext._name = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3441;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3442;
                localContext._percentage = this.valueExpression(0);
                this.state = 3443;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 3444;
                this.match(SparkSqlParser.KW_WITHIN);
                this.state = 3445;
                this.match(SparkSqlParser.KW_GROUP);
                this.state = 3446;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3447;
                this.match(SparkSqlParser.KW_ORDER);
                this.state = 3448;
                this.match(SparkSqlParser.KW_BY);
                this.state = 3449;
                this.sortItem();
                this.state = 3450;
                this.match(SparkSqlParser.RIGHT_PAREN);
                this.state = 3457;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 447, this.context) ) {
                case 1:
                    {
                    this.state = 3451;
                    this.match(SparkSqlParser.KW_FILTER);
                    this.state = 3452;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 3453;
                    this.match(SparkSqlParser.KW_WHERE);
                    this.state = 3454;
                    localContext._where = this.booleanExpression(0);
                    this.state = 3455;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                this.state = 3461;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 448, this.context) ) {
                case 1:
                    {
                    this.state = 3459;
                    this.match(SparkSqlParser.KW_OVER);
                    this.state = 3460;
                    this.windowSpec();
                    }
                    break;
                }
                }
                break;
            }
            this.context!.stop = this.tokenStream.LT(-1);
            this.state = 3475;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 451, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    if (this._parseListeners != null) {
                        this.triggerExitRuleEvent();
                    }
                    previousContext = localContext;
                    {
                    this.state = 3473;
                    this.errorHandler.sync(this);
                    switch (this.interpreter.adaptivePredict(this.tokenStream, 450, this.context) ) {
                    case 1:
                        {
                        localContext = new PrimaryExpressionContext(parentContext, parentState);
                        localContext._value = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_primaryExpression);
                        this.state = 3465;
                        if (!(this.precpred(this.context, 9))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 9)");
                        }
                        this.state = 3466;
                        this.match(SparkSqlParser.LEFT_BRACKET);
                        this.state = 3467;
                        localContext._index = this.valueExpression(0);
                        this.state = 3468;
                        this.match(SparkSqlParser.RIGHT_BRACKET);
                        }
                        break;
                    case 2:
                        {
                        localContext = new PrimaryExpressionContext(parentContext, parentState);
                        localContext._base = previousContext;
                        this.pushNewRecursionContext(localContext, _startState, SparkSqlParser.RULE_primaryExpression);
                        this.state = 3470;
                        if (!(this.precpred(this.context, 7))) {
                            throw this.createFailedPredicateException("this.precpred(this.context, 7)");
                        }
                        this.state = 3471;
                        this.match(SparkSqlParser.DOT);
                        this.state = 3472;
                        localContext._fieldName = this.identifier();
                        }
                        break;
                    }
                    }
                }
                this.state = 3477;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 451, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.unrollRecursionContexts(parentContext);
        }
        return localContext;
    }
    public literalType(): LiteralTypeContext {
        let localContext = new LiteralTypeContext(this.context, this.state);
        this.enterRule(localContext, 286, SparkSqlParser.RULE_literalType);
        try {
            this.state = 3485;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 452, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3478;
                this.match(SparkSqlParser.KW_DATE);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3479;
                this.match(SparkSqlParser.KW_TIMESTAMP);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3480;
                this.match(SparkSqlParser.KW_TIMESTAMP_LTZ);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3481;
                this.match(SparkSqlParser.KW_TIMESTAMP_NTZ);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3482;
                this.match(SparkSqlParser.KW_INTERVAL);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3483;
                this.match(SparkSqlParser.KW_BINARY_HEX);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3484;
                localContext._unsupportedType = this.identifier();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public constant(): ConstantContext {
        let localContext = new ConstantContext(this.context, this.state);
        this.enterRule(localContext, 288, SparkSqlParser.RULE_constant);
        try {
            let alternative: number;
            this.state = 3502;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 454, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3487;
                this.match(SparkSqlParser.KW_NULL);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3488;
                this.match(SparkSqlParser.QUESTION);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3489;
                this.match(SparkSqlParser.COLON);
                this.state = 3490;
                this.identifier();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3491;
                this.interval();
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3492;
                this.literalType();
                this.state = 3493;
                this.stringLit();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3495;
                this.number_();
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3496;
                this.booleanValue();
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 3498;
                this.errorHandler.sync(this);
                alternative = 1;
                do {
                    switch (alternative) {
                    case 1:
                        {
                        {
                        this.state = 3497;
                        this.stringLit();
                        }
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    this.state = 3500;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 453, this.context);
                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public comparisonOperator(): ComparisonOperatorContext {
        let localContext = new ComparisonOperatorContext(this.context, this.state);
        this.enterRule(localContext, 290, SparkSqlParser.RULE_comparisonOperator);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3504;
            _la = this.tokenStream.LA(1);
            if(!(((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & 255) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public arithmeticOperator(): ArithmeticOperatorContext {
        let localContext = new ArithmeticOperatorContext(this.context, this.state);
        this.enterRule(localContext, 292, SparkSqlParser.RULE_arithmeticOperator);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3506;
            _la = this.tokenStream.LA(1);
            if(!(_la === 94 || ((((_la - 361)) & ~0x1F) === 0 && ((1 << (_la - 361)) & 1023) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public predicateOperator(): PredicateOperatorContext {
        let localContext = new PredicateOperatorContext(this.context, this.state);
        this.enterRule(localContext, 294, SparkSqlParser.RULE_predicateOperator);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3508;
            _la = this.tokenStream.LA(1);
            if(!(_la === 14 || _la === 140 || _la === 197 || _la === 208)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public booleanValue(): BooleanValueContext {
        let localContext = new BooleanValueContext(this.context, this.state);
        this.enterRule(localContext, 296, SparkSqlParser.RULE_booleanValue);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3510;
            _la = this.tokenStream.LA(1);
            if(!(_la === 111 || _la === 316)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public interval(): IntervalContext {
        let localContext = new IntervalContext(this.context, this.state);
        this.enterRule(localContext, 298, SparkSqlParser.RULE_interval);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3512;
            this.match(SparkSqlParser.KW_INTERVAL);
            this.state = 3515;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 455, this.context) ) {
            case 1:
                {
                this.state = 3513;
                this.errorCapturingMultiUnitsInterval();
                }
                break;
            case 2:
                {
                this.state = 3514;
                this.errorCapturingUnitToUnitInterval();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public errorCapturingMultiUnitsInterval(): ErrorCapturingMultiUnitsIntervalContext {
        let localContext = new ErrorCapturingMultiUnitsIntervalContext(this.context, this.state);
        this.enterRule(localContext, 300, SparkSqlParser.RULE_errorCapturingMultiUnitsInterval);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3517;
            localContext._body = this.multiUnitsInterval();
            this.state = 3519;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 456, this.context) ) {
            case 1:
                {
                this.state = 3518;
                this.unitToUnitInterval();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public multiUnitsInterval(): MultiUnitsIntervalContext {
        let localContext = new MultiUnitsIntervalContext(this.context, this.state);
        this.enterRule(localContext, 302, SparkSqlParser.RULE_multiUnitsInterval);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3524;
            this.errorHandler.sync(this);
            alternative = 1;
            do {
                switch (alternative) {
                case 1:
                    {
                    {
                    this.state = 3521;
                    this.intervalValue();
                    this.state = 3522;
                    localContext._unitInMultiUnits = this.unitInMultiUnits();
                    localContext._unit.push(localContext._unitInMultiUnits);
                    }
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3526;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 457, this.context);
            } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public errorCapturingUnitToUnitInterval(): ErrorCapturingUnitToUnitIntervalContext {
        let localContext = new ErrorCapturingUnitToUnitIntervalContext(this.context, this.state);
        this.enterRule(localContext, 304, SparkSqlParser.RULE_errorCapturingUnitToUnitInterval);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3528;
            localContext._body = this.unitToUnitInterval();
            this.state = 3531;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 458, this.context) ) {
            case 1:
                {
                this.state = 3529;
                localContext._error1 = this.multiUnitsInterval();
                }
                break;
            case 2:
                {
                this.state = 3530;
                localContext._error2 = this.unitToUnitInterval();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unitToUnitInterval(): UnitToUnitIntervalContext {
        let localContext = new UnitToUnitIntervalContext(this.context, this.state);
        this.enterRule(localContext, 306, SparkSqlParser.RULE_unitToUnitInterval);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3533;
            localContext._value = this.intervalValue();
            this.state = 3534;
            this.unitInUnitToUnit();
            this.state = 3535;
            this.match(SparkSqlParser.KW_TO);
            this.state = 3536;
            this.unitInUnitToUnit();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public intervalValue(): IntervalValueContext {
        let localContext = new IntervalValueContext(this.context, this.state);
        this.enterRule(localContext, 308, SparkSqlParser.RULE_intervalValue);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3539;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 361 || _la === 362) {
                {
                this.state = 3538;
                _la = this.tokenStream.LA(1);
                if(!(_la === 361 || _la === 362)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
            }

            this.state = 3544;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.INTEGER_VALUE:
                {
                this.state = 3541;
                this.match(SparkSqlParser.INTEGER_VALUE);
                }
                break;
            case SparkSqlParser.DECIMAL_VALUE:
                {
                this.state = 3542;
                this.match(SparkSqlParser.DECIMAL_VALUE);
                }
                break;
            case SparkSqlParser.STRING_LITERAL:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
                {
                this.state = 3543;
                this.stringLit();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unitInMultiUnits(): UnitInMultiUnitsContext {
        let localContext = new UnitInMultiUnitsContext(this.context, this.state);
        this.enterRule(localContext, 310, SparkSqlParser.RULE_unitInMultiUnits);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3546;
            _la = this.tokenStream.LA(1);
            if(!(_la === 67 || _la === 68 || _la === 134 || _la === 135 || ((((_la - 180)) & ~0x1F) === 0 && ((1 << (_la - 180)) & 12543) !== 0) || _la === 259 || _la === 260 || ((((_la - 341)) & ~0x1F) === 0 && ((1 << (_la - 341)) & 387) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public unitInUnitToUnit(): UnitInUnitToUnitContext {
        let localContext = new UnitInUnitToUnitContext(this.context, this.state);
        this.enterRule(localContext, 312, SparkSqlParser.RULE_unitInUnitToUnit);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3548;
            _la = this.tokenStream.LA(1);
            if(!(_la === 67 || _la === 134 || _la === 184 || _la === 186 || _la === 259 || _la === 348)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public colPosition(): ColPositionContext {
        let localContext = new ColPositionContext(this.context, this.state);
        this.enterRule(localContext, 314, SparkSqlParser.RULE_colPosition);
        try {
            this.state = 3553;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_FIRST:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3550;
                localContext._position = this.match(SparkSqlParser.KW_FIRST);
                }
                break;
            case SparkSqlParser.KW_AFTER:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3551;
                localContext._position = this.match(SparkSqlParser.KW_AFTER);
                this.state = 3552;
                localContext._afterCol = this.errorCapturingIdentifier();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public type_(): TypeContext {
        let localContext = new TypeContext(this.context, this.state);
        this.enterRule(localContext, 316, SparkSqlParser.RULE_type);
        try {
            this.state = 3585;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 462, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3555;
                this.match(SparkSqlParser.KW_BOOLEAN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3556;
                this.match(SparkSqlParser.KW_TINYINT);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3557;
                this.match(SparkSqlParser.KW_BYTE);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3558;
                this.match(SparkSqlParser.KW_SMALLINT);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3559;
                this.match(SparkSqlParser.KW_SHORT);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3560;
                this.match(SparkSqlParser.KW_INT);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3561;
                this.match(SparkSqlParser.KW_INTEGER);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 3562;
                this.match(SparkSqlParser.KW_BIGINT);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 3563;
                this.match(SparkSqlParser.KW_LONG);
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 3564;
                this.match(SparkSqlParser.KW_FLOAT);
                }
                break;
            case 11:
                this.enterOuterAlt(localContext, 11);
                {
                this.state = 3565;
                this.match(SparkSqlParser.KW_REAL);
                }
                break;
            case 12:
                this.enterOuterAlt(localContext, 12);
                {
                this.state = 3566;
                this.match(SparkSqlParser.KW_DOUBLE);
                }
                break;
            case 13:
                this.enterOuterAlt(localContext, 13);
                {
                this.state = 3567;
                this.match(SparkSqlParser.KW_DATE);
                }
                break;
            case 14:
                this.enterOuterAlt(localContext, 14);
                {
                this.state = 3568;
                this.match(SparkSqlParser.KW_TIMESTAMP);
                }
                break;
            case 15:
                this.enterOuterAlt(localContext, 15);
                {
                this.state = 3569;
                this.match(SparkSqlParser.KW_TIMESTAMP_NTZ);
                }
                break;
            case 16:
                this.enterOuterAlt(localContext, 16);
                {
                this.state = 3570;
                this.match(SparkSqlParser.KW_TIMESTAMP_LTZ);
                }
                break;
            case 17:
                this.enterOuterAlt(localContext, 17);
                {
                this.state = 3571;
                this.match(SparkSqlParser.KW_STRING);
                }
                break;
            case 18:
                this.enterOuterAlt(localContext, 18);
                {
                this.state = 3572;
                this.match(SparkSqlParser.KW_CHARACTER);
                }
                break;
            case 19:
                this.enterOuterAlt(localContext, 19);
                {
                this.state = 3573;
                this.match(SparkSqlParser.KW_CHAR);
                }
                break;
            case 20:
                this.enterOuterAlt(localContext, 20);
                {
                this.state = 3574;
                this.match(SparkSqlParser.KW_VARCHAR);
                }
                break;
            case 21:
                this.enterOuterAlt(localContext, 21);
                {
                this.state = 3575;
                this.match(SparkSqlParser.KW_BINARY);
                }
                break;
            case 22:
                this.enterOuterAlt(localContext, 22);
                {
                this.state = 3576;
                this.match(SparkSqlParser.KW_DECIMAL);
                }
                break;
            case 23:
                this.enterOuterAlt(localContext, 23);
                {
                this.state = 3577;
                this.match(SparkSqlParser.KW_DEC);
                }
                break;
            case 24:
                this.enterOuterAlt(localContext, 24);
                {
                this.state = 3578;
                this.match(SparkSqlParser.KW_NUMERIC);
                }
                break;
            case 25:
                this.enterOuterAlt(localContext, 25);
                {
                this.state = 3579;
                this.match(SparkSqlParser.KW_VOID);
                }
                break;
            case 26:
                this.enterOuterAlt(localContext, 26);
                {
                this.state = 3580;
                this.match(SparkSqlParser.KW_INTERVAL);
                }
                break;
            case 27:
                this.enterOuterAlt(localContext, 27);
                {
                this.state = 3581;
                this.match(SparkSqlParser.KW_ARRAY);
                }
                break;
            case 28:
                this.enterOuterAlt(localContext, 28);
                {
                this.state = 3582;
                this.match(SparkSqlParser.KW_STRUCT);
                }
                break;
            case 29:
                this.enterOuterAlt(localContext, 29);
                {
                this.state = 3583;
                this.match(SparkSqlParser.KW_MAP);
                }
                break;
            case 30:
                this.enterOuterAlt(localContext, 30);
                {
                this.state = 3584;
                localContext._unsupportedType = this.identifier();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public dataType(): DataTypeContext {
        let localContext = new DataTypeContext(this.context, this.state);
        this.enterRule(localContext, 318, SparkSqlParser.RULE_dataType);
        let _la: number;
        try {
            this.state = 3633;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 469, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3587;
                localContext._complex = this.match(SparkSqlParser.KW_ARRAY);
                this.state = 3588;
                this.match(SparkSqlParser.LT);
                this.state = 3589;
                this.dataType();
                this.state = 3590;
                this.match(SparkSqlParser.GT);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3592;
                localContext._complex = this.match(SparkSqlParser.KW_MAP);
                this.state = 3593;
                this.match(SparkSqlParser.LT);
                this.state = 3594;
                this.dataType();
                this.state = 3595;
                this.match(SparkSqlParser.COMMA);
                this.state = 3596;
                this.dataType();
                this.state = 3597;
                this.match(SparkSqlParser.GT);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3599;
                localContext._complex = this.match(SparkSqlParser.KW_STRUCT);
                this.state = 3606;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.LT:
                    {
                    this.state = 3600;
                    this.match(SparkSqlParser.LT);
                    this.state = 3602;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if ((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294967040) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4294967295) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 4160749567) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 4294967295) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967295) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294967279) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4294967295) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294967167) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294967295) !== 0) || ((((_la - 378)) & ~0x1F) === 0 && ((1 << (_la - 378)) & 3073) !== 0)) {
                        {
                        this.state = 3601;
                        this.complexColTypeList();
                        }
                    }

                    this.state = 3604;
                    this.match(SparkSqlParser.GT);
                    }
                    break;
                case SparkSqlParser.NEQ:
                    {
                    this.state = 3605;
                    this.match(SparkSqlParser.NEQ);
                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3608;
                this.match(SparkSqlParser.KW_INTERVAL);
                this.state = 3609;
                _la = this.tokenStream.LA(1);
                if(!(_la === 186 || _la === 348)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3612;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 465, this.context) ) {
                case 1:
                    {
                    this.state = 3610;
                    this.match(SparkSqlParser.KW_TO);
                    this.state = 3611;
                    this.match(SparkSqlParser.KW_MONTH);
                    }
                    break;
                }
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3614;
                this.match(SparkSqlParser.KW_INTERVAL);
                this.state = 3615;
                _la = this.tokenStream.LA(1);
                if(!(_la === 67 || _la === 134 || _la === 184 || _la === 259)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3618;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 466, this.context) ) {
                case 1:
                    {
                    this.state = 3616;
                    this.match(SparkSqlParser.KW_TO);
                    this.state = 3617;
                    _la = this.tokenStream.LA(1);
                    if(!(_la === 134 || _la === 184 || _la === 259)) {
                    this.errorHandler.recoverInline(this);
                    }
                    else {
                        this.errorHandler.reportMatch(this);
                        this.consume();
                    }
                    }
                    break;
                }
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3620;
                this.type_();
                this.state = 3631;
                this.errorHandler.sync(this);
                switch (this.interpreter.adaptivePredict(this.tokenStream, 468, this.context) ) {
                case 1:
                    {
                    this.state = 3621;
                    this.match(SparkSqlParser.LEFT_PAREN);
                    this.state = 3622;
                    this.match(SparkSqlParser.INTEGER_VALUE);
                    this.state = 3627;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 3623;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 3624;
                        this.match(SparkSqlParser.INTEGER_VALUE);
                        }
                        }
                        this.state = 3629;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                    }
                    this.state = 3630;
                    this.match(SparkSqlParser.RIGHT_PAREN);
                    }
                    break;
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public qualifiedColTypeWithPositionSeqForAdd(): QualifiedColTypeWithPositionSeqForAddContext {
        let localContext = new QualifiedColTypeWithPositionSeqForAddContext(this.context, this.state);
        this.enterRule(localContext, 320, SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForAdd);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3635;
            this.qualifiedColTypeWithPositionForAdd();
            this.state = 3640;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3636;
                this.match(SparkSqlParser.COMMA);
                this.state = 3637;
                this.qualifiedColTypeWithPositionForAdd();
                }
                }
                this.state = 3642;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext {
        let localContext = new QualifiedColTypeWithPositionForAddContext(this.context, this.state);
        this.enterRule(localContext, 322, SparkSqlParser.RULE_qualifiedColTypeWithPositionForAdd);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3643;
            localContext._name = this.columnNameCreate();
            this.state = 3644;
            this.dataType();
            this.state = 3648;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 471, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 3645;
                    this.colDefinitionDescriptorWithPosition();
                    }
                    }
                }
                this.state = 3650;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 471, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public qualifiedColTypeWithPositionSeqForReplace(): QualifiedColTypeWithPositionSeqForReplaceContext {
        let localContext = new QualifiedColTypeWithPositionSeqForReplaceContext(this.context, this.state);
        this.enterRule(localContext, 324, SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForReplace);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3651;
            this.qualifiedColTypeWithPositionForReplace();
            this.state = 3656;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3652;
                this.match(SparkSqlParser.COMMA);
                this.state = 3653;
                this.qualifiedColTypeWithPositionForReplace();
                }
                }
                this.state = 3658;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public qualifiedColTypeWithPositionForReplace(): QualifiedColTypeWithPositionForReplaceContext {
        let localContext = new QualifiedColTypeWithPositionForReplaceContext(this.context, this.state);
        this.enterRule(localContext, 326, SparkSqlParser.RULE_qualifiedColTypeWithPositionForReplace);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3659;
            localContext._name = this.columnName();
            this.state = 3660;
            this.dataType();
            this.state = 3664;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 9 || _la === 51 || _la === 82 || _la === 116 || _la === 197) {
                {
                {
                this.state = 3661;
                this.colDefinitionDescriptorWithPosition();
                }
                }
                this.state = 3666;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext {
        let localContext = new ColDefinitionDescriptorWithPositionContext(this.context, this.state);
        this.enterRule(localContext, 328, SparkSqlParser.RULE_colDefinitionDescriptorWithPosition);
        try {
            this.state = 3672;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_NOT:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3667;
                this.match(SparkSqlParser.KW_NOT);
                this.state = 3668;
                this.match(SparkSqlParser.KW_NULL);
                }
                break;
            case SparkSqlParser.KW_DEFAULT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3669;
                this.defaultExpression();
                }
                break;
            case SparkSqlParser.KW_COMMENT:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3670;
                this.commentSpec();
                }
                break;
            case SparkSqlParser.KW_AFTER:
            case SparkSqlParser.KW_FIRST:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3671;
                this.colPosition();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public defaultExpression(): DefaultExpressionContext {
        let localContext = new DefaultExpressionContext(this.context, this.state);
        this.enterRule(localContext, 330, SparkSqlParser.RULE_defaultExpression);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3674;
            this.match(SparkSqlParser.KW_DEFAULT);
            this.state = 3675;
            this.expression();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public variableDefaultExpression(): VariableDefaultExpressionContext {
        let localContext = new VariableDefaultExpressionContext(this.context, this.state);
        this.enterRule(localContext, 332, SparkSqlParser.RULE_variableDefaultExpression);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3677;
            _la = this.tokenStream.LA(1);
            if(!(_la === 82 || _la === 352)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            this.state = 3678;
            this.expression();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public colTypeList(): ColTypeListContext {
        let localContext = new ColTypeListContext(this.context, this.state);
        this.enterRule(localContext, 334, SparkSqlParser.RULE_colTypeList);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3680;
            this.colType();
            this.state = 3685;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 475, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 3681;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3682;
                    this.colType();
                    }
                    }
                }
                this.state = 3687;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 475, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public colType(): ColTypeContext {
        let localContext = new ColTypeContext(this.context, this.state);
        this.enterRule(localContext, 336, SparkSqlParser.RULE_colType);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3688;
            localContext._colName = this.errorCapturingIdentifier();
            this.state = 3689;
            this.dataType();
            this.state = 3692;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 476, this.context) ) {
            case 1:
                {
                this.state = 3690;
                this.match(SparkSqlParser.KW_NOT);
                this.state = 3691;
                this.match(SparkSqlParser.KW_NULL);
                }
                break;
            }
            this.state = 3695;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 477, this.context) ) {
            case 1:
                {
                this.state = 3694;
                this.commentSpec();
                }
                break;
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext {
        let localContext = new CreateOrReplaceTableColTypeListContext(this.context, this.state);
        this.enterRule(localContext, 338, SparkSqlParser.RULE_createOrReplaceTableColTypeList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3697;
            this.createOrReplaceTableColType();
            this.state = 3702;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3698;
                this.match(SparkSqlParser.COMMA);
                this.state = 3699;
                this.createOrReplaceTableColType();
                }
                }
                this.state = 3704;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext {
        let localContext = new CreateOrReplaceTableColTypeContext(this.context, this.state);
        this.enterRule(localContext, 340, SparkSqlParser.RULE_createOrReplaceTableColType);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3705;
            localContext._colName = this.columnNameCreate();
            this.state = 3706;
            this.dataType();
            this.state = 3710;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 51 || _la === 82 || _la === 127 || _la === 197) {
                {
                {
                this.state = 3707;
                this.colDefinitionOption();
                }
                }
                this.state = 3712;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public colDefinitionOption(): ColDefinitionOptionContext {
        let localContext = new ColDefinitionOptionContext(this.context, this.state);
        this.enterRule(localContext, 342, SparkSqlParser.RULE_colDefinitionOption);
        try {
            this.state = 3718;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.KW_NOT:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3713;
                this.match(SparkSqlParser.KW_NOT);
                this.state = 3714;
                this.match(SparkSqlParser.KW_NULL);
                }
                break;
            case SparkSqlParser.KW_DEFAULT:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3715;
                this.defaultExpression();
                }
                break;
            case SparkSqlParser.KW_GENERATED:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3716;
                this.generationExpression();
                }
                break;
            case SparkSqlParser.KW_COMMENT:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3717;
                this.commentSpec();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public generationExpression(): GenerationExpressionContext {
        let localContext = new GenerationExpressionContext(this.context, this.state);
        this.enterRule(localContext, 344, SparkSqlParser.RULE_generationExpression);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3720;
            this.match(SparkSqlParser.KW_GENERATED);
            this.state = 3721;
            this.match(SparkSqlParser.KW_ALWAYS);
            this.state = 3722;
            this.match(SparkSqlParser.KW_AS);
            this.state = 3723;
            this.match(SparkSqlParser.LEFT_PAREN);
            this.state = 3724;
            this.expression();
            this.state = 3725;
            this.match(SparkSqlParser.RIGHT_PAREN);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public complexColTypeList(): ComplexColTypeListContext {
        let localContext = new ComplexColTypeListContext(this.context, this.state);
        this.enterRule(localContext, 346, SparkSqlParser.RULE_complexColTypeList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3727;
            this.complexColType();
            this.state = 3732;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3728;
                this.match(SparkSqlParser.COMMA);
                this.state = 3729;
                this.complexColType();
                }
                }
                this.state = 3734;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public complexColType(): ComplexColTypeContext {
        let localContext = new ComplexColTypeContext(this.context, this.state);
        this.enterRule(localContext, 348, SparkSqlParser.RULE_complexColType);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3735;
            this.identifier();
            this.state = 3737;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 371) {
                {
                this.state = 3736;
                this.match(SparkSqlParser.COLON);
                }
            }

            this.state = 3739;
            this.dataType();
            this.state = 3742;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 197) {
                {
                this.state = 3740;
                this.match(SparkSqlParser.KW_NOT);
                this.state = 3741;
                this.match(SparkSqlParser.KW_NULL);
                }
            }

            this.state = 3745;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            if (_la === 51) {
                {
                this.state = 3744;
                this.commentSpec();
                }
            }

            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public whenClause(): WhenClauseContext {
        let localContext = new WhenClauseContext(this.context, this.state);
        this.enterRule(localContext, 350, SparkSqlParser.RULE_whenClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3747;
            this.match(SparkSqlParser.KW_WHEN);
            this.state = 3748;
            localContext._condition = this.expression();
            this.state = 3749;
            this.match(SparkSqlParser.KW_THEN);
            this.state = 3750;
            localContext._result = this.expression();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public windowClause(): WindowClauseContext {
        let localContext = new WindowClauseContext(this.context, this.state);
        this.enterRule(localContext, 352, SparkSqlParser.RULE_windowClause);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3752;
            this.match(SparkSqlParser.KW_WINDOW);
            this.state = 3753;
            this.namedWindow();
            this.state = 3758;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 485, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 3754;
                    this.match(SparkSqlParser.COMMA);
                    this.state = 3755;
                    this.namedWindow();
                    }
                    }
                }
                this.state = 3760;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 485, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public zorderClause(): ZorderClauseContext {
        let localContext = new ZorderClauseContext(this.context, this.state);
        this.enterRule(localContext, 354, SparkSqlParser.RULE_zorderClause);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3761;
            this.match(SparkSqlParser.KW_ZORDER);
            this.state = 3762;
            this.match(SparkSqlParser.KW_BY);
            this.state = 3763;
            this.columnNameSeq();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public namedWindow(): NamedWindowContext {
        let localContext = new NamedWindowContext(this.context, this.state);
        this.enterRule(localContext, 356, SparkSqlParser.RULE_namedWindow);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3765;
            localContext._name = this.errorCapturingIdentifier();
            this.state = 3766;
            this.match(SparkSqlParser.KW_AS);
            this.state = 3767;
            this.windowSpec();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public windowSpec(): WindowSpecContext {
        let localContext = new WindowSpecContext(this.context, this.state);
        this.enterRule(localContext, 358, SparkSqlParser.RULE_windowSpec);
        let _la: number;
        try {
            this.state = 3815;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 493, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3769;
                localContext._name = this.errorCapturingIdentifier();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3770;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3771;
                localContext._name = this.errorCapturingIdentifier();
                this.state = 3772;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3774;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3809;
                this.errorHandler.sync(this);
                switch (this.tokenStream.LA(1)) {
                case SparkSqlParser.KW_CLUSTER:
                    {
                    this.state = 3775;
                    this.match(SparkSqlParser.KW_CLUSTER);
                    this.state = 3776;
                    this.match(SparkSqlParser.KW_BY);
                    this.state = 3777;
                    localContext._expression = this.expression();
                    localContext._partition.push(localContext._expression);
                    this.state = 3782;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    while (_la === 4) {
                        {
                        {
                        this.state = 3778;
                        this.match(SparkSqlParser.COMMA);
                        this.state = 3779;
                        localContext._expression = this.expression();
                        localContext._partition.push(localContext._expression);
                        }
                        }
                        this.state = 3784;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.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 = 3795;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 93 || _la === 217) {
                        {
                        this.state = 3785;
                        _la = this.tokenStream.LA(1);
                        if(!(_la === 93 || _la === 217)) {
                        this.errorHandler.recoverInline(this);
                        }
                        else {
                            this.errorHandler.reportMatch(this);
                            this.consume();
                        }
                        this.state = 3786;
                        this.match(SparkSqlParser.KW_BY);
                        this.state = 3787;
                        localContext._expression = this.expression();
                        localContext._partition.push(localContext._expression);
                        this.state = 3792;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                        while (_la === 4) {
                            {
                            {
                            this.state = 3788;
                            this.match(SparkSqlParser.COMMA);
                            this.state = 3789;
                            localContext._expression = this.expression();
                            localContext._partition.push(localContext._expression);
                            }
                            }
                            this.state = 3794;
                            this.errorHandler.sync(this);
                            _la = this.tokenStream.LA(1);
                        }
                        }
                    }

                    this.state = 3807;
                    this.errorHandler.sync(this);
                    _la = this.tokenStream.LA(1);
                    if (_la === 209 || _la === 278) {
                        {
                        this.state = 3797;
                        _la = this.tokenStream.LA(1);
                        if(!(_la === 209 || _la === 278)) {
                        this.errorHandler.recoverInline(this);
                        }
                        else {
                            this.errorHandler.reportMatch(this);
                            this.consume();
                        }
                        this.state = 3798;
                        this.match(SparkSqlParser.KW_BY);
                        this.state = 3799;
                        this.sortItem();
                        this.state = 3804;
                        this.errorHandler.sync(this);
                        _la = this.tokenStream.LA(1);
                        while (_la === 4) {
                            {
                            {
                            this.state = 3800;
                            this.match(SparkSqlParser.COMMA);
                            this.state = 3801;
                            this.sortItem();
                            }
                            }
                            this.state = 3806;
                            this.errorHandler.sync(this);
                            _la = this.tokenStream.LA(1);
                        }
                        }
                    }

                    }
                    break;
                default:
                    throw new antlr.NoViableAltException(this);
                }
                this.state = 3812;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 233 || _la === 258) {
                    {
                    this.state = 3811;
                    this.windowFrame();
                    }
                }

                this.state = 3814;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public windowFrame(): WindowFrameContext {
        let localContext = new WindowFrameContext(this.context, this.state);
        this.enterRule(localContext, 360, SparkSqlParser.RULE_windowFrame);
        try {
            this.state = 3833;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 494, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3817;
                localContext._frameType = this.match(SparkSqlParser.KW_RANGE);
                this.state = 3818;
                localContext._start_ = this.frameBound();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3819;
                localContext._frameType = this.match(SparkSqlParser.KW_ROWS);
                this.state = 3820;
                localContext._start_ = this.frameBound();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3821;
                localContext._frameType = this.match(SparkSqlParser.KW_RANGE);
                this.state = 3822;
                this.match(SparkSqlParser.KW_BETWEEN);
                this.state = 3823;
                localContext._start_ = this.frameBound();
                this.state = 3824;
                this.match(SparkSqlParser.KW_AND);
                this.state = 3825;
                localContext._end = this.frameBound();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3827;
                localContext._frameType = this.match(SparkSqlParser.KW_ROWS);
                this.state = 3828;
                this.match(SparkSqlParser.KW_BETWEEN);
                this.state = 3829;
                localContext._start_ = this.frameBound();
                this.state = 3830;
                this.match(SparkSqlParser.KW_AND);
                this.state = 3831;
                localContext._end = this.frameBound();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public frameBound(): FrameBoundContext {
        let localContext = new FrameBoundContext(this.context, this.state);
        this.enterRule(localContext, 362, SparkSqlParser.RULE_frameBound);
        let _la: number;
        try {
            this.state = 3842;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 495, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3835;
                this.match(SparkSqlParser.KW_UNBOUNDED);
                this.state = 3836;
                localContext._boundType = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 118 || _la === 226)) {
                    localContext._boundType = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3837;
                localContext._boundType = this.match(SparkSqlParser.KW_CURRENT);
                this.state = 3838;
                this.match(SparkSqlParser.KW_ROW);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3839;
                this.expression();
                this.state = 3840;
                localContext._boundType = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 118 || _la === 226)) {
                    localContext._boundType = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public qualifiedNameList(): QualifiedNameListContext {
        let localContext = new QualifiedNameListContext(this.context, this.state);
        this.enterRule(localContext, 364, SparkSqlParser.RULE_qualifiedNameList);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3844;
            this.qualifiedName();
            this.state = 3849;
            this.errorHandler.sync(this);
            _la = this.tokenStream.LA(1);
            while (_la === 4) {
                {
                {
                this.state = 3845;
                this.match(SparkSqlParser.COMMA);
                this.state = 3846;
                this.qualifiedName();
                }
                }
                this.state = 3851;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionName(): FunctionNameContext {
        let localContext = new FunctionNameContext(this.context, this.state);
        this.enterRule(localContext, 366, SparkSqlParser.RULE_functionName);
        try {
            this.state = 3861;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 497, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3852;
                this.match(SparkSqlParser.KW_IDENTIFIER);
                this.state = 3853;
                this.match(SparkSqlParser.LEFT_PAREN);
                this.state = 3854;
                this.expression();
                this.state = 3855;
                this.match(SparkSqlParser.RIGHT_PAREN);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3857;
                this.qualifiedName();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3858;
                this.match(SparkSqlParser.KW_FILTER);
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3859;
                this.match(SparkSqlParser.KW_LEFT);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3860;
                this.match(SparkSqlParser.KW_RIGHT);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public functionNameCreate(): FunctionNameCreateContext {
        let localContext = new FunctionNameCreateContext(this.context, this.state);
        this.enterRule(localContext, 368, SparkSqlParser.RULE_functionNameCreate);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3863;
            this.qualifiedName();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public qualifiedName(): QualifiedNameContext {
        let localContext = new QualifiedNameContext(this.context, this.state);
        this.enterRule(localContext, 370, SparkSqlParser.RULE_qualifiedName);
        try {
            let alternative: number;
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3865;
            this.identifier();
            this.state = 3870;
            this.errorHandler.sync(this);
            alternative = this.interpreter.adaptivePredict(this.tokenStream, 498, this.context);
            while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER) {
                if (alternative === 1) {
                    {
                    {
                    this.state = 3866;
                    this.match(SparkSqlParser.DOT);
                    this.state = 3867;
                    this.identifier();
                    }
                    }
                }
                this.state = 3872;
                this.errorHandler.sync(this);
                alternative = this.interpreter.adaptivePredict(this.tokenStream, 498, this.context);
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public errorCapturingIdentifier(): ErrorCapturingIdentifierContext {
        let localContext = new ErrorCapturingIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 372, SparkSqlParser.RULE_errorCapturingIdentifier);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3873;
            this.identifier();
            this.state = 3874;
            this.errorCapturingIdentifierExtra();
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public errorCapturingIdentifierExtra(): ErrorCapturingIdentifierExtraContext {
        let localContext = new ErrorCapturingIdentifierExtraContext(this.context, this.state);
        this.enterRule(localContext, 374, SparkSqlParser.RULE_errorCapturingIdentifierExtra);
        try {
            let alternative: number;
            this.state = 3883;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 500, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3878;
                this.errorHandler.sync(this);
                alternative = 1;
                do {
                    switch (alternative) {
                    case 1:
                        {
                        {
                        this.state = 3876;
                        this.match(SparkSqlParser.MINUS);
                        this.state = 3877;
                        this.identifier();
                        }
                        }
                        break;
                    default:
                        throw new antlr.NoViableAltException(this);
                    }
                    this.state = 3880;
                    this.errorHandler.sync(this);
                    alternative = this.interpreter.adaptivePredict(this.tokenStream, 499, this.context);
                } while (alternative !== 2 && alternative !== antlr.ATN.INVALID_ALT_NUMBER);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                // tslint:disable-next-line:no-empty
                {
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public identifier(): IdentifierContext {
        let localContext = new IdentifierContext(this.context, this.state);
        this.enterRule(localContext, 376, SparkSqlParser.RULE_identifier);
        try {
            this.state = 3887;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 501, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3885;
                this.strictIdentifier();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3886;
                this.strictNonReserved();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public strictIdentifier(): StrictIdentifierContext {
        let localContext = new StrictIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 378, SparkSqlParser.RULE_strictIdentifier);
        try {
            this.state = 3893;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 502, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3889;
                this.match(SparkSqlParser.IDENTIFIER);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3890;
                this.quotedIdentifier();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3891;
                this.ansiNonReserved();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3892;
                this.nonReserved();
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public quotedIdentifier(): QuotedIdentifierContext {
        let localContext = new QuotedIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 380, SparkSqlParser.RULE_quotedIdentifier);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3895;
            _la = this.tokenStream.LA(1);
            if(!(_la === 378 || _la === 389)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public backQuotedIdentifier(): BackQuotedIdentifierContext {
        let localContext = new BackQuotedIdentifierContext(this.context, this.state);
        this.enterRule(localContext, 382, SparkSqlParser.RULE_backQuotedIdentifier);
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3897;
            this.match(SparkSqlParser.BACKQUOTED_IDENTIFIER);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public number_(): NumberContext {
        let localContext = new NumberContext(this.context, this.state);
        this.enterRule(localContext, 384, SparkSqlParser.RULE_number);
        let _la: number;
        try {
            this.state = 3939;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 513, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3900;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3899;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3902;
                this.match(SparkSqlParser.EXPONENT_VALUE);
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3904;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3903;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3906;
                this.match(SparkSqlParser.DECIMAL_VALUE);
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3908;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3907;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3910;
                _la = this.tokenStream.LA(1);
                if(!(_la === 383 || _la === 384)) {
                this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3912;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3911;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3914;
                this.match(SparkSqlParser.INTEGER_VALUE);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3916;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3915;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3918;
                this.match(SparkSqlParser.BIGINT_LITERAL);
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3920;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3919;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3922;
                this.match(SparkSqlParser.SMALLINT_LITERAL);
                }
                break;
            case 7:
                this.enterOuterAlt(localContext, 7);
                {
                this.state = 3924;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3923;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3926;
                this.match(SparkSqlParser.TINYINT_LITERAL);
                }
                break;
            case 8:
                this.enterOuterAlt(localContext, 8);
                {
                this.state = 3928;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3927;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3930;
                this.match(SparkSqlParser.DOUBLE_LITERAL);
                }
                break;
            case 9:
                this.enterOuterAlt(localContext, 9);
                {
                this.state = 3932;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3931;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3934;
                this.match(SparkSqlParser.FLOAT_LITERAL);
                }
                break;
            case 10:
                this.enterOuterAlt(localContext, 10);
                {
                this.state = 3936;
                this.errorHandler.sync(this);
                _la = this.tokenStream.LA(1);
                if (_la === 362) {
                    {
                    this.state = 3935;
                    this.match(SparkSqlParser.MINUS);
                    }
                }

                this.state = 3938;
                this.match(SparkSqlParser.BIGDECIMAL_LITERAL);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public alterColumnAction(): AlterColumnActionContext {
        let localContext = new AlterColumnActionContext(this.context, this.state);
        this.enterRule(localContext, 386, SparkSqlParser.RULE_alterColumnAction);
        let _la: number;
        try {
            this.state = 3952;
            this.errorHandler.sync(this);
            switch (this.interpreter.adaptivePredict(this.tokenStream, 514, this.context) ) {
            case 1:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3941;
                this.match(SparkSqlParser.KW_TYPE);
                this.state = 3942;
                this.dataType();
                }
                break;
            case 2:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3943;
                this.commentSpec();
                }
                break;
            case 3:
                this.enterOuterAlt(localContext, 3);
                {
                this.state = 3944;
                this.colPosition();
                }
                break;
            case 4:
                this.enterOuterAlt(localContext, 4);
                {
                this.state = 3945;
                localContext._setOrDrop = this.tokenStream.LT(1);
                _la = this.tokenStream.LA(1);
                if(!(_la === 96 || _la === 269)) {
                    localContext._setOrDrop = this.errorHandler.recoverInline(this);
                }
                else {
                    this.errorHandler.reportMatch(this);
                    this.consume();
                }
                this.state = 3946;
                this.match(SparkSqlParser.KW_NOT);
                this.state = 3947;
                this.match(SparkSqlParser.KW_NULL);
                }
                break;
            case 5:
                this.enterOuterAlt(localContext, 5);
                {
                this.state = 3948;
                this.match(SparkSqlParser.KW_SET);
                this.state = 3949;
                this.defaultExpression();
                }
                break;
            case 6:
                this.enterOuterAlt(localContext, 6);
                {
                this.state = 3950;
                localContext._dropDefault = this.match(SparkSqlParser.KW_DROP);
                this.state = 3951;
                this.match(SparkSqlParser.KW_DEFAULT);
                }
                break;
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public stringLit(): StringLitContext {
        let localContext = new StringLitContext(this.context, this.state);
        this.enterRule(localContext, 388, SparkSqlParser.RULE_stringLit);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3954;
            _la = this.tokenStream.LA(1);
            if(!(_la === 377 || _la === 378)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public comment(): CommentContext {
        let localContext = new CommentContext(this.context, this.state);
        this.enterRule(localContext, 390, SparkSqlParser.RULE_comment);
        try {
            this.state = 3958;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.STRING_LITERAL:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3956;
                this.stringLit();
                }
                break;
            case SparkSqlParser.KW_NULL:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3957;
                this.match(SparkSqlParser.KW_NULL);
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public version(): VersionContext {
        let localContext = new VersionContext(this.context, this.state);
        this.enterRule(localContext, 392, SparkSqlParser.RULE_version);
        try {
            this.state = 3962;
            this.errorHandler.sync(this);
            switch (this.tokenStream.LA(1)) {
            case SparkSqlParser.INTEGER_VALUE:
                this.enterOuterAlt(localContext, 1);
                {
                this.state = 3960;
                this.match(SparkSqlParser.INTEGER_VALUE);
                }
                break;
            case SparkSqlParser.STRING_LITERAL:
            case SparkSqlParser.DOUBLEQUOTED_STRING:
                this.enterOuterAlt(localContext, 2);
                {
                this.state = 3961;
                this.stringLit();
                }
                break;
            default:
                throw new antlr.NoViableAltException(this);
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public ansiNonReserved(): AnsiNonReservedContext {
        let localContext = new AnsiNonReservedContext(this.context, this.state);
        this.enterRule(localContext, 394, SparkSqlParser.RULE_ansiNonReserved);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3964;
            _la = this.tokenStream.LA(1);
            if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4017011456) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 1711111143) !== 0) || ((((_la - 67)) & ~0x1F) === 0 && ((1 << (_la - 67)) & 3187671039) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & 1328796669) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & 3316086655) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & 1610612735) !== 0) || ((((_la - 199)) & ~0x1F) === 0 && ((1 << (_la - 199)) & 4020201927) !== 0) || ((((_la - 231)) & ~0x1F) === 0 && ((1 << (_la - 231)) & 4294442751) !== 0) || ((((_la - 264)) & ~0x1F) === 0 && ((1 << (_la - 264)) & 3758088175) !== 0) || ((((_la - 296)) & ~0x1F) === 0 && ((1 << (_la - 296)) & 3355402191) !== 0) || ((((_la - 328)) & ~0x1F) === 0 && ((1 << (_la - 328)) & 15892455) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public strictNonReserved(): StrictNonReservedContext {
        let localContext = new StrictNonReservedContext(this.context, this.state);
        this.enterRule(localContext, 396, SparkSqlParser.RULE_strictNonReserved);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3966;
            _la = this.tokenStream.LA(1);
            if(!(_la === 15 || _la === 60 || _la === 102 || _la === 124 || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & 149521) !== 0) || _la === 194 || _la === 203 || ((((_la - 250)) & ~0x1F) === 0 && ((1 << (_la - 250)) & 1064961) !== 0) || _la === 323 || _la === 332)) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }
    public nonReserved(): NonReservedContext {
        let localContext = new NonReservedContext(this.context, this.state);
        this.enterRule(localContext, 398, SparkSqlParser.RULE_nonReserved);
        let _la: number;
        try {
            this.enterOuterAlt(localContext, 1);
            {
            this.state = 3968;
            _la = this.tokenStream.LA(1);
            if(!((((_la) & ~0x1F) === 0 && ((1 << _la) & 4294934272) !== 0) || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & 4026531839) !== 0) || ((((_la - 64)) & ~0x1F) === 0 && ((1 << (_la - 64)) & 4294967295) !== 0) || ((((_la - 96)) & ~0x1F) === 0 && ((1 << (_la - 96)) & 3892314047) !== 0) || ((((_la - 128)) & ~0x1F) === 0 && ((1 << (_la - 128)) & 3085893631) !== 0) || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & 4294967293) !== 0) || ((((_la - 192)) & ~0x1F) === 0 && ((1 << (_la - 192)) & 4294965227) !== 0) || ((((_la - 224)) & ~0x1F) === 0 && ((1 << (_la - 224)) & 4227858431) !== 0) || ((((_la - 256)) & ~0x1F) === 0 && ((1 << (_la - 256)) & 4294950527) !== 0) || ((((_la - 288)) & ~0x1F) === 0 && ((1 << (_la - 288)) & 4294967263) !== 0) || ((((_la - 320)) & ~0x1F) === 0 && ((1 << (_la - 320)) & 4294963191) !== 0))) {
            this.errorHandler.recoverInline(this);
            }
            else {
                this.errorHandler.reportMatch(this);
                this.consume();
            }
            }
        }
        catch (re) {
            if (re instanceof antlr.RecognitionException) {
                localContext.exception = re;
                this.errorHandler.reportError(this, re);
                this.errorHandler.recover(this, re);
            } else {
                throw re;
            }
        }
        finally {
            this.exitRule();
        }
        return localContext;
    }

    public override sempred(localContext: antlr.RuleContext | null, ruleIndex: number, predIndex: number): boolean {
        switch (ruleIndex) {
        case 46:
            return this.columnName_sempred(localContext as ColumnNameContext, predIndex);
        case 52:
            return this.queryTerm_sempred(localContext as QueryTermContext, predIndex);
        case 138:
            return this.booleanExpression_sempred(localContext as BooleanExpressionContext, predIndex);
        case 140:
            return this.valueExpression_sempred(localContext as ValueExpressionContext, predIndex);
        case 142:
            return this.primaryExpression_sempred(localContext as PrimaryExpressionContext, predIndex);
        }
        return true;
    }
    private columnName_sempred(localContext: ColumnNameContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 0:
            return this.shouldMatchEmpty();
        }
        return true;
    }
    private queryTerm_sempred(localContext: QueryTermContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 1:
            return this.precpred(this.context, 3);
        case 2:
            return this.precpred(this.context, 2);
        case 3:
            return this.precpred(this.context, 1);
        }
        return true;
    }
    private booleanExpression_sempred(localContext: BooleanExpressionContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 4:
            return this.precpred(this.context, 2);
        case 5:
            return this.precpred(this.context, 1);
        }
        return true;
    }
    private valueExpression_sempred(localContext: ValueExpressionContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 6:
            return this.precpred(this.context, 6);
        case 7:
            return this.precpred(this.context, 5);
        case 8:
            return this.precpred(this.context, 4);
        case 9:
            return this.precpred(this.context, 3);
        case 10:
            return this.precpred(this.context, 2);
        case 11:
            return this.precpred(this.context, 1);
        }
        return true;
    }
    private primaryExpression_sempred(localContext: PrimaryExpressionContext | null, predIndex: number): boolean {
        switch (predIndex) {
        case 12:
            return this.precpred(this.context, 9);
        case 13:
            return this.precpred(this.context, 7);
        }
        return true;
    }

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

    private static __ATN: antlr.ATN;
    public static get _ATN(): antlr.ATN {
        if (!SparkSqlParser.__ATN) {
            SparkSqlParser.__ATN = new antlr.ATNDeserializer().deserialize(SparkSqlParser._serializedATN);
        }

        return SparkSqlParser.__ATN;
    }


    private static readonly vocabulary = new antlr.Vocabulary(SparkSqlParser.literalNames, SparkSqlParser.symbolicNames, []);

    public override get vocabulary(): antlr.Vocabulary {
        return SparkSqlParser.vocabulary;
    }

    private static readonly decisionsToDFA = SparkSqlParser._ATN.decisionToState.map( (ds: antlr.DecisionState, index: number) => new antlr.DFA(ds, index) );
}

export class ProgramContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public EOF(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.EOF, 0)!;
    }
    public singleStatement(): SingleStatementContext[];
    public singleStatement(i: number): SingleStatementContext | null;
    public singleStatement(i?: number): SingleStatementContext[] | SingleStatementContext | null {
        if (i === undefined) {
            return this.getRuleContexts(SingleStatementContext);
        }

        return this.getRuleContext(i, SingleStatementContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_program;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterProgram) {
             listener.enterProgram(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitProgram) {
             listener.exitProgram(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitProgram) {
            return visitor.visitProgram(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class StatementContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_statement;
    }
    public override copyFrom(ctx: StatementContext): void {
        super.copyFrom(ctx);
    }
}
export class ResetAnyContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_RESET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_RESET, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterResetAny) {
             listener.enterResetAny(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitResetAny) {
             listener.exitResetAny(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitResetAny) {
            return visitor.visitResetAny(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterTableDropColumnContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_COLUMN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMN, 0)!;
    }
    public columnName(): ColumnNameContext {
        return this.getRuleContext(0, ColumnNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterTableDropColumn) {
             listener.enterAlterTableDropColumn(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterTableDropColumn) {
             listener.exitAlterTableDropColumn(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterTableDropColumn) {
            return visitor.visitAlterTableDropColumn(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropMaterializedViewContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropMaterializedView) {
             listener.enterDropMaterializedView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropMaterializedView) {
             listener.exitDropMaterializedView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropMaterializedView) {
            return visitor.visitDropMaterializedView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterViewQueryContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterViewQuery) {
             listener.enterAlterViewQuery(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterViewQuery) {
             listener.exitAlterViewQuery(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterViewQuery) {
            return visitor.visitAlterViewQuery(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropNamespaceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public namespace(): NamespaceContext {
        return this.getRuleContext(0, NamespaceContext)!;
    }
    public namespaceName(): NamespaceNameContext {
        return this.getRuleContext(0, NamespaceNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public KW_RESTRICT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_RESTRICT, 0);
    }
    public KW_CASCADE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CASCADE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropNamespace) {
             listener.enterDropNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropNamespace) {
             listener.exitDropNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropNamespace) {
            return visitor.visitDropNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateTempViewUsingContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_TEMPORARY(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TEMPORARY, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewNameCreate(): ViewNameCreateContext {
        return this.getRuleContext(0, ViewNameCreateContext)!;
    }
    public tableProvider(): TableProviderContext {
        return this.getRuleContext(0, TableProviderContext)!;
    }
    public KW_OR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OR, 0);
    }
    public KW_REPLACE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_REPLACE, 0);
    }
    public KW_GLOBAL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_GLOBAL, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public colTypeList(): ColTypeListContext | null {
        return this.getRuleContext(0, ColTypeListContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public KW_OPTIONS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OPTIONS, 0);
    }
    public propertyList(): PropertyListContext | null {
        return this.getRuleContext(0, PropertyListContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateTempViewUsing) {
             listener.enterCreateTempViewUsing(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateTempViewUsing) {
             listener.exitCreateTempViewUsing(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateTempViewUsing) {
            return visitor.visitCreateTempViewUsing(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RenameTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_RENAME(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_RENAME, 0)!;
    }
    public KW_TO(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TO, 0)!;
    }
    public multipartIdentifier(): MultipartIdentifierContext {
        return this.getRuleContext(0, MultipartIdentifierContext)!;
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public KW_VIEW(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VIEW, 0);
    }
    public viewName(): ViewNameContext | null {
        return this.getRuleContext(0, ViewNameContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRenameTable) {
             listener.enterRenameTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRenameTable) {
             listener.exitRenameTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRenameTable) {
            return visitor.visitRenameTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DeclareVariableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DECLARE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DECLARE, 0)!;
    }
    public functionName(): FunctionNameContext {
        return this.getRuleContext(0, FunctionNameContext)!;
    }
    public KW_OR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OR, 0);
    }
    public KW_REPLACE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_REPLACE, 0);
    }
    public KW_VARIABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VARIABLE, 0);
    }
    public dataType(): DataTypeContext | null {
        return this.getRuleContext(0, DataTypeContext);
    }
    public variableDefaultExpression(): VariableDefaultExpressionContext | null {
        return this.getRuleContext(0, VariableDefaultExpressionContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDeclareVariable) {
             listener.enterDeclareVariable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDeclareVariable) {
             listener.exitDeclareVariable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDeclareVariable) {
            return visitor.visitDeclareVariable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class FailNativeCommandContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_ROLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ROLE, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterFailNativeCommand) {
             listener.enterFailNativeCommand(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitFailNativeCommand) {
             listener.exitFailNativeCommand(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitFailNativeCommand) {
            return visitor.visitFailNativeCommand(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetCatalogContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_CATALOG(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CATALOG, 0)!;
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetCatalog) {
             listener.enterSetCatalog(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetCatalog) {
             listener.exitSetCatalog(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetCatalog) {
            return visitor.visitSetCatalog(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterMaterializedViewPropertiesContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, 0)!;
    }
    public propertyList(): PropertyListContext {
        return this.getRuleContext(0, PropertyListContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterMaterializedViewProperties) {
             listener.enterAlterMaterializedViewProperties(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterMaterializedViewProperties) {
             listener.exitAlterMaterializedViewProperties(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterMaterializedViewProperties) {
            return visitor.visitAlterMaterializedViewProperties(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ClearCacheContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CLEAR(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CLEAR, 0)!;
    }
    public KW_CACHE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CACHE, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterClearCache) {
             listener.enterClearCache(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitClearCache) {
             listener.exitClearCache(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitClearCache) {
            return visitor.visitClearCache(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropViewContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropView) {
             listener.enterDropView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropView) {
             listener.exitDropView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropView) {
            return visitor.visitDropView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowTablesContext extends StatementContext {
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_TABLES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLES, 0)!;
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowTables) {
             listener.enterShowTables(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowTables) {
             listener.exitShowTables(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowTables) {
            return visitor.visitShowTables(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RecoverPartitionsContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_RECOVER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_RECOVER, 0)!;
    }
    public KW_PARTITIONS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_PARTITIONS, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRecoverPartitions) {
             listener.enterRecoverPartitions(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRecoverPartitions) {
             listener.exitRecoverPartitions(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRecoverPartitions) {
            return visitor.visitRecoverPartitions(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropIndexContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_INDEX(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INDEX, 0)!;
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public KW_ON(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ON, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropIndex) {
             listener.enterDropIndex(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropIndex) {
             listener.exitDropIndex(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropIndex) {
            return visitor.visitDropIndex(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTimeZoneIntervalContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_TIME(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TIME, 0)!;
    }
    public KW_ZONE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ZONE, 0)!;
    }
    public interval(): IntervalContext {
        return this.getRuleContext(0, IntervalContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTimeZoneInterval) {
             listener.enterSetTimeZoneInterval(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTimeZoneInterval) {
             listener.exitSetTimeZoneInterval(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTimeZoneInterval) {
            return visitor.visitSetTimeZoneInterval(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowCatalogsContext extends StatementContext {
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_CATALOGS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CATALOGS, 0)!;
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowCatalogs) {
             listener.enterShowCatalogs(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowCatalogs) {
             listener.exitShowCatalogs(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowCatalogs) {
            return visitor.visitShowCatalogs(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowCurrentNamespaceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_CURRENT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CURRENT, 0)!;
    }
    public namespace(): NamespaceContext {
        return this.getRuleContext(0, NamespaceContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowCurrentNamespace) {
             listener.enterShowCurrentNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowCurrentNamespace) {
             listener.exitShowCurrentNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowCurrentNamespace) {
            return visitor.visitShowCurrentNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RenameTablePartitionContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public partitionSpec(): PartitionSpecContext[];
    public partitionSpec(i: number): PartitionSpecContext | null;
    public partitionSpec(i?: number): PartitionSpecContext[] | PartitionSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionSpecContext);
        }

        return this.getRuleContext(i, PartitionSpecContext);
    }
    public KW_RENAME(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_RENAME, 0)!;
    }
    public KW_TO(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TO, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRenameTablePartition) {
             listener.enterRenameTablePartition(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRenameTablePartition) {
             listener.exitRenameTablePartition(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRenameTablePartition) {
            return visitor.visitRenameTablePartition(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RepairTableContext extends StatementContext {
    public _option?: Token | null;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_REPAIR(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REPAIR, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_MSCK(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_MSCK, 0);
    }
    public KW_PARTITIONS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PARTITIONS, 0);
    }
    public KW_ADD(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ADD, 0);
    }
    public KW_DROP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DROP, 0);
    }
    public KW_SYNC(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SYNC, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRepairTable) {
             listener.enterRepairTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRepairTable) {
             listener.exitRepairTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRepairTable) {
            return visitor.visitRepairTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RefreshResourceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_REFRESH(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REFRESH, 0)!;
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRefreshResource) {
             listener.enterRefreshResource(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRefreshResource) {
             listener.exitRefreshResource(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRefreshResource) {
            return visitor.visitRefreshResource(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetVariableAssignmentContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public assignmentList(): AssignmentListContext {
        return this.getRuleContext(0, AssignmentListContext)!;
    }
    public KW_VARIABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VARIABLE, 0);
    }
    public KW_VAR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VAR, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetVariableAssignment) {
             listener.enterSetVariableAssignment(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetVariableAssignment) {
             listener.exitSetVariableAssignment(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetVariableAssignment) {
            return visitor.visitSetVariableAssignment(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowCreateTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public KW_SERDE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SERDE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowCreateTable) {
             listener.enterShowCreateTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowCreateTable) {
             listener.exitShowCreateTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowCreateTable) {
            return visitor.visitShowCreateTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowNamespacesContext extends StatementContext {
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public namespaces(): NamespacesContext {
        return this.getRuleContext(0, NamespacesContext)!;
    }
    public multipartIdentifier(): MultipartIdentifierContext | null {
        return this.getRuleContext(0, MultipartIdentifierContext);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowNamespaces) {
             listener.enterShowNamespaces(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowNamespaces) {
             listener.exitShowNamespaces(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowNamespaces) {
            return visitor.visitShowNamespaces(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowColumnsContext extends StatementContext {
    public _table?: TableNameContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_COLUMNS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMNS, 0)!;
    }
    public KW_FROM(): antlr.TerminalNode[];
    public KW_FROM(i: number): antlr.TerminalNode | null;
    public KW_FROM(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_FROM);
    	} else {
    		return this.getToken(SparkSqlParser.KW_FROM, i);
    	}
    }
    public KW_IN(): antlr.TerminalNode[];
    public KW_IN(i: number): antlr.TerminalNode | null;
    public KW_IN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_IN);
    	} else {
    		return this.getToken(SparkSqlParser.KW_IN, i);
    	}
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowColumns) {
             listener.enterShowColumns(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowColumns) {
             listener.exitShowColumns(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowColumns) {
            return visitor.visitShowColumns(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ReplaceTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public replaceTableHeader(): ReplaceTableHeaderContext {
        return this.getRuleContext(0, ReplaceTableHeaderContext)!;
    }
    public createTableClauses(): CreateTableClausesContext {
        return this.getRuleContext(0, CreateTableClausesContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext | null {
        return this.getRuleContext(0, CreateOrReplaceTableColTypeListContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public tableProvider(): TableProviderContext | null {
        return this.getRuleContext(0, TableProviderContext);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterReplaceTable) {
             listener.enterReplaceTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitReplaceTable) {
             listener.exitReplaceTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitReplaceTable) {
            return visitor.visitReplaceTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AnalyzeTablesContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ANALYZE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ANALYZE, 0)!;
    }
    public KW_TABLES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLES, 0)!;
    }
    public KW_COMPUTE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COMPUTE, 0)!;
    }
    public KW_STATISTICS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_STATISTICS, 0)!;
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public KW_NOSCAN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NOSCAN, 0);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAnalyzeTables) {
             listener.enterAnalyzeTables(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAnalyzeTables) {
             listener.exitAnalyzeTables(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAnalyzeTables) {
            return visitor.visitAnalyzeTables(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AddTablePartitionContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_ADD(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ADD, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public KW_VIEW(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VIEW, 0);
    }
    public viewName(): ViewNameContext | null {
        return this.getRuleContext(0, ViewNameContext);
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public partitionSpecLocation(): PartitionSpecLocationContext[];
    public partitionSpecLocation(i: number): PartitionSpecLocationContext | null;
    public partitionSpecLocation(i?: number): PartitionSpecLocationContext[] | PartitionSpecLocationContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionSpecLocationContext);
        }

        return this.getRuleContext(i, PartitionSpecLocationContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAddTablePartition) {
             listener.enterAddTablePartition(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAddTablePartition) {
             listener.exitAddTablePartition(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAddTablePartition) {
            return visitor.visitAddTablePartition(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetNamespaceLocationContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public namespace(): NamespaceContext {
        return this.getRuleContext(0, NamespaceContext)!;
    }
    public namespaceName(): NamespaceNameContext {
        return this.getRuleContext(0, NamespaceNameContext)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public locationSpec(): LocationSpecContext {
        return this.getRuleContext(0, LocationSpecContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetNamespaceLocation) {
             listener.enterSetNamespaceLocation(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetNamespaceLocation) {
             listener.exitSetNamespaceLocation(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetNamespaceLocation) {
            return visitor.visitSetNamespaceLocation(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RefreshTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_REFRESH(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REFRESH, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRefreshTable) {
             listener.enterRefreshTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRefreshTable) {
             listener.exitRefreshTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRefreshTable) {
            return visitor.visitRefreshTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetAnyContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetAny) {
             listener.enterSetAny(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetAny) {
             listener.exitSetAny(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetAny) {
            return visitor.visitSetAny(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ResetConfigContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_RESET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_RESET, 0)!;
    }
    public configKey(): ConfigKeyContext {
        return this.getRuleContext(0, ConfigKeyContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterResetConfig) {
             listener.enterResetConfig(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitResetConfig) {
             listener.exitResetConfig(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitResetConfig) {
            return visitor.visitResetConfig(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetConfigAnyKeyContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public EQ(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.EQ, 0)!;
    }
    public configValue(): ConfigValueContext {
        return this.getRuleContext(0, ConfigValueContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetConfigAnyKey) {
             listener.enterSetConfigAnyKey(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetConfigAnyKey) {
             listener.exitSetConfigAnyKey(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetConfigAnyKey) {
            return visitor.visitSetConfigAnyKey(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetNamespacePropertiesContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public namespace(): NamespaceContext {
        return this.getRuleContext(0, NamespaceContext)!;
    }
    public namespaceName(): NamespaceNameContext {
        return this.getRuleContext(0, NamespaceNameContext)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public propertyList(): PropertyListContext {
        return this.getRuleContext(0, PropertyListContext)!;
    }
    public KW_DBPROPERTIES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DBPROPERTIES, 0);
    }
    public KW_PROPERTIES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PROPERTIES, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetNamespaceProperties) {
             listener.enterSetNamespaceProperties(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetNamespaceProperties) {
             listener.exitSetNamespaceProperties(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetNamespaceProperties) {
            return visitor.visitSetNamespaceProperties(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ManageResourceContext extends StatementContext {
    public _op?: Token | null;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public KW_ADD(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ADD, 0);
    }
    public KW_LIST(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIST, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterManageResource) {
             listener.enterManageResource(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitManageResource) {
             listener.exitManageResource(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitManageResource) {
            return visitor.visitManageResource(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ExplainStatementContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_EXPLAIN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_EXPLAIN, 0)!;
    }
    public statement(): StatementContext {
        return this.getRuleContext(0, StatementContext)!;
    }
    public KW_LOGICAL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LOGICAL, 0);
    }
    public KW_FORMATTED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FORMATTED, 0);
    }
    public KW_EXTENDED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXTENDED, 0);
    }
    public KW_CODEGEN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CODEGEN, 0);
    }
    public KW_COST(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_COST, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterExplainStatement) {
             listener.enterExplainStatement(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitExplainStatement) {
             listener.exitExplainStatement(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitExplainStatement) {
            return visitor.visitExplainStatement(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AnalyzeContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ANALYZE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ANALYZE, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_COMPUTE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COMPUTE, 0)!;
    }
    public KW_STATISTICS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_STATISTICS, 0)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public KW_NOSCAN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NOSCAN, 0);
    }
    public KW_FOR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FOR, 0);
    }
    public KW_COLUMNS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_COLUMNS, 0);
    }
    public columnNameSeq(): ColumnNameSeqContext | null {
        return this.getRuleContext(0, ColumnNameSeqContext);
    }
    public KW_ALL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ALL, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAnalyze) {
             listener.enterAnalyze(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAnalyze) {
             listener.exitAnalyze(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAnalyze) {
            return visitor.visitAnalyze(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateFunctionContext extends StatementContext {
    public _className?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_FUNCTION(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FUNCTION, 0)!;
    }
    public functionNameCreate(): FunctionNameCreateContext {
        return this.getRuleContext(0, FunctionNameCreateContext)!;
    }
    public KW_AS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_AS, 0)!;
    }
    public stringLit(): StringLitContext {
        return this.getRuleContext(0, StringLitContext)!;
    }
    public KW_OR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OR, 0);
    }
    public KW_REPLACE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_REPLACE, 0);
    }
    public KW_TEMPORARY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TEMPORARY, 0);
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public KW_USING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_USING, 0);
    }
    public resource(): ResourceContext[];
    public resource(i: number): ResourceContext | null;
    public resource(i?: number): ResourceContext[] | ResourceContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ResourceContext);
        }

        return this.getRuleContext(i, ResourceContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateFunction) {
             listener.enterCreateFunction(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateFunction) {
             listener.exitCreateFunction(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateFunction) {
            return visitor.visitCreateFunction(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class UnCacheTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_UNCACHE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_UNCACHE, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnCacheTable) {
             listener.enterUnCacheTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnCacheTable) {
             listener.exitUnCacheTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnCacheTable) {
            return visitor.visitUnCacheTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterTableAddColumnsContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_ADD(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ADD, 0)!;
    }
    public KW_COLUMNS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMNS, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public qualifiedColTypeWithPositionSeqForAdd(): QualifiedColTypeWithPositionSeqForAddContext {
        return this.getRuleContext(0, QualifiedColTypeWithPositionSeqForAddContext)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterTableAddColumns) {
             listener.enterAlterTableAddColumns(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterTableAddColumns) {
             listener.exitAlterTableAddColumns(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterTableAddColumns) {
            return visitor.visitAlterTableAddColumns(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class HiveReplaceColumnsContext extends StatementContext {
    public _table?: TableNameContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public KW_REPLACE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REPLACE, 0)!;
    }
    public KW_COLUMNS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMNS, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public qualifiedColTypeWithPositionSeqForReplace(): QualifiedColTypeWithPositionSeqForReplaceContext {
        return this.getRuleContext(0, QualifiedColTypeWithPositionSeqForReplaceContext)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterHiveReplaceColumns) {
             listener.enterHiveReplaceColumns(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitHiveReplaceColumns) {
             listener.exitHiveReplaceColumns(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitHiveReplaceColumns) {
            return visitor.visitHiveReplaceColumns(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterTableAddColumnContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_ADD(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ADD, 0)!;
    }
    public KW_COLUMN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMN, 0)!;
    }
    public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext {
        return this.getRuleContext(0, QualifiedColTypeWithPositionForAddContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterTableAddColumn) {
             listener.enterAlterTableAddColumn(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterTableAddColumn) {
             listener.exitAlterTableAddColumn(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterTableAddColumn) {
            return visitor.visitAlterTableAddColumn(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CommentNamespaceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_COMMENT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COMMENT, 0)!;
    }
    public KW_ON(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ON, 0)!;
    }
    public namespace(): NamespaceContext {
        return this.getRuleContext(0, NamespaceContext)!;
    }
    public namespaceName(): NamespaceNameContext {
        return this.getRuleContext(0, NamespaceNameContext)!;
    }
    public KW_IS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_IS, 0)!;
    }
    public comment(): CommentContext {
        return this.getRuleContext(0, CommentContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCommentNamespace) {
             listener.enterCommentNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCommentNamespace) {
             listener.exitCommentNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCommentNamespace) {
            return visitor.visitCommentNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public createTableHeader(): CreateTableHeaderContext {
        return this.getRuleContext(0, CreateTableHeaderContext)!;
    }
    public createTableClauses(): CreateTableClausesContext {
        return this.getRuleContext(0, CreateTableClausesContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public createOrReplaceTableColTypeList(): CreateOrReplaceTableColTypeListContext | null {
        return this.getRuleContext(0, CreateOrReplaceTableColTypeListContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public tableProvider(): TableProviderContext | null {
        return this.getRuleContext(0, TableProviderContext);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateTable) {
             listener.enterCreateTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateTable) {
             listener.exitCreateTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateTable) {
            return visitor.visitCreateTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DmlStatementContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public dmlStatementNoWith(): DmlStatementNoWithContext {
        return this.getRuleContext(0, DmlStatementNoWithContext)!;
    }
    public ctes(): CtesContext | null {
        return this.getRuleContext(0, CtesContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDmlStatement) {
             listener.enterDmlStatement(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDmlStatement) {
             listener.exitDmlStatement(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDmlStatement) {
            return visitor.visitDmlStatement(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterMaterializedViewRewriteContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public KW_REWRITE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REWRITE, 0)!;
    }
    public KW_ENABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ENABLE, 0);
    }
    public KW_DISABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DISABLE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterMaterializedViewRewrite) {
             listener.enterAlterMaterializedViewRewrite(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterMaterializedViewRewrite) {
             listener.exitAlterMaterializedViewRewrite(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterMaterializedViewRewrite) {
            return visitor.visitAlterMaterializedViewRewrite(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateTableLikeContext extends StatementContext {
    public _target?: TableNameCreateContext;
    public _source?: TableNameContext;
    public _tableProps?: PropertyListContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public KW_LIKE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_LIKE, 0)!;
    }
    public tableNameCreate(): TableNameCreateContext {
        return this.getRuleContext(0, TableNameCreateContext)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public tableProvider(): TableProviderContext[];
    public tableProvider(i: number): TableProviderContext | null;
    public tableProvider(i?: number): TableProviderContext[] | TableProviderContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TableProviderContext);
        }

        return this.getRuleContext(i, TableProviderContext);
    }
    public rowFormat(): RowFormatContext[];
    public rowFormat(i: number): RowFormatContext | null;
    public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RowFormatContext);
        }

        return this.getRuleContext(i, RowFormatContext);
    }
    public createFileFormat(): CreateFileFormatContext[];
    public createFileFormat(i: number): CreateFileFormatContext | null;
    public createFileFormat(i?: number): CreateFileFormatContext[] | CreateFileFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CreateFileFormatContext);
        }

        return this.getRuleContext(i, CreateFileFormatContext);
    }
    public locationSpec(): LocationSpecContext[];
    public locationSpec(i: number): LocationSpecContext | null;
    public locationSpec(i?: number): LocationSpecContext[] | LocationSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LocationSpecContext);
        }

        return this.getRuleContext(i, LocationSpecContext);
    }
    public tableLifecycle(): TableLifecycleContext[];
    public tableLifecycle(i: number): TableLifecycleContext | null;
    public tableLifecycle(i?: number): TableLifecycleContext[] | TableLifecycleContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TableLifecycleContext);
        }

        return this.getRuleContext(i, TableLifecycleContext);
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode[];
    public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null;
    public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
    	} else {
    		return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
    	}
    }
    public propertyList(): PropertyListContext[];
    public propertyList(i: number): PropertyListContext | null;
    public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PropertyListContext);
        }

        return this.getRuleContext(i, PropertyListContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateTableLike) {
             listener.enterCreateTableLike(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateTableLike) {
             listener.exitCreateTableLike(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateTableLike) {
            return visitor.visitCreateTableLike(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropFunctionContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_FUNCTION(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FUNCTION, 0)!;
    }
    public functionName(): FunctionNameContext {
        return this.getRuleContext(0, FunctionNameContext)!;
    }
    public KW_TEMPORARY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TEMPORARY, 0);
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropFunction) {
             listener.enterDropFunction(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropFunction) {
             listener.exitDropFunction(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropFunction) {
            return visitor.visitDropFunction(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetVariableMultiAssignmentContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public multipartIdentifierList(): MultipartIdentifierListContext {
        return this.getRuleContext(0, MultipartIdentifierListContext)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.RIGHT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
    	}
    }
    public EQ(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.EQ, 0)!;
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public KW_VARIABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VARIABLE, 0);
    }
    public KW_VAR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VAR, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetVariableMultiAssignment) {
             listener.enterSetVariableMultiAssignment(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetVariableMultiAssignment) {
             listener.exitSetVariableMultiAssignment(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetVariableMultiAssignment) {
            return visitor.visitSetVariableMultiAssignment(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DescribeRelationContext extends StatementContext {
    public _option?: Token | null;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_DESC(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESC, 0);
    }
    public KW_DESCRIBE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESCRIBE, 0);
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public describeColName(): DescribeColNameContext | null {
        return this.getRuleContext(0, DescribeColNameContext);
    }
    public KW_EXTENDED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXTENDED, 0);
    }
    public KW_FORMATTED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FORMATTED, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDescribeRelation) {
             listener.enterDescribeRelation(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDescribeRelation) {
             listener.exitDescribeRelation(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDescribeRelation) {
            return visitor.visitDescribeRelation(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class LoadDataContext extends StatementContext {
    public _path?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_LOAD(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_LOAD, 0)!;
    }
    public KW_DATA(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DATA, 0)!;
    }
    public KW_INPATH(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INPATH, 0)!;
    }
    public KW_INTO(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INTO, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public stringLit(): StringLitContext {
        return this.getRuleContext(0, StringLitContext)!;
    }
    public KW_LOCAL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LOCAL, 0);
    }
    public KW_OVERWRITE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OVERWRITE, 0);
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterLoadData) {
             listener.enterLoadData(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitLoadData) {
             listener.exitLoadData(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitLoadData) {
            return visitor.visitLoadData(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowPartitionsContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_PARTITIONS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_PARTITIONS, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowPartitions) {
             listener.enterShowPartitions(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowPartitions) {
             listener.exitShowPartitions(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowPartitions) {
            return visitor.visitShowPartitions(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DescribeFunctionContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_FUNCTION(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FUNCTION, 0)!;
    }
    public describeFuncName(): DescribeFuncNameContext {
        return this.getRuleContext(0, DescribeFuncNameContext)!;
    }
    public KW_DESC(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESC, 0);
    }
    public KW_DESCRIBE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESCRIBE, 0);
    }
    public KW_EXTENDED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXTENDED, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDescribeFunction) {
             listener.enterDescribeFunction(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDescribeFunction) {
             listener.exitDescribeFunction(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDescribeFunction) {
            return visitor.visitDescribeFunction(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RenameTableColumnContext extends StatementContext {
    public _table?: TableNameContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public KW_RENAME(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_RENAME, 0)!;
    }
    public KW_COLUMN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMN, 0)!;
    }
    public columnName(): ColumnNameContext {
        return this.getRuleContext(0, ColumnNameContext)!;
    }
    public KW_TO(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TO, 0)!;
    }
    public columnNameCreate(): ColumnNameCreateContext {
        return this.getRuleContext(0, ColumnNameCreateContext)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRenameTableColumn) {
             listener.enterRenameTableColumn(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRenameTableColumn) {
             listener.exitRenameTableColumn(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRenameTableColumn) {
            return visitor.visitRenameTableColumn(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetConfigContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public configKey(): ConfigKeyContext {
        return this.getRuleContext(0, ConfigKeyContext)!;
    }
    public EQ(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.EQ, 0)!;
    }
    public configValue(): ConfigValueContext {
        return this.getRuleContext(0, ConfigValueContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetConfig) {
             listener.enterSetConfig(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetConfig) {
             listener.exitSetConfig(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetConfig) {
            return visitor.visitSetConfig(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class UnsupportHiveCommandsContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public unsupportedHiveNativeCommands(): UnsupportedHiveNativeCommandsContext {
        return this.getRuleContext(0, UnsupportedHiveNativeCommandsContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnsupportHiveCommands) {
             listener.enterUnsupportHiveCommands(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnsupportHiveCommands) {
             listener.exitUnsupportHiveCommands(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnsupportHiveCommands) {
            return visitor.visitUnsupportHiveCommands(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class StatementDefaultContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterStatementDefault) {
             listener.enterStatementDefault(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitStatementDefault) {
             listener.exitStatementDefault(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitStatementDefault) {
            return visitor.visitStatementDefault(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class HiveChangeColumnContext extends StatementContext {
    public _table?: TableNameContext;
    public _colName?: ColumnNameContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public KW_CHANGE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CHANGE, 0)!;
    }
    public colType(): ColTypeContext {
        return this.getRuleContext(0, ColTypeContext)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public columnName(): ColumnNameContext {
        return this.getRuleContext(0, ColumnNameContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public KW_COLUMN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_COLUMN, 0);
    }
    public colPosition(): ColPositionContext | null {
        return this.getRuleContext(0, ColPositionContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterHiveChangeColumn) {
             listener.enterHiveChangeColumn(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitHiveChangeColumn) {
             listener.exitHiveChangeColumn(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitHiveChangeColumn) {
            return visitor.visitHiveChangeColumn(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class OptimizeTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_OPTIMIZE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_OPTIMIZE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public zorderClause(): ZorderClauseContext {
        return this.getRuleContext(0, ZorderClauseContext)!;
    }
    public whereClause(): WhereClauseContext | null {
        return this.getRuleContext(0, WhereClauseContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterOptimizeTable) {
             listener.enterOptimizeTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitOptimizeTable) {
             listener.exitOptimizeTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitOptimizeTable) {
            return visitor.visitOptimizeTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTimeZoneContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_TIME(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TIME, 0)!;
    }
    public KW_ZONE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ZONE, 0)!;
    }
    public timezone(): TimezoneContext {
        return this.getRuleContext(0, TimezoneContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTimeZone) {
             listener.enterSetTimeZone(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTimeZone) {
             listener.exitSetTimeZone(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTimeZone) {
            return visitor.visitSetTimeZone(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DescribeQueryContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public KW_DESC(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESC, 0);
    }
    public KW_DESCRIBE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESCRIBE, 0);
    }
    public KW_QUERY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_QUERY, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDescribeQuery) {
             listener.enterDescribeQuery(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDescribeQuery) {
             listener.exitDescribeQuery(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDescribeQuery) {
            return visitor.visitDescribeQuery(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class TruncateTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_TRUNCATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TRUNCATE, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterTruncateTable) {
             listener.enterTruncateTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitTruncateTable) {
             listener.exitTruncateTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitTruncateTable) {
            return visitor.visitTruncateTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetConfigAndValueContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public configKey(): ConfigKeyContext {
        return this.getRuleContext(0, ConfigKeyContext)!;
    }
    public EQ(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.EQ, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetConfigAndValue) {
             listener.enterSetConfigAndValue(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetConfigAndValue) {
             listener.exitSetConfigAndValue(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetConfigAndValue) {
            return visitor.visitSetConfigAndValue(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateMaterializedViewContext extends StatementContext {
    public _options?: PropertyListContext;
    public _partitioning?: PartitionFieldListContext;
    public _tableProps?: PropertyListContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewNameCreate(): ViewNameCreateContext {
        return this.getRuleContext(0, ViewNameCreateContext)!;
    }
    public KW_AS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_AS, 0)!;
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public tableProvider(): TableProviderContext | null {
        return this.getRuleContext(0, TableProviderContext);
    }
    public skewSpec(): SkewSpecContext[];
    public skewSpec(i: number): SkewSpecContext | null;
    public skewSpec(i?: number): SkewSpecContext[] | SkewSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(SkewSpecContext);
        }

        return this.getRuleContext(i, SkewSpecContext);
    }
    public bucketSpec(): BucketSpecContext[];
    public bucketSpec(i: number): BucketSpecContext | null;
    public bucketSpec(i?: number): BucketSpecContext[] | BucketSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(BucketSpecContext);
        }

        return this.getRuleContext(i, BucketSpecContext);
    }
    public rowFormat(): RowFormatContext[];
    public rowFormat(i: number): RowFormatContext | null;
    public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RowFormatContext);
        }

        return this.getRuleContext(i, RowFormatContext);
    }
    public createFileFormat(): CreateFileFormatContext[];
    public createFileFormat(i: number): CreateFileFormatContext | null;
    public createFileFormat(i?: number): CreateFileFormatContext[] | CreateFileFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CreateFileFormatContext);
        }

        return this.getRuleContext(i, CreateFileFormatContext);
    }
    public locationSpec(): LocationSpecContext[];
    public locationSpec(i: number): LocationSpecContext | null;
    public locationSpec(i?: number): LocationSpecContext[] | LocationSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LocationSpecContext);
        }

        return this.getRuleContext(i, LocationSpecContext);
    }
    public commentSpec(): CommentSpecContext[];
    public commentSpec(i: number): CommentSpecContext | null;
    public commentSpec(i?: number): CommentSpecContext[] | CommentSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CommentSpecContext);
        }

        return this.getRuleContext(i, CommentSpecContext);
    }
    public KW_OPTIONS(): antlr.TerminalNode[];
    public KW_OPTIONS(i: number): antlr.TerminalNode | null;
    public KW_OPTIONS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_OPTIONS);
    	} else {
    		return this.getToken(SparkSqlParser.KW_OPTIONS, i);
    	}
    }
    public KW_PARTITIONED(): antlr.TerminalNode[];
    public KW_PARTITIONED(i: number): antlr.TerminalNode | null;
    public KW_PARTITIONED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_PARTITIONED);
    	} else {
    		return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
    	}
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_BY);
    	} else {
    		return this.getToken(SparkSqlParser.KW_BY, i);
    	}
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode[];
    public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null;
    public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
    	} else {
    		return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
    	}
    }
    public propertyList(): PropertyListContext[];
    public propertyList(i: number): PropertyListContext | null;
    public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PropertyListContext);
        }

        return this.getRuleContext(i, PropertyListContext);
    }
    public partitionFieldList(): PartitionFieldListContext[];
    public partitionFieldList(i: number): PartitionFieldListContext | null;
    public partitionFieldList(i?: number): PartitionFieldListContext[] | PartitionFieldListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionFieldListContext);
        }

        return this.getRuleContext(i, PartitionFieldListContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateMaterializedView) {
             listener.enterCreateMaterializedView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateMaterializedView) {
             listener.exitCreateMaterializedView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateMaterializedView) {
            return visitor.visitCreateMaterializedView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTableSerDeContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_SERDE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SERDE, 0)!;
    }
    public stringLit(): StringLitContext {
        return this.getRuleContext(0, StringLitContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public KW_WITH(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_WITH, 0);
    }
    public KW_SERDEPROPERTIES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SERDEPROPERTIES, 0);
    }
    public propertyList(): PropertyListContext | null {
        return this.getRuleContext(0, PropertyListContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTableSerDe) {
             listener.enterSetTableSerDe(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTableSerDe) {
             listener.exitSetTableSerDe(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTableSerDe) {
            return visitor.visitSetTableSerDe(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateViewContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewNameCreate(): ViewNameCreateContext {
        return this.getRuleContext(0, ViewNameCreateContext)!;
    }
    public KW_AS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_AS, 0)!;
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public KW_OR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OR, 0);
    }
    public KW_REPLACE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_REPLACE, 0);
    }
    public KW_TEMPORARY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TEMPORARY, 0);
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public identifierCommentList(): IdentifierCommentListContext | null {
        return this.getRuleContext(0, IdentifierCommentListContext);
    }
    public commentSpec(): CommentSpecContext[];
    public commentSpec(i: number): CommentSpecContext | null;
    public commentSpec(i?: number): CommentSpecContext[] | CommentSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CommentSpecContext);
        }

        return this.getRuleContext(i, CommentSpecContext);
    }
    public KW_PARTITIONED(): antlr.TerminalNode[];
    public KW_PARTITIONED(i: number): antlr.TerminalNode | null;
    public KW_PARTITIONED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_PARTITIONED);
    	} else {
    		return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
    	}
    }
    public KW_ON(): antlr.TerminalNode[];
    public KW_ON(i: number): antlr.TerminalNode | null;
    public KW_ON(i?: number): antlr.TerminalNode | null | antlr.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 | null;
    public identifierList(i?: number): IdentifierListContext[] | IdentifierListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierListContext);
        }

        return this.getRuleContext(i, IdentifierListContext);
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode[];
    public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null;
    public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_TBLPROPERTIES);
    	} else {
    		return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, i);
    	}
    }
    public propertyList(): PropertyListContext[];
    public propertyList(i: number): PropertyListContext | null;
    public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PropertyListContext);
        }

        return this.getRuleContext(i, PropertyListContext);
    }
    public KW_GLOBAL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_GLOBAL, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateView) {
             listener.enterCreateView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateView) {
             listener.exitCreateView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateView) {
            return visitor.visitCreateView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTimeZoneAnyContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_TIME(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TIME, 0)!;
    }
    public KW_ZONE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ZONE, 0)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTimeZoneAny) {
             listener.enterSetTimeZoneAny(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTimeZoneAny) {
             listener.exitSetTimeZoneAny(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTimeZoneAny) {
            return visitor.visitSetTimeZoneAny(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropTablePartitionsContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public partitionSpec(): PartitionSpecContext[];
    public partitionSpec(i: number): PartitionSpecContext | null;
    public partitionSpec(i?: number): PartitionSpecContext[] | PartitionSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionSpecContext);
        }

        return this.getRuleContext(i, PartitionSpecContext);
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public KW_VIEW(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VIEW, 0);
    }
    public viewName(): ViewNameContext | null {
        return this.getRuleContext(0, ViewNameContext);
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public KW_PURGE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PURGE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropTablePartitions) {
             listener.enterDropTablePartitions(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropTablePartitions) {
             listener.exitDropTablePartitions(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropTablePartitions) {
            return visitor.visitDropTablePartitions(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public KW_PURGE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PURGE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropTable) {
             listener.enterDropTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropTable) {
             listener.exitDropTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropTable) {
            return visitor.visitDropTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowTableExtendedContext extends StatementContext {
    public _ns?: NamespaceNameContext;
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public KW_EXTENDED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_EXTENDED, 0)!;
    }
    public KW_LIKE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_LIKE, 0)!;
    }
    public stringLit(): StringLitContext {
        return this.getRuleContext(0, StringLitContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowTableExtended) {
             listener.enterShowTableExtended(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowTableExtended) {
             listener.exitShowTableExtended(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowTableExtended) {
            return visitor.visitShowTableExtended(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DescribeNamespaceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DATABASE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DATABASE, 0)!;
    }
    public namespaceName(): NamespaceNameContext {
        return this.getRuleContext(0, NamespaceNameContext)!;
    }
    public KW_DESC(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESC, 0);
    }
    public KW_DESCRIBE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DESCRIBE, 0);
    }
    public KW_EXTENDED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXTENDED, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDescribeNamespace) {
             listener.enterDescribeNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDescribeNamespace) {
             listener.exitDescribeNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDescribeNamespace) {
            return visitor.visitDescribeNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class AlterTableAlterColumnContext extends StatementContext {
    public _table?: TableNameContext;
    public _column?: ColumnNameContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode[];
    public KW_ALTER(i: number): antlr.TerminalNode | null;
    public KW_ALTER(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_ALTER);
    	} else {
    		return this.getToken(SparkSqlParser.KW_ALTER, i);
    	}
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_CHANGE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CHANGE, 0);
    }
    public columnName(): ColumnNameContext {
        return this.getRuleContext(0, ColumnNameContext)!;
    }
    public KW_COLUMN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_COLUMN, 0);
    }
    public alterColumnAction(): AlterColumnActionContext | null {
        return this.getRuleContext(0, AlterColumnActionContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAlterTableAlterColumn) {
             listener.enterAlterTableAlterColumn(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAlterTableAlterColumn) {
             listener.exitAlterTableAlterColumn(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAlterTableAlterColumn) {
            return visitor.visitAlterTableAlterColumn(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RefreshFunctionContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_REFRESH(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REFRESH, 0)!;
    }
    public KW_FUNCTION(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FUNCTION, 0)!;
    }
    public functionName(): FunctionNameContext {
        return this.getRuleContext(0, FunctionNameContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRefreshFunction) {
             listener.enterRefreshFunction(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRefreshFunction) {
             listener.exitRefreshFunction(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRefreshFunction) {
            return visitor.visitRefreshFunction(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CommentTableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_COMMENT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COMMENT, 0)!;
    }
    public KW_ON(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ON, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_IS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_IS, 0)!;
    }
    public comment(): CommentContext {
        return this.getRuleContext(0, CommentContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCommentTable) {
             listener.enterCommentTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCommentTable) {
             listener.exitCommentTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCommentTable) {
            return visitor.visitCommentTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowMaterializedViewsContext extends StatementContext {
    public _db_name?: NamespaceNameContext;
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEWS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEWS, 0)!;
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowMaterializedViews) {
             listener.enterShowMaterializedViews(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowMaterializedViews) {
             listener.exitShowMaterializedViews(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowMaterializedViews) {
            return visitor.visitShowMaterializedViews(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateIndexContext extends StatementContext {
    public _indexType?: IdentifierContext;
    public _options?: PropertyListContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_INDEX(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INDEX, 0)!;
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public KW_ON(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ON, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public multipartIdentifierPropertyList(): MultipartIdentifierPropertyListContext {
        return this.getRuleContext(0, MultipartIdentifierPropertyListContext)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public KW_USING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_USING, 0);
    }
    public KW_OPTIONS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OPTIONS, 0);
    }
    public propertyList(): PropertyListContext | null {
        return this.getRuleContext(0, PropertyListContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateIndex) {
             listener.enterCreateIndex(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateIndex) {
             listener.exitCreateIndex(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateIndex) {
            return visitor.visitCreateIndex(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class UseNamespaceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_USE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_USE, 0)!;
    }
    public namespaceName(): NamespaceNameContext {
        return this.getRuleContext(0, NamespaceNameContext)!;
    }
    public namespace(): NamespaceContext | null {
        return this.getRuleContext(0, NamespaceContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUseNamespace) {
             listener.enterUseNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUseNamespace) {
             listener.exitUseNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUseNamespace) {
            return visitor.visitUseNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropVariableContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_TEMPORARY(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TEMPORARY, 0)!;
    }
    public KW_VARIABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VARIABLE, 0)!;
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public viewName(): ViewNameContext | null {
        return this.getRuleContext(0, ViewNameContext);
    }
    public functionName(): FunctionNameContext | null {
        return this.getRuleContext(0, FunctionNameContext);
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropVariable) {
             listener.enterDropVariable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropVariable) {
             listener.exitDropVariable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropVariable) {
            return visitor.visitDropVariable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CreateNamespaceContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public namespace(): NamespaceContext {
        return this.getRuleContext(0, NamespaceContext)!;
    }
    public namespaceNameCreate(): NamespaceNameCreateContext {
        return this.getRuleContext(0, NamespaceNameCreateContext)!;
    }
    public ifNotExists(): IfNotExistsContext | null {
        return this.getRuleContext(0, IfNotExistsContext);
    }
    public commentSpec(): CommentSpecContext[];
    public commentSpec(i: number): CommentSpecContext | null;
    public commentSpec(i?: number): CommentSpecContext[] | CommentSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CommentSpecContext);
        }

        return this.getRuleContext(i, CommentSpecContext);
    }
    public locationSpec(): LocationSpecContext[];
    public locationSpec(i: number): LocationSpecContext | null;
    public locationSpec(i?: number): LocationSpecContext[] | LocationSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LocationSpecContext);
        }

        return this.getRuleContext(i, LocationSpecContext);
    }
    public KW_WITH(): antlr.TerminalNode[];
    public KW_WITH(i: number): antlr.TerminalNode | null;
    public KW_WITH(i?: number): antlr.TerminalNode | null | antlr.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 | null;
    public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PropertyListContext);
        }

        return this.getRuleContext(i, PropertyListContext);
    }
    public KW_DBPROPERTIES(): antlr.TerminalNode[];
    public KW_DBPROPERTIES(i: number): antlr.TerminalNode | null;
    public KW_DBPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_DBPROPERTIES);
    	} else {
    		return this.getToken(SparkSqlParser.KW_DBPROPERTIES, i);
    	}
    }
    public KW_PROPERTIES(): antlr.TerminalNode[];
    public KW_PROPERTIES(i: number): antlr.TerminalNode | null;
    public KW_PROPERTIES(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_PROPERTIES);
    	} else {
    		return this.getToken(SparkSqlParser.KW_PROPERTIES, i);
    	}
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateNamespace) {
             listener.enterCreateNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateNamespace) {
             listener.exitCreateNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateNamespace) {
            return visitor.visitCreateNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTableSerDePropertiesContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_SERDEPROPERTIES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SERDEPROPERTIES, 0)!;
    }
    public propertyList(): PropertyListContext {
        return this.getRuleContext(0, PropertyListContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTableSerDeProperties) {
             listener.enterSetTableSerDeProperties(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTableSerDeProperties) {
             listener.exitSetTableSerDeProperties(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTableSerDeProperties) {
            return visitor.visitSetTableSerDeProperties(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class RefreshMaterializedViewContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_REFRESH(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_REFRESH, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRefreshMaterializedView) {
             listener.enterRefreshMaterializedView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRefreshMaterializedView) {
             listener.exitRefreshMaterializedView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRefreshMaterializedView) {
            return visitor.visitRefreshMaterializedView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowTblPropertiesContext extends StatementContext {
    public _table?: TableNameContext;
    public _key?: PropertyKeyContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public propertyKey(): PropertyKeyContext | null {
        return this.getRuleContext(0, PropertyKeyContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowTblProperties) {
             listener.enterShowTblProperties(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowTblProperties) {
             listener.exitShowTblProperties(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowTblProperties) {
            return visitor.visitShowTblProperties(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowCreateMaterializedViewContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_CREATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CREATE, 0)!;
    }
    public KW_MATERIALIZED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MATERIALIZED, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public KW_SERDE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SERDE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowCreateMaterializedView) {
             listener.enterShowCreateMaterializedView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowCreateMaterializedView) {
             listener.exitShowCreateMaterializedView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowCreateMaterializedView) {
            return visitor.visitShowCreateMaterializedView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class UnsetTablePropertiesContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_UNSET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_UNSET, 0)!;
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, 0)!;
    }
    public propertyList(): PropertyListContext {
        return this.getRuleContext(0, PropertyListContext)!;
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public KW_VIEW(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VIEW, 0);
    }
    public viewName(): ViewNameContext | null {
        return this.getRuleContext(0, ViewNameContext);
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnsetTableProperties) {
             listener.enterUnsetTableProperties(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnsetTableProperties) {
             listener.exitUnsetTableProperties(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnsetTableProperties) {
            return visitor.visitUnsetTableProperties(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTableLocationContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public locationSpec(): LocationSpecContext {
        return this.getRuleContext(0, LocationSpecContext)!;
    }
    public partitionSpec(): PartitionSpecContext | null {
        return this.getRuleContext(0, PartitionSpecContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTableLocation) {
             listener.enterSetTableLocation(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTableLocation) {
             listener.exitSetTableLocation(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTableLocation) {
            return visitor.visitSetTableLocation(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class DropTableColumnsContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_DROP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DROP, 0)!;
    }
    public KW_COLUMNS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_COLUMNS, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public columnNameSeq(): ColumnNameSeqContext {
        return this.getRuleContext(0, ColumnNameSeqContext)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public ifExists(): IfExistsContext | null {
        return this.getRuleContext(0, IfExistsContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDropTableColumns) {
             listener.enterDropTableColumns(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDropTableColumns) {
             listener.exitDropTableColumns(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDropTableColumns) {
            return visitor.visitDropTableColumns(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowViewsContext extends StatementContext {
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_VIEWS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEWS, 0)!;
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowViews) {
             listener.enterShowViews(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowViews) {
             listener.exitShowViews(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowViews) {
            return visitor.visitShowViews(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class ShowFunctionsContext extends StatementContext {
    public _ns?: NamespaceNameContext;
    public _legacy?: MultipartIdentifierContext;
    public _pattern?: StringLitContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_SHOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SHOW, 0)!;
    }
    public KW_FUNCTIONS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FUNCTIONS, 0)!;
    }
    public functionKind(): FunctionKindContext | null {
        return this.getRuleContext(0, FunctionKindContext);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public namespaceName(): NamespaceNameContext | null {
        return this.getRuleContext(0, NamespaceNameContext);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public multipartIdentifier(): MultipartIdentifierContext | null {
        return this.getRuleContext(0, MultipartIdentifierContext);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterShowFunctions) {
             listener.enterShowFunctions(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitShowFunctions) {
             listener.exitShowFunctions(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitShowFunctions) {
            return visitor.visitShowFunctions(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class CacheTableContext extends StatementContext {
    public _options?: PropertyListContext;
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_CACHE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CACHE, 0)!;
    }
    public KW_TABLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TABLE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public KW_LAZY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LAZY, 0);
    }
    public KW_OPTIONS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OPTIONS, 0);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public propertyList(): PropertyListContext | null {
        return this.getRuleContext(0, PropertyListContext);
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCacheTable) {
             listener.enterCacheTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCacheTable) {
             listener.exitCacheTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCacheTable) {
            return visitor.visitCacheTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class SetTablePropertiesContext extends StatementContext {
    public constructor(ctx: StatementContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_ALTER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ALTER, 0)!;
    }
    public KW_SET(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SET, 0)!;
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TBLPROPERTIES, 0)!;
    }
    public propertyList(): PropertyListContext {
        return this.getRuleContext(0, PropertyListContext)!;
    }
    public KW_TABLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TABLE, 0);
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public KW_VIEW(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VIEW, 0);
    }
    public viewName(): ViewNameContext | null {
        return this.getRuleContext(0, ViewNameContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSetTableProperties) {
             listener.enterSetTableProperties(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSetTableProperties) {
             listener.exitSetTableProperties(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSetTableProperties) {
            return visitor.visitSetTableProperties(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


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


export class BucketSpecContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_CLUSTERED(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_CLUSTERED, 0)!;
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.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(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INTO, 0)!;
    }
    public INTEGER_VALUE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.INTEGER_VALUE, 0)!;
    }
    public KW_BUCKETS(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_BUCKETS, 0)!;
    }
    public KW_SORTED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SORTED, 0);
    }
    public orderedIdentifierList(): OrderedIdentifierListContext | null {
        return this.getRuleContext(0, OrderedIdentifierListContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_bucketSpec;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterBucketSpec) {
             listener.enterBucketSpec(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitBucketSpec) {
             listener.exitBucketSpec(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitBucketSpec) {
            return visitor.visitBucketSpec(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


export class QueryContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_query;
    }
    public override copyFrom(ctx: QueryContext): void {
        super.copyFrom(ctx);
    }
}
export class QueryStatementContext extends QueryContext {
    public constructor(ctx: QueryContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public queryTerm(): QueryTermContext {
        return this.getRuleContext(0, QueryTermContext)!;
    }
    public queryOrganization(): QueryOrganizationContext {
        return this.getRuleContext(0, QueryOrganizationContext)!;
    }
    public ctes(): CtesContext | null {
        return this.getRuleContext(0, CtesContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQueryStatement) {
             listener.enterQueryStatement(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQueryStatement) {
             listener.exitQueryStatement(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQueryStatement) {
            return visitor.visitQueryStatement(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class PartitionSpecContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_PARTITION(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_PARTITION, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public partitionVal(): PartitionValContext[];
    public partitionVal(i: number): PartitionValContext | null;
    public partitionVal(i?: number): PartitionValContext[] | PartitionValContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionValContext);
        }

        return this.getRuleContext(i, PartitionValContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_partitionSpec;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPartitionSpec) {
             listener.enterPartitionSpec(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPartitionSpec) {
             listener.exitPartitionSpec(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPartitionSpec) {
            return visitor.visitPartitionSpec(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class NamespaceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_NAMESPACE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NAMESPACE, 0);
    }
    public KW_DATABASE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DATABASE, 0);
    }
    public KW_SCHEMA(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SCHEMA, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_namespace;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNamespace) {
             listener.enterNamespace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNamespace) {
             listener.exitNamespace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNamespace) {
            return visitor.visitNamespace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class NamespacesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_NAMESPACES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NAMESPACES, 0);
    }
    public KW_DATABASES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DATABASES, 0);
    }
    public KW_SCHEMAS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SCHEMAS, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_namespaces;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNamespaces) {
             listener.enterNamespaces(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNamespaces) {
             listener.exitNamespaces(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNamespaces) {
            return visitor.visitNamespaces(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class DescribeColNameContext extends antlr.ParserRuleContext {
    public _identifier?: IdentifierContext;
    public _nameParts: IdentifierContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.DOT);
    	} else {
    		return this.getToken(SparkSqlParser.DOT, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_describeColName;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDescribeColName) {
             listener.enterDescribeColName(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDescribeColName) {
             listener.exitDescribeColName(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDescribeColName) {
            return visitor.visitDescribeColName(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class CtesContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_WITH(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_WITH, 0)!;
    }
    public namedQuery(): NamedQueryContext[];
    public namedQuery(i: number): NamedQueryContext | null;
    public namedQuery(i?: number): NamedQueryContext[] | NamedQueryContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NamedQueryContext);
        }

        return this.getRuleContext(i, NamedQueryContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_ctes;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCtes) {
             listener.enterCtes(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCtes) {
             listener.exitCtes(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCtes) {
            return visitor.visitCtes(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class CreateTableClausesContext extends antlr.ParserRuleContext {
    public _options?: ExpressionPropertyListContext;
    public _partitioning?: PartitionFieldListContext;
    public _tableProps?: PropertyListContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public skewSpec(): SkewSpecContext[];
    public skewSpec(i: number): SkewSpecContext | null;
    public skewSpec(i?: number): SkewSpecContext[] | SkewSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(SkewSpecContext);
        }

        return this.getRuleContext(i, SkewSpecContext);
    }
    public bucketSpec(): BucketSpecContext[];
    public bucketSpec(i: number): BucketSpecContext | null;
    public bucketSpec(i?: number): BucketSpecContext[] | BucketSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(BucketSpecContext);
        }

        return this.getRuleContext(i, BucketSpecContext);
    }
    public rowFormat(): RowFormatContext[];
    public rowFormat(i: number): RowFormatContext | null;
    public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RowFormatContext);
        }

        return this.getRuleContext(i, RowFormatContext);
    }
    public createFileFormat(): CreateFileFormatContext[];
    public createFileFormat(i: number): CreateFileFormatContext | null;
    public createFileFormat(i?: number): CreateFileFormatContext[] | CreateFileFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CreateFileFormatContext);
        }

        return this.getRuleContext(i, CreateFileFormatContext);
    }
    public locationSpec(): LocationSpecContext[];
    public locationSpec(i: number): LocationSpecContext | null;
    public locationSpec(i?: number): LocationSpecContext[] | LocationSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LocationSpecContext);
        }

        return this.getRuleContext(i, LocationSpecContext);
    }
    public commentSpec(): CommentSpecContext[];
    public commentSpec(i: number): CommentSpecContext | null;
    public commentSpec(i?: number): CommentSpecContext[] | CommentSpecContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CommentSpecContext);
        }

        return this.getRuleContext(i, CommentSpecContext);
    }
    public tableLifecycle(): TableLifecycleContext[];
    public tableLifecycle(i: number): TableLifecycleContext | null;
    public tableLifecycle(i?: number): TableLifecycleContext[] | TableLifecycleContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TableLifecycleContext);
        }

        return this.getRuleContext(i, TableLifecycleContext);
    }
    public KW_OPTIONS(): antlr.TerminalNode[];
    public KW_OPTIONS(i: number): antlr.TerminalNode | null;
    public KW_OPTIONS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_OPTIONS);
    	} else {
    		return this.getToken(SparkSqlParser.KW_OPTIONS, i);
    	}
    }
    public KW_PARTITIONED(): antlr.TerminalNode[];
    public KW_PARTITIONED(i: number): antlr.TerminalNode | null;
    public KW_PARTITIONED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_PARTITIONED);
    	} else {
    		return this.getToken(SparkSqlParser.KW_PARTITIONED, i);
    	}
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_BY);
    	} else {
    		return this.getToken(SparkSqlParser.KW_BY, i);
    	}
    }
    public KW_TBLPROPERTIES(): antlr.TerminalNode[];
    public KW_TBLPROPERTIES(i: number): antlr.TerminalNode | null;
    public KW_TBLPROPERTIES(i?: number): antlr.TerminalNode | null | antlr.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 | null;
    public expressionPropertyList(i?: number): ExpressionPropertyListContext[] | ExpressionPropertyListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionPropertyListContext);
        }

        return this.getRuleContext(i, ExpressionPropertyListContext);
    }
    public partitionFieldList(): PartitionFieldListContext[];
    public partitionFieldList(i: number): PartitionFieldListContext | null;
    public partitionFieldList(i?: number): PartitionFieldListContext[] | PartitionFieldListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionFieldListContext);
        }

        return this.getRuleContext(i, PartitionFieldListContext);
    }
    public propertyList(): PropertyListContext[];
    public propertyList(i: number): PropertyListContext | null;
    public propertyList(i?: number): PropertyListContext[] | PropertyListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PropertyListContext);
        }

        return this.getRuleContext(i, PropertyListContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_createTableClauses;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateTableClauses) {
             listener.enterCreateTableClauses(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateTableClauses) {
             listener.exitCreateTableClauses(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateTableClauses) {
            return visitor.visitCreateTableClauses(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class TableLifecycleContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_LIFECYCLE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_LIFECYCLE, 0)!;
    }
    public INTEGER_VALUE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.INTEGER_VALUE, 0)!;
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_tableLifecycle;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterTableLifecycle) {
             listener.enterTableLifecycle(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitTableLifecycle) {
             listener.exitTableLifecycle(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitTableLifecycle) {
            return visitor.visitTableLifecycle(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PropertyListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public property(): PropertyContext[];
    public property(i: number): PropertyContext | null;
    public property(i?: number): PropertyContext[] | PropertyContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PropertyContext);
        }

        return this.getRuleContext(i, PropertyContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_propertyList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPropertyList) {
             listener.enterPropertyList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPropertyList) {
             listener.exitPropertyList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPropertyList) {
            return visitor.visitPropertyList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class PropertyKeyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.DOT);
    	} else {
    		return this.getToken(SparkSqlParser.DOT, i);
    	}
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_propertyKey;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPropertyKey) {
             listener.enterPropertyKey(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPropertyKey) {
             listener.exitPropertyKey(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPropertyKey) {
            return visitor.visitPropertyKey(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class ExpressionPropertyListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public expressionProperty(): ExpressionPropertyContext[];
    public expressionProperty(i: number): ExpressionPropertyContext | null;
    public expressionProperty(i?: number): ExpressionPropertyContext[] | ExpressionPropertyContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionPropertyContext);
        }

        return this.getRuleContext(i, ExpressionPropertyContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_expressionPropertyList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterExpressionPropertyList) {
             listener.enterExpressionPropertyList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitExpressionPropertyList) {
             listener.exitExpressionPropertyList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitExpressionPropertyList) {
            return visitor.visitExpressionPropertyList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class ConstantListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public constant(): ConstantContext[];
    public constant(i: number): ConstantContext | null;
    public constant(i?: number): ConstantContext[] | ConstantContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ConstantContext);
        }

        return this.getRuleContext(i, ConstantContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_constantList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterConstantList) {
             listener.enterConstantList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitConstantList) {
             listener.exitConstantList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitConstantList) {
            return visitor.visitConstantList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class NestedConstantListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public constantList(): ConstantListContext[];
    public constantList(i: number): ConstantListContext | null;
    public constantList(i?: number): ConstantListContext[] | ConstantListContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ConstantListContext);
        }

        return this.getRuleContext(i, ConstantListContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_nestedConstantList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNestedConstantList) {
             listener.enterNestedConstantList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNestedConstantList) {
             listener.exitNestedConstantList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNestedConstantList) {
            return visitor.visitNestedConstantList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class FileFormatContext extends antlr.ParserRuleContext {
    public _inFmt?: StringLitContext;
    public _outFmt?: StringLitContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_INPUTFORMAT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_INPUTFORMAT, 0);
    }
    public KW_OUTPUTFORMAT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OUTPUTFORMAT, 0);
    }
    public stringLit(): StringLitContext[];
    public stringLit(i: number): StringLitContext | null;
    public stringLit(i?: number): StringLitContext[] | StringLitContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLitContext);
        }

        return this.getRuleContext(i, StringLitContext);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_fileFormat;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterFileFormat) {
             listener.enterFileFormat(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitFileFormat) {
             listener.exitFileFormat(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitFileFormat) {
            return visitor.visitFileFormat(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class DmlStatementNoWithContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_dmlStatementNoWith;
    }
    public override copyFrom(ctx: DmlStatementNoWithContext): void {
        super.copyFrom(ctx);
    }
}
export class DeleteFromTableContext extends DmlStatementNoWithContext {
    public constructor(ctx: DmlStatementNoWithContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_DELETE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_DELETE, 0)!;
    }
    public KW_FROM(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FROM, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public tableAlias(): TableAliasContext {
        return this.getRuleContext(0, TableAliasContext)!;
    }
    public whereClause(): WhereClauseContext | null {
        return this.getRuleContext(0, WhereClauseContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDeleteFromTable) {
             listener.enterDeleteFromTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDeleteFromTable) {
             listener.exitDeleteFromTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDeleteFromTable) {
            return visitor.visitDeleteFromTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class MultipleInsertContext extends DmlStatementNoWithContext {
    public constructor(ctx: DmlStatementNoWithContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public fromClause(): FromClauseContext {
        return this.getRuleContext(0, FromClauseContext)!;
    }
    public multiInsertQueryBody(): MultiInsertQueryBodyContext[];
    public multiInsertQueryBody(i: number): MultiInsertQueryBodyContext | null;
    public multiInsertQueryBody(i?: number): MultiInsertQueryBodyContext[] | MultiInsertQueryBodyContext | null {
        if (i === undefined) {
            return this.getRuleContexts(MultiInsertQueryBodyContext);
        }

        return this.getRuleContext(i, MultiInsertQueryBodyContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterMultipleInsert) {
             listener.enterMultipleInsert(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitMultipleInsert) {
             listener.exitMultipleInsert(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitMultipleInsert) {
            return visitor.visitMultipleInsert(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class UpdateTableContext extends DmlStatementNoWithContext {
    public constructor(ctx: DmlStatementNoWithContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_UPDATE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_UPDATE, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public tableAlias(): TableAliasContext {
        return this.getRuleContext(0, TableAliasContext)!;
    }
    public setClause(): SetClauseContext {
        return this.getRuleContext(0, SetClauseContext)!;
    }
    public whereClause(): WhereClauseContext | null {
        return this.getRuleContext(0, WhereClauseContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUpdateTable) {
             listener.enterUpdateTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUpdateTable) {
             listener.exitUpdateTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUpdateTable) {
            return visitor.visitUpdateTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class InsertFromQueryContext extends DmlStatementNoWithContext {
    public constructor(ctx: DmlStatementNoWithContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public insertInto(): InsertIntoContext {
        return this.getRuleContext(0, InsertIntoContext)!;
    }
    public query(): QueryContext {
        return this.getRuleContext(0, QueryContext)!;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterInsertFromQuery) {
             listener.enterInsertFromQuery(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitInsertFromQuery) {
             listener.exitInsertFromQuery(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitInsertFromQuery) {
            return visitor.visitInsertFromQuery(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}
export class MergeIntoTableContext extends DmlStatementNoWithContext {
    public _target?: TableNameContext;
    public _targetAlias?: TableAliasContext;
    public _source?: IdentifierReferenceContext;
    public _sourceQuery?: QueryContext;
    public _sourceAlias?: TableAliasContext;
    public _mergeCondition?: BooleanExpressionContext;
    public constructor(ctx: DmlStatementNoWithContext) {
        super(ctx.parent, ctx.invokingState);
        super.copyFrom(ctx);
    }
    public KW_MERGE(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_MERGE, 0)!;
    }
    public KW_INTO(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INTO, 0)!;
    }
    public KW_USING(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_USING, 0)!;
    }
    public KW_ON(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ON, 0)!;
    }
    public tableName(): TableNameContext {
        return this.getRuleContext(0, TableNameContext)!;
    }
    public tableAlias(): TableAliasContext[];
    public tableAlias(i: number): TableAliasContext | null;
    public tableAlias(i?: number): TableAliasContext[] | TableAliasContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TableAliasContext);
        }

        return this.getRuleContext(i, TableAliasContext);
    }
    public booleanExpression(): BooleanExpressionContext {
        return this.getRuleContext(0, BooleanExpressionContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public identifierReference(): IdentifierReferenceContext | null {
        return this.getRuleContext(0, IdentifierReferenceContext);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public matchedClause(): MatchedClauseContext[];
    public matchedClause(i: number): MatchedClauseContext | null;
    public matchedClause(i?: number): MatchedClauseContext[] | MatchedClauseContext | null {
        if (i === undefined) {
            return this.getRuleContexts(MatchedClauseContext);
        }

        return this.getRuleContext(i, MatchedClauseContext);
    }
    public notMatchedClause(): NotMatchedClauseContext[];
    public notMatchedClause(i: number): NotMatchedClauseContext | null;
    public notMatchedClause(i?: number): NotMatchedClauseContext[] | NotMatchedClauseContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NotMatchedClauseContext);
        }

        return this.getRuleContext(i, NotMatchedClauseContext);
    }
    public notMatchedBySourceClause(): NotMatchedBySourceClauseContext[];
    public notMatchedBySourceClause(i: number): NotMatchedBySourceClauseContext | null;
    public notMatchedBySourceClause(i?: number): NotMatchedBySourceClauseContext[] | NotMatchedBySourceClauseContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NotMatchedBySourceClauseContext);
        }

        return this.getRuleContext(i, NotMatchedBySourceClauseContext);
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterMergeIntoTable) {
             listener.enterMergeIntoTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitMergeIntoTable) {
             listener.exitMergeIntoTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitMergeIntoTable) {
            return visitor.visitMergeIntoTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class NamespaceNameContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifierReference(): IdentifierReferenceContext {
        return this.getRuleContext(0, IdentifierReferenceContext)!;
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_namespaceName;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNamespaceName) {
             listener.enterNamespaceName(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNamespaceName) {
             listener.exitNamespaceName(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNamespaceName) {
            return visitor.visitNamespaceName(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class NamespaceNameCreateContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifierReference(): IdentifierReferenceContext {
        return this.getRuleContext(0, IdentifierReferenceContext)!;
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_namespaceNameCreate;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNamespaceNameCreate) {
             listener.enterNamespaceNameCreate(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNamespaceNameCreate) {
             listener.exitNamespaceNameCreate(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNamespaceNameCreate) {
            return visitor.visitNamespaceNameCreate(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


export class ColumnNameSeqContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public columnName(): ColumnNameContext[];
    public columnName(i: number): ColumnNameContext | null;
    public columnName(i?: number): ColumnNameContext[] | ColumnNameContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ColumnNameContext);
        }

        return this.getRuleContext(i, ColumnNameContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_columnNameSeq;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterColumnNameSeq) {
             listener.enterColumnNameSeq(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitColumnNameSeq) {
             listener.exitColumnNameSeq(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitColumnNameSeq) {
            return visitor.visitColumnNameSeq(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class QueryOrganizationContext extends antlr.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 constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_ORDER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ORDER, 0);
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_BY);
    	} else {
    		return this.getToken(SparkSqlParser.KW_BY, i);
    	}
    }
    public KW_CLUSTER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CLUSTER, 0);
    }
    public KW_DISTRIBUTE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DISTRIBUTE, 0);
    }
    public KW_SORT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SORT, 0);
    }
    public windowClause(): WindowClauseContext | null {
        return this.getRuleContext(0, WindowClauseContext);
    }
    public KW_LIMIT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIMIT, 0);
    }
    public KW_OFFSET(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OFFSET, 0);
    }
    public sortItem(): SortItemContext[];
    public sortItem(i: number): SortItemContext | null;
    public sortItem(i?: number): SortItemContext[] | SortItemContext | null {
        if (i === undefined) {
            return this.getRuleContexts(SortItemContext);
        }

        return this.getRuleContext(i, SortItemContext);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public KW_ALL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ALL, 0);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_queryOrganization;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQueryOrganization) {
             listener.enterQueryOrganization(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQueryOrganization) {
             listener.exitQueryOrganization(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQueryOrganization) {
            return visitor.visitQueryOrganization(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class QueryTermContext extends antlr.ParserRuleContext {
    public _left?: QueryTermContext;
    public _operator?: Token | null;
    public _right?: QueryTermContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public queryPrimary(): QueryPrimaryContext | null {
        return this.getRuleContext(0, QueryPrimaryContext);
    }
    public queryTerm(): QueryTermContext[];
    public queryTerm(i: number): QueryTermContext | null;
    public queryTerm(i?: number): QueryTermContext[] | QueryTermContext | null {
        if (i === undefined) {
            return this.getRuleContexts(QueryTermContext);
        }

        return this.getRuleContext(i, QueryTermContext);
    }
    public KW_INTERSECT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_INTERSECT, 0);
    }
    public KW_UNION(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_UNION, 0);
    }
    public KW_EXCEPT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXCEPT, 0);
    }
    public KW_MINUS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_MINUS, 0);
    }
    public setQuantifier(): SetQuantifierContext | null {
        return this.getRuleContext(0, SetQuantifierContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_queryTerm;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQueryTerm) {
             listener.enterQueryTerm(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQueryTerm) {
             listener.exitQueryTerm(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQueryTerm) {
            return visitor.visitQueryTerm(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class FromStatementContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public fromClause(): FromClauseContext {
        return this.getRuleContext(0, FromClauseContext)!;
    }
    public fromStatementBody(): FromStatementBodyContext[];
    public fromStatementBody(i: number): FromStatementBodyContext | null;
    public fromStatementBody(i?: number): FromStatementBodyContext[] | FromStatementBodyContext | null {
        if (i === undefined) {
            return this.getRuleContexts(FromStatementBodyContext);
        }

        return this.getRuleContext(i, FromStatementBodyContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_fromStatement;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterFromStatement) {
             listener.enterFromStatement(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitFromStatement) {
             listener.exitFromStatement(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitFromStatement) {
            return visitor.visitFromStatement(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class FromStatementBodyContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public transformClause(): TransformClauseContext | null {
        return this.getRuleContext(0, TransformClauseContext);
    }
    public queryOrganization(): QueryOrganizationContext {
        return this.getRuleContext(0, QueryOrganizationContext)!;
    }
    public whereClause(): WhereClauseContext | null {
        return this.getRuleContext(0, WhereClauseContext);
    }
    public selectClause(): SelectClauseContext | null {
        return this.getRuleContext(0, SelectClauseContext);
    }
    public lateralView(): LateralViewContext[];
    public lateralView(i: number): LateralViewContext | null;
    public lateralView(i?: number): LateralViewContext[] | LateralViewContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LateralViewContext);
        }

        return this.getRuleContext(i, LateralViewContext);
    }
    public aggregationClause(): AggregationClauseContext | null {
        return this.getRuleContext(0, AggregationClauseContext);
    }
    public havingClause(): HavingClauseContext | null {
        return this.getRuleContext(0, HavingClauseContext);
    }
    public windowClause(): WindowClauseContext | null {
        return this.getRuleContext(0, WindowClauseContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_fromStatementBody;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterFromStatementBody) {
             listener.enterFromStatementBody(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitFromStatementBody) {
             listener.exitFromStatementBody(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitFromStatementBody) {
            return visitor.visitFromStatementBody(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class QuerySpecificationContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public transformClause(): TransformClauseContext | null {
        return this.getRuleContext(0, TransformClauseContext);
    }
    public fromClause(): FromClauseContext | null {
        return this.getRuleContext(0, FromClauseContext);
    }
    public lateralView(): LateralViewContext[];
    public lateralView(i: number): LateralViewContext | null;
    public lateralView(i?: number): LateralViewContext[] | LateralViewContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LateralViewContext);
        }

        return this.getRuleContext(i, LateralViewContext);
    }
    public whereClause(): WhereClauseContext | null {
        return this.getRuleContext(0, WhereClauseContext);
    }
    public aggregationClause(): AggregationClauseContext | null {
        return this.getRuleContext(0, AggregationClauseContext);
    }
    public havingClause(): HavingClauseContext | null {
        return this.getRuleContext(0, HavingClauseContext);
    }
    public windowClause(): WindowClauseContext | null {
        return this.getRuleContext(0, WindowClauseContext);
    }
    public selectClause(): SelectClauseContext | null {
        return this.getRuleContext(0, SelectClauseContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_querySpecification;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQuerySpecification) {
             listener.enterQuerySpecification(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQuerySpecification) {
             listener.exitQuerySpecification(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQuerySpecification) {
            return visitor.visitQuerySpecification(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class TransformClauseContext extends antlr.ParserRuleContext {
    public _kind?: Token | null;
    public _inRowFormat?: RowFormatContext;
    public _recordWriter?: StringLitContext;
    public _script?: StringLitContext;
    public _outRowFormat?: RowFormatContext;
    public _recordReader?: StringLitContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_USING(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_USING, 0)!;
    }
    public stringLit(): StringLitContext[];
    public stringLit(i: number): StringLitContext | null;
    public stringLit(i?: number): StringLitContext[] | StringLitContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLitContext);
        }

        return this.getRuleContext(i, StringLitContext);
    }
    public KW_SELECT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SELECT, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public expressionSeq(): ExpressionSeqContext | null {
        return this.getRuleContext(0, ExpressionSeqContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.RIGHT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
    	}
    }
    public KW_TRANSFORM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TRANSFORM, 0);
    }
    public KW_MAP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_MAP, 0);
    }
    public KW_REDUCE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_REDUCE, 0);
    }
    public KW_RECORDWRITER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_RECORDWRITER, 0);
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public KW_RECORDREADER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_RECORDREADER, 0);
    }
    public rowFormat(): RowFormatContext[];
    public rowFormat(i: number): RowFormatContext | null;
    public rowFormat(i?: number): RowFormatContext[] | RowFormatContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RowFormatContext);
        }

        return this.getRuleContext(i, RowFormatContext);
    }
    public setQuantifier(): SetQuantifierContext | null {
        return this.getRuleContext(0, SetQuantifierContext);
    }
    public identifierSeq(): IdentifierSeqContext | null {
        return this.getRuleContext(0, IdentifierSeqContext);
    }
    public colTypeList(): ColTypeListContext | null {
        return this.getRuleContext(0, ColTypeListContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_transformClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterTransformClause) {
             listener.enterTransformClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitTransformClause) {
             listener.exitTransformClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitTransformClause) {
            return visitor.visitTransformClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class SelectClauseContext extends antlr.ParserRuleContext {
    public _hint?: HintContext;
    public _hints: HintContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_SELECT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_SELECT, 0)!;
    }
    public namedExpressionSeq(): NamedExpressionSeqContext {
        return this.getRuleContext(0, NamedExpressionSeqContext)!;
    }
    public setQuantifier(): SetQuantifierContext | null {
        return this.getRuleContext(0, SetQuantifierContext);
    }
    public hint(): HintContext[];
    public hint(i: number): HintContext | null;
    public hint(i?: number): HintContext[] | HintContext | null {
        if (i === undefined) {
            return this.getRuleContexts(HintContext);
        }

        return this.getRuleContext(i, HintContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_selectClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterSelectClause) {
             listener.enterSelectClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitSelectClause) {
             listener.exitSelectClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitSelectClause) {
            return visitor.visitSelectClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


export class NotMatchedActionContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_INSERT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_INSERT, 0)!;
    }
    public ASTERISK(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.ASTERISK, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public multipartIdentifierList(): MultipartIdentifierListContext | null {
        return this.getRuleContext(0, MultipartIdentifierListContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.RIGHT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
    	}
    }
    public KW_VALUES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_VALUES, 0);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_notMatchedAction;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNotMatchedAction) {
             listener.enterNotMatchedAction(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNotMatchedAction) {
             listener.exitNotMatchedAction(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNotMatchedAction) {
            return visitor.visitNotMatchedAction(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class AssignmentListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public assignment(): AssignmentContext[];
    public assignment(i: number): AssignmentContext | null;
    public assignment(i?: number): AssignmentContext[] | AssignmentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(AssignmentContext);
        }

        return this.getRuleContext(i, AssignmentContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_assignmentList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAssignmentList) {
             listener.enterAssignmentList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAssignmentList) {
             listener.exitAssignmentList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAssignmentList) {
            return visitor.visitAssignmentList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


export class HintContext extends antlr.ParserRuleContext {
    public _hintStatement?: HintStatementContext;
    public _hintStatements: HintStatementContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public HENT_START(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.HENT_START, 0)!;
    }
    public HENT_END(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.HENT_END, 0)!;
    }
    public hintStatement(): HintStatementContext[];
    public hintStatement(i: number): HintStatementContext | null;
    public hintStatement(i?: number): HintStatementContext[] | HintStatementContext | null {
        if (i === undefined) {
            return this.getRuleContexts(HintStatementContext);
        }

        return this.getRuleContext(i, HintStatementContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_hint;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterHint) {
             listener.enterHint(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitHint) {
             listener.exitHint(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitHint) {
            return visitor.visitHint(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class HintStatementContext extends antlr.ParserRuleContext {
    public _hintName?: IdentifierContext;
    public _primaryExpression?: PrimaryExpressionContext;
    public _parameters: PrimaryExpressionContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext {
        return this.getRuleContext(0, IdentifierContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public primaryExpression(): PrimaryExpressionContext[];
    public primaryExpression(i: number): PrimaryExpressionContext | null;
    public primaryExpression(i?: number): PrimaryExpressionContext[] | PrimaryExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PrimaryExpressionContext);
        }

        return this.getRuleContext(i, PrimaryExpressionContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_hintStatement;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterHintStatement) {
             listener.enterHintStatement(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitHintStatement) {
             listener.exitHintStatement(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitHintStatement) {
            return visitor.visitHintStatement(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class FromClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_FROM(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FROM, 0)!;
    }
    public relation(): RelationContext[];
    public relation(i: number): RelationContext | null;
    public relation(i?: number): RelationContext[] | RelationContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RelationContext);
        }

        return this.getRuleContext(i, RelationContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public lateralView(): LateralViewContext[];
    public lateralView(i: number): LateralViewContext | null;
    public lateralView(i?: number): LateralViewContext[] | LateralViewContext | null {
        if (i === undefined) {
            return this.getRuleContexts(LateralViewContext);
        }

        return this.getRuleContext(i, LateralViewContext);
    }
    public pivotClause(): PivotClauseContext | null {
        return this.getRuleContext(0, PivotClauseContext);
    }
    public unpivotClause(): UnpivotClauseContext | null {
        return this.getRuleContext(0, UnpivotClauseContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_fromClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterFromClause) {
             listener.enterFromClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitFromClause) {
             listener.exitFromClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitFromClause) {
            return visitor.visitFromClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class AggregationClauseContext extends antlr.ParserRuleContext {
    public _groupByClause?: GroupByClauseContext;
    public _groupingExpressionsWithGroupingAnalytics: GroupByClauseContext[] = [];
    public _expression?: ExpressionContext;
    public _groupingExpressions: ExpressionContext[] = [];
    public _kind?: Token | null;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_GROUP(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_GROUP, 0)!;
    }
    public KW_BY(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_BY, 0)!;
    }
    public groupByClause(): GroupByClauseContext[];
    public groupByClause(i: number): GroupByClauseContext | null;
    public groupByClause(i?: number): GroupByClauseContext[] | GroupByClauseContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GroupByClauseContext);
        }

        return this.getRuleContext(i, GroupByClauseContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public KW_WITH(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_WITH, 0);
    }
    public KW_SETS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SETS, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public groupingSet(): GroupingSetContext[];
    public groupingSet(i: number): GroupingSetContext | null;
    public groupingSet(i?: number): GroupingSetContext[] | GroupingSetContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GroupingSetContext);
        }

        return this.getRuleContext(i, GroupingSetContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public KW_ROLLUP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ROLLUP, 0);
    }
    public KW_CUBE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CUBE, 0);
    }
    public KW_GROUPING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_GROUPING, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_aggregationClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterAggregationClause) {
             listener.enterAggregationClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitAggregationClause) {
             listener.exitAggregationClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitAggregationClause) {
            return visitor.visitAggregationClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class GroupingAnalyticsContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public groupingSet(): GroupingSetContext[];
    public groupingSet(i: number): GroupingSetContext | null;
    public groupingSet(i?: number): GroupingSetContext[] | GroupingSetContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GroupingSetContext);
        }

        return this.getRuleContext(i, GroupingSetContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public KW_ROLLUP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ROLLUP, 0);
    }
    public KW_CUBE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CUBE, 0);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public KW_GROUPING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_GROUPING, 0);
    }
    public KW_SETS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SETS, 0);
    }
    public groupingElement(): GroupingElementContext[];
    public groupingElement(i: number): GroupingElementContext | null;
    public groupingElement(i?: number): GroupingElementContext[] | GroupingElementContext | null {
        if (i === undefined) {
            return this.getRuleContexts(GroupingElementContext);
        }

        return this.getRuleContext(i, GroupingElementContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_groupingAnalytics;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterGroupingAnalytics) {
             listener.enterGroupingAnalytics(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitGroupingAnalytics) {
             listener.exitGroupingAnalytics(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitGroupingAnalytics) {
            return visitor.visitGroupingAnalytics(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class GroupingSetContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public columnName(): ColumnNameContext[];
    public columnName(i: number): ColumnNameContext | null;
    public columnName(i?: number): ColumnNameContext[] | ColumnNameContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ColumnNameContext);
        }

        return this.getRuleContext(i, ColumnNameContext);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_groupingSet;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterGroupingSet) {
             listener.enterGroupingSet(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitGroupingSet) {
             listener.exitGroupingSet(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitGroupingSet) {
            return visitor.visitGroupingSet(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PivotClauseContext extends antlr.ParserRuleContext {
    public _aggregates?: NamedExpressionSeqContext;
    public _pivotValue?: PivotValueContext;
    public _pivotValues: PivotValueContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_PIVOT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_PIVOT, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public KW_FOR(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FOR, 0)!;
    }
    public pivotColumn(): PivotColumnContext {
        return this.getRuleContext(0, PivotColumnContext)!;
    }
    public KW_IN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_IN, 0)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.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 | null;
    public pivotValue(i?: number): PivotValueContext[] | PivotValueContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PivotValueContext);
        }

        return this.getRuleContext(i, PivotValueContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_pivotClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPivotClause) {
             listener.enterPivotClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPivotClause) {
             listener.exitPivotClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPivotClause) {
            return visitor.visitPivotClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PivotColumnContext extends antlr.ParserRuleContext {
    public _identifier?: IdentifierContext;
    public _identifiers: IdentifierContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_pivotColumn;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPivotColumn) {
             listener.enterPivotColumn(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPivotColumn) {
             listener.exitPivotColumn(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPivotColumn) {
            return visitor.visitPivotColumn(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


export class UnpivotSingleValueColumnClauseContext extends antlr.ParserRuleContext {
    public _unpivotColumnAndAlias?: UnpivotColumnAndAliasContext;
    public _unpivotColumns: UnpivotColumnAndAliasContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public unpivotValueColumn(): UnpivotValueColumnContext {
        return this.getRuleContext(0, UnpivotValueColumnContext)!;
    }
    public KW_FOR(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FOR, 0)!;
    }
    public unpivotNameColumn(): UnpivotNameColumnContext {
        return this.getRuleContext(0, UnpivotNameColumnContext)!;
    }
    public KW_IN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_IN, 0)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public unpivotColumnAndAlias(): UnpivotColumnAndAliasContext[];
    public unpivotColumnAndAlias(i: number): UnpivotColumnAndAliasContext | null;
    public unpivotColumnAndAlias(i?: number): UnpivotColumnAndAliasContext[] | UnpivotColumnAndAliasContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnpivotColumnAndAliasContext);
        }

        return this.getRuleContext(i, UnpivotColumnAndAliasContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_unpivotSingleValueColumnClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnpivotSingleValueColumnClause) {
             listener.enterUnpivotSingleValueColumnClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnpivotSingleValueColumnClause) {
             listener.exitUnpivotSingleValueColumnClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnpivotSingleValueColumnClause) {
            return visitor.visitUnpivotSingleValueColumnClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class UnpivotMultiValueColumnClauseContext extends antlr.ParserRuleContext {
    public _unpivotValueColumn?: UnpivotValueColumnContext;
    public _unpivotValueColumns: UnpivotValueColumnContext[] = [];
    public _unpivotColumnSet?: UnpivotColumnSetContext;
    public _unpivotColumnSets: UnpivotColumnSetContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.RIGHT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
    	}
    }
    public KW_FOR(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FOR, 0)!;
    }
    public unpivotNameColumn(): UnpivotNameColumnContext {
        return this.getRuleContext(0, UnpivotNameColumnContext)!;
    }
    public KW_IN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_IN, 0)!;
    }
    public unpivotValueColumn(): UnpivotValueColumnContext[];
    public unpivotValueColumn(i: number): UnpivotValueColumnContext | null;
    public unpivotValueColumn(i?: number): UnpivotValueColumnContext[] | UnpivotValueColumnContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnpivotValueColumnContext);
        }

        return this.getRuleContext(i, UnpivotValueColumnContext);
    }
    public unpivotColumnSet(): UnpivotColumnSetContext[];
    public unpivotColumnSet(i: number): UnpivotColumnSetContext | null;
    public unpivotColumnSet(i?: number): UnpivotColumnSetContext[] | UnpivotColumnSetContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnpivotColumnSetContext);
        }

        return this.getRuleContext(i, UnpivotColumnSetContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_unpivotMultiValueColumnClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnpivotMultiValueColumnClause) {
             listener.enterUnpivotMultiValueColumnClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnpivotMultiValueColumnClause) {
             listener.exitUnpivotMultiValueColumnClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnpivotMultiValueColumnClause) {
            return visitor.visitUnpivotMultiValueColumnClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class UnpivotColumnSetContext extends antlr.ParserRuleContext {
    public _unpivotColumn?: UnpivotColumnContext;
    public _unpivotColumns: UnpivotColumnContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public unpivotColumn(): UnpivotColumnContext[];
    public unpivotColumn(i: number): UnpivotColumnContext | null;
    public unpivotColumn(i?: number): UnpivotColumnContext[] | UnpivotColumnContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnpivotColumnContext);
        }

        return this.getRuleContext(i, UnpivotColumnContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public unpivotAlias(): UnpivotAliasContext | null {
        return this.getRuleContext(0, UnpivotAliasContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_unpivotColumnSet;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnpivotColumnSet) {
             listener.enterUnpivotColumnSet(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnpivotColumnSet) {
             listener.exitUnpivotColumnSet(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnpivotColumnSet) {
            return visitor.visitUnpivotColumnSet(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


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


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


export class LateralViewContext extends antlr.ParserRuleContext {
    public _identifier?: IdentifierContext;
    public _colName: IdentifierContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_LATERAL(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_LATERAL, 0)!;
    }
    public KW_VIEW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VIEW, 0)!;
    }
    public viewName(): ViewNameContext {
        return this.getRuleContext(0, ViewNameContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public tableAlias(): TableAliasContext {
        return this.getRuleContext(0, TableAliasContext)!;
    }
    public KW_OUTER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OUTER, 0);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_lateralView;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterLateralView) {
             listener.enterLateralView(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitLateralView) {
             listener.exitLateralView(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitLateralView) {
            return visitor.visitLateralView(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class RelationContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public tableName(): TableNameContext | null {
        return this.getRuleContext(0, TableNameContext);
    }
    public relationPrimary(): RelationPrimaryContext | null {
        return this.getRuleContext(0, RelationPrimaryContext);
    }
    public KW_LATERAL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LATERAL, 0);
    }
    public relationExtension(): RelationExtensionContext[];
    public relationExtension(i: number): RelationExtensionContext | null;
    public relationExtension(i?: number): RelationExtensionContext[] | RelationExtensionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(RelationExtensionContext);
        }

        return this.getRuleContext(i, RelationExtensionContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_relation;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRelation) {
             listener.enterRelation(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRelation) {
             listener.exitRelation(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRelation) {
            return visitor.visitRelation(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


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


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


export class IdentifierSeqContext extends antlr.ParserRuleContext {
    public _errorCapturingIdentifier?: ErrorCapturingIdentifierContext;
    public _ident: ErrorCapturingIdentifierContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null;
    public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ErrorCapturingIdentifierContext);
        }

        return this.getRuleContext(i, ErrorCapturingIdentifierContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_identifierSeq;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterIdentifierSeq) {
             listener.enterIdentifierSeq(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitIdentifierSeq) {
             listener.exitIdentifierSeq(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitIdentifierSeq) {
            return visitor.visitIdentifierSeq(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class OrderedIdentifierListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public orderedIdentifier(): OrderedIdentifierContext[];
    public orderedIdentifier(i: number): OrderedIdentifierContext | null;
    public orderedIdentifier(i?: number): OrderedIdentifierContext[] | OrderedIdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(OrderedIdentifierContext);
        }

        return this.getRuleContext(i, OrderedIdentifierContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_orderedIdentifierList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterOrderedIdentifierList) {
             listener.enterOrderedIdentifierList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitOrderedIdentifierList) {
             listener.exitOrderedIdentifierList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitOrderedIdentifierList) {
            return visitor.visitOrderedIdentifierList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class IdentifierCommentListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public identifierComment(): IdentifierCommentContext[];
    public identifierComment(i: number): IdentifierCommentContext | null;
    public identifierComment(i?: number): IdentifierCommentContext[] | IdentifierCommentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierCommentContext);
        }

        return this.getRuleContext(i, IdentifierCommentContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_identifierCommentList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterIdentifierCommentList) {
             listener.enterIdentifierCommentList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitIdentifierCommentList) {
             listener.exitIdentifierCommentList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitIdentifierCommentList) {
            return visitor.visitIdentifierCommentList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class IdentifierCommentContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public columnNameCreate(): ColumnNameCreateContext {
        return this.getRuleContext(0, ColumnNameCreateContext)!;
    }
    public commentSpec(): CommentSpecContext | null {
        return this.getRuleContext(0, CommentSpecContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_identifierComment;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterIdentifierComment) {
             listener.enterIdentifierComment(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitIdentifierComment) {
             listener.exitIdentifierComment(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitIdentifierComment) {
            return visitor.visitIdentifierComment(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class InlineTableContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_VALUES(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_VALUES, 0)!;
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public tableAlias(): TableAliasContext {
        return this.getRuleContext(0, TableAliasContext)!;
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_inlineTable;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterInlineTable) {
             listener.enterInlineTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitInlineTable) {
             listener.exitInlineTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitInlineTable) {
            return visitor.visitInlineTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class TableArgumentPartitioningContext extends antlr.ParserRuleContext {
    public _expression?: ExpressionContext;
    public _partition: ExpressionContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_BY);
    	} else {
    		return this.getToken(SparkSqlParser.KW_BY, i);
    	}
    }
    public KW_WITH(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_WITH, 0);
    }
    public KW_SINGLE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SINGLE, 0);
    }
    public KW_PARTITION(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PARTITION, 0);
    }
    public KW_ORDER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ORDER, 0);
    }
    public KW_SORT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SORT, 0);
    }
    public KW_DISTRIBUTE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DISTRIBUTE, 0);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public sortItem(): SortItemContext[];
    public sortItem(i: number): SortItemContext | null;
    public sortItem(i?: number): SortItemContext[] | SortItemContext | null {
        if (i === undefined) {
            return this.getRuleContexts(SortItemContext);
        }

        return this.getRuleContext(i, SortItemContext);
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.RIGHT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.RIGHT_PAREN, i);
    	}
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_tableArgumentPartitioning;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterTableArgumentPartitioning) {
             listener.enterTableArgumentPartitioning(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitTableArgumentPartitioning) {
             listener.exitTableArgumentPartitioning(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitTableArgumentPartitioning) {
            return visitor.visitTableArgumentPartitioning(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


export class FunctionTableContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public functionName(): FunctionNameContext {
        return this.getRuleContext(0, FunctionNameContext)!;
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public tableAlias(): TableAliasContext {
        return this.getRuleContext(0, TableAliasContext)!;
    }
    public functionTableArgument(): FunctionTableArgumentContext[];
    public functionTableArgument(i: number): FunctionTableArgumentContext | null;
    public functionTableArgument(i?: number): FunctionTableArgumentContext[] | FunctionTableArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(FunctionTableArgumentContext);
        }

        return this.getRuleContext(i, FunctionTableArgumentContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_functionTable;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterFunctionTable) {
             listener.enterFunctionTable(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitFunctionTable) {
             listener.exitFunctionTable(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitFunctionTable) {
            return visitor.visitFunctionTable(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class RowFormatContext extends antlr.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 constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_ROW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ROW, 0)!;
    }
    public KW_FORMAT(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_FORMAT, 0)!;
    }
    public KW_SERDE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SERDE, 0);
    }
    public stringLit(): StringLitContext[];
    public stringLit(i: number): StringLitContext | null;
    public stringLit(i?: number): StringLitContext[] | StringLitContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLitContext);
        }

        return this.getRuleContext(i, StringLitContext);
    }
    public KW_WITH(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_WITH, 0);
    }
    public KW_SERDEPROPERTIES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SERDEPROPERTIES, 0);
    }
    public propertyList(): PropertyListContext | null {
        return this.getRuleContext(0, PropertyListContext);
    }
    public KW_DELIMITED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DELIMITED, 0);
    }
    public KW_FIELDS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FIELDS, 0);
    }
    public KW_TERMINATED(): antlr.TerminalNode[];
    public KW_TERMINATED(i: number): antlr.TerminalNode | null;
    public KW_TERMINATED(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_TERMINATED);
    	} else {
    		return this.getToken(SparkSqlParser.KW_TERMINATED, i);
    	}
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_BY);
    	} else {
    		return this.getToken(SparkSqlParser.KW_BY, i);
    	}
    }
    public KW_COLLECTION(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_COLLECTION, 0);
    }
    public KW_ITEMS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ITEMS, 0);
    }
    public KW_MAP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_MAP, 0);
    }
    public KW_KEYS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_KEYS, 0);
    }
    public KW_LINES(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LINES, 0);
    }
    public KW_NULL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NULL, 0);
    }
    public KW_DEFINED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DEFINED, 0);
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public KW_ESCAPED(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ESCAPED, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_rowFormat;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterRowFormat) {
             listener.enterRowFormat(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitRowFormat) {
             listener.exitRowFormat(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitRowFormat) {
            return visitor.visitRowFormat(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class MultipartIdentifierListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public multipartIdentifier(): MultipartIdentifierContext[];
    public multipartIdentifier(i: number): MultipartIdentifierContext | null;
    public multipartIdentifier(i?: number): MultipartIdentifierContext[] | MultipartIdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(MultipartIdentifierContext);
        }

        return this.getRuleContext(i, MultipartIdentifierContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_multipartIdentifierList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterMultipartIdentifierList) {
             listener.enterMultipartIdentifierList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitMultipartIdentifierList) {
             listener.exitMultipartIdentifierList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitMultipartIdentifierList) {
            return visitor.visitMultipartIdentifierList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class MultipartIdentifierContext extends antlr.ParserRuleContext {
    public _errorCapturingIdentifier?: ErrorCapturingIdentifierContext;
    public _parts: ErrorCapturingIdentifierContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null;
    public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ErrorCapturingIdentifierContext);
        }

        return this.getRuleContext(i, ErrorCapturingIdentifierContext);
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.DOT);
    	} else {
    		return this.getToken(SparkSqlParser.DOT, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_multipartIdentifier;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterMultipartIdentifier) {
             listener.enterMultipartIdentifier(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitMultipartIdentifier) {
             listener.exitMultipartIdentifier(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitMultipartIdentifier) {
            return visitor.visitMultipartIdentifier(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class MultipartIdentifierPropertyListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public multipartIdentifierProperty(): MultipartIdentifierPropertyContext[];
    public multipartIdentifierProperty(i: number): MultipartIdentifierPropertyContext | null;
    public multipartIdentifierProperty(i?: number): MultipartIdentifierPropertyContext[] | MultipartIdentifierPropertyContext | null {
        if (i === undefined) {
            return this.getRuleContexts(MultipartIdentifierPropertyContext);
        }

        return this.getRuleContext(i, MultipartIdentifierPropertyContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_multipartIdentifierPropertyList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterMultipartIdentifierPropertyList) {
             listener.enterMultipartIdentifierPropertyList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitMultipartIdentifierPropertyList) {
             listener.exitMultipartIdentifierPropertyList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitMultipartIdentifierPropertyList) {
            return visitor.visitMultipartIdentifierPropertyList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class TableIdentifierContext extends antlr.ParserRuleContext {
    public _db?: ErrorCapturingIdentifierContext;
    public _table?: ErrorCapturingIdentifierContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null;
    public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ErrorCapturingIdentifierContext);
        }

        return this.getRuleContext(i, ErrorCapturingIdentifierContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.DOT, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_tableIdentifier;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterTableIdentifier) {
             listener.enterTableIdentifier(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitTableIdentifier) {
             listener.exitTableIdentifier(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitTableIdentifier) {
            return visitor.visitTableIdentifier(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ViewIdentifierContext extends antlr.ParserRuleContext {
    public _db?: ErrorCapturingIdentifierContext;
    public _view?: ErrorCapturingIdentifierContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public errorCapturingIdentifier(): ErrorCapturingIdentifierContext[];
    public errorCapturingIdentifier(i: number): ErrorCapturingIdentifierContext | null;
    public errorCapturingIdentifier(i?: number): ErrorCapturingIdentifierContext[] | ErrorCapturingIdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ErrorCapturingIdentifierContext);
        }

        return this.getRuleContext(i, ErrorCapturingIdentifierContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.DOT, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_viewIdentifier;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterViewIdentifier) {
             listener.enterViewIdentifier(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitViewIdentifier) {
             listener.exitViewIdentifier(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitViewIdentifier) {
            return visitor.visitViewIdentifier(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class NamedExpressionSeqContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public namedExpression(): NamedExpressionContext[];
    public namedExpression(i: number): NamedExpressionContext | null;
    public namedExpression(i?: number): NamedExpressionContext[] | NamedExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NamedExpressionContext);
        }

        return this.getRuleContext(i, NamedExpressionContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_namedExpressionSeq;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterNamedExpressionSeq) {
             listener.enterNamedExpressionSeq(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitNamedExpressionSeq) {
             listener.exitNamedExpressionSeq(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitNamedExpressionSeq) {
            return visitor.visitNamedExpressionSeq(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PartitionFieldListContext extends antlr.ParserRuleContext {
    public _partitionField?: PartitionFieldContext;
    public _fields: PartitionFieldContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LEFT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0)!;
    }
    public RIGHT_PAREN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0)!;
    }
    public partitionField(): PartitionFieldContext[];
    public partitionField(i: number): PartitionFieldContext | null;
    public partitionField(i?: number): PartitionFieldContext[] | PartitionFieldContext | null {
        if (i === undefined) {
            return this.getRuleContexts(PartitionFieldContext);
        }

        return this.getRuleContext(i, PartitionFieldContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_partitionFieldList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPartitionFieldList) {
             listener.enterPartitionFieldList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPartitionFieldList) {
             listener.exitPartitionFieldList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPartitionFieldList) {
            return visitor.visitPartitionFieldList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class TransformContext extends antlr.ParserRuleContext {
    public _transformName?: IdentifierContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public qualifiedName(): QualifiedNameContext | null {
        return this.getRuleContext(0, QualifiedNameContext);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public transformArgument(): TransformArgumentContext[];
    public transformArgument(i: number): TransformArgumentContext | null;
    public transformArgument(i?: number): TransformArgumentContext[] | TransformArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(TransformArgumentContext);
        }

        return this.getRuleContext(i, TransformArgumentContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_transform;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterTransform) {
             listener.enterTransform(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitTransform) {
             listener.exitTransform(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitTransform) {
            return visitor.visitTransform(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


export class ExpressionSeqContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_expressionSeq;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterExpressionSeq) {
             listener.enterExpressionSeq(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitExpressionSeq) {
             listener.exitExpressionSeq(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitExpressionSeq) {
            return visitor.visitExpressionSeq(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class BooleanExpressionContext extends antlr.ParserRuleContext {
    public _left?: BooleanExpressionContext;
    public _operator?: Token | null;
    public _right?: BooleanExpressionContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public booleanExpression(): BooleanExpressionContext[];
    public booleanExpression(i: number): BooleanExpressionContext | null;
    public booleanExpression(i?: number): BooleanExpressionContext[] | BooleanExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(BooleanExpressionContext);
        }

        return this.getRuleContext(i, BooleanExpressionContext);
    }
    public KW_NOT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NOT, 0);
    }
    public NOT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.NOT, 0);
    }
    public KW_EXISTS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXISTS, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public valueExpression(): ValueExpressionContext | null {
        return this.getRuleContext(0, ValueExpressionContext);
    }
    public predicate(): PredicateContext | null {
        return this.getRuleContext(0, PredicateContext);
    }
    public KW_AND(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AND, 0);
    }
    public KW_OR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OR, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_booleanExpression;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterBooleanExpression) {
             listener.enterBooleanExpression(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitBooleanExpression) {
             listener.exitBooleanExpression(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitBooleanExpression) {
            return visitor.visitBooleanExpression(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class PredicateContext extends antlr.ParserRuleContext {
    public _kind?: Token | null;
    public _lower?: ValueExpressionContext;
    public _upper?: ValueExpressionContext;
    public _pattern?: ValueExpressionContext;
    public _quantifier?: Token | null;
    public _escapeChar?: StringLitContext;
    public _right?: ValueExpressionContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_AND(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AND, 0);
    }
    public KW_BETWEEN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_BETWEEN, 0);
    }
    public valueExpression(): ValueExpressionContext[];
    public valueExpression(i: number): ValueExpressionContext | null;
    public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueExpressionContext);
        }

        return this.getRuleContext(i, ValueExpressionContext);
    }
    public KW_NOT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NOT, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public KW_RLIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_RLIKE, 0);
    }
    public KW_REGEXP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_REGEXP, 0);
    }
    public KW_LIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LIKE, 0);
    }
    public KW_ILIKE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ILIKE, 0);
    }
    public KW_ANY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ANY, 0);
    }
    public KW_SOME(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SOME, 0);
    }
    public KW_ALL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ALL, 0);
    }
    public KW_ESCAPE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ESCAPE, 0);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_IS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IS, 0);
    }
    public KW_NULL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NULL, 0);
    }
    public KW_TRUE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TRUE, 0);
    }
    public KW_FALSE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FALSE, 0);
    }
    public KW_UNKNOWN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_UNKNOWN, 0);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_DISTINCT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DISTINCT, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_predicate;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPredicate) {
             listener.enterPredicate(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPredicate) {
             listener.exitPredicate(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPredicate) {
            return visitor.visitPredicate(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ValueExpressionContext extends antlr.ParserRuleContext {
    public _left?: ValueExpressionContext;
    public _operator?: Token | null;
    public _right?: ValueExpressionContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public primaryExpression(): PrimaryExpressionContext | null {
        return this.getRuleContext(0, PrimaryExpressionContext);
    }
    public valueExpression(): ValueExpressionContext[];
    public valueExpression(i: number): ValueExpressionContext | null;
    public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueExpressionContext);
        }

        return this.getRuleContext(i, ValueExpressionContext);
    }
    public MINUS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.MINUS, 0);
    }
    public PLUS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.PLUS, 0);
    }
    public TILDE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.TILDE, 0);
    }
    public ASTERISK(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.ASTERISK, 0);
    }
    public SLASH(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.SLASH, 0);
    }
    public PERCENT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.PERCENT, 0);
    }
    public KW_DIV(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DIV, 0);
    }
    public CONCAT_PIPE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.CONCAT_PIPE, 0);
    }
    public AMPERSAND(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.AMPERSAND, 0);
    }
    public HAT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.HAT, 0);
    }
    public PIPE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.PIPE, 0);
    }
    public comparisonOperator(): ComparisonOperatorContext | null {
        return this.getRuleContext(0, ComparisonOperatorContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_valueExpression;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterValueExpression) {
             listener.enterValueExpression(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitValueExpression) {
             listener.exitValueExpression(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitValueExpression) {
            return visitor.visitValueExpression(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class PrimaryExpressionContext extends antlr.ParserRuleContext {
    public _value?: PrimaryExpressionContext;
    public _base?: PrimaryExpressionContext;
    public _name?: Token | null;
    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 | null;
    public _field?: IdentifierContext;
    public _source?: ValueExpressionContext;
    public _pos?: ValueExpressionContext;
    public _len?: ValueExpressionContext;
    public _trimOption?: Token | null;
    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 constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_CURRENT_DATE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CURRENT_DATE, 0);
    }
    public KW_CURRENT_TIMESTAMP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CURRENT_TIMESTAMP, 0);
    }
    public KW_CURRENT_USER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CURRENT_USER, 0);
    }
    public KW_USER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_USER, 0);
    }
    public KW_SESSION_USER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SESSION_USER, 0);
    }
    public LEFT_PAREN(): antlr.TerminalNode[];
    public LEFT_PAREN(i: number): antlr.TerminalNode | null;
    public LEFT_PAREN(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.LEFT_PAREN);
    	} else {
    		return this.getToken(SparkSqlParser.LEFT_PAREN, i);
    	}
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public RIGHT_PAREN(): antlr.TerminalNode[];
    public RIGHT_PAREN(i: number): antlr.TerminalNode | null;
    public RIGHT_PAREN(i?: number): antlr.TerminalNode | null | antlr.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 | null;
    public valueExpression(i?: number): ValueExpressionContext[] | ValueExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ValueExpressionContext);
        }

        return this.getRuleContext(i, ValueExpressionContext);
    }
    public KW_TIMESTAMPADD(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TIMESTAMPADD, 0);
    }
    public KW_DATEADD(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DATEADD, 0);
    }
    public KW_DATE_ADD(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DATE_ADD, 0);
    }
    public datetimeUnit(): DatetimeUnitContext | null {
        return this.getRuleContext(0, DatetimeUnitContext);
    }
    public stringLit(): StringLitContext | null {
        return this.getRuleContext(0, StringLitContext);
    }
    public KW_TIMESTAMPDIFF(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TIMESTAMPDIFF, 0);
    }
    public KW_DATEDIFF(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DATEDIFF, 0);
    }
    public KW_DATE_DIFF(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DATE_DIFF, 0);
    }
    public KW_TIMEDIFF(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TIMEDIFF, 0);
    }
    public KW_CASE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CASE, 0);
    }
    public KW_END(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_END, 0);
    }
    public whenClause(): WhenClauseContext[];
    public whenClause(i: number): WhenClauseContext | null;
    public whenClause(i?: number): WhenClauseContext[] | WhenClauseContext | null {
        if (i === undefined) {
            return this.getRuleContexts(WhenClauseContext);
        }

        return this.getRuleContext(i, WhenClauseContext);
    }
    public KW_ELSE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ELSE, 0);
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public KW_AS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AS, 0);
    }
    public dataType(): DataTypeContext | null {
        return this.getRuleContext(0, DataTypeContext);
    }
    public KW_CAST(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CAST, 0);
    }
    public KW_TRY_CAST(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TRY_CAST, 0);
    }
    public KW_STRUCT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_STRUCT, 0);
    }
    public namedExpression(): NamedExpressionContext[];
    public namedExpression(i: number): NamedExpressionContext | null;
    public namedExpression(i?: number): NamedExpressionContext[] | NamedExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NamedExpressionContext);
        }

        return this.getRuleContext(i, NamedExpressionContext);
    }
    public KW_FIRST(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FIRST, 0);
    }
    public KW_IGNORE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IGNORE, 0);
    }
    public KW_NULLS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NULLS, 0);
    }
    public KW_ANY_VALUE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ANY_VALUE, 0);
    }
    public KW_LAST(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LAST, 0);
    }
    public KW_POSITION(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_POSITION, 0);
    }
    public KW_IN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IN, 0);
    }
    public constant(): ConstantContext | null {
        return this.getRuleContext(0, ConstantContext);
    }
    public ASTERISK(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.ASTERISK, 0);
    }
    public qualifiedName(): QualifiedNameContext | null {
        return this.getRuleContext(0, QualifiedNameContext);
    }
    public DOT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.DOT, 0);
    }
    public query(): QueryContext | null {
        return this.getRuleContext(0, QueryContext);
    }
    public KW_IDENTIFIER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_IDENTIFIER, 0);
    }
    public functionName(): FunctionNameContext | null {
        return this.getRuleContext(0, FunctionNameContext);
    }
    public functionArgument(): FunctionArgumentContext[];
    public functionArgument(i: number): FunctionArgumentContext | null;
    public functionArgument(i?: number): FunctionArgumentContext[] | FunctionArgumentContext | null {
        if (i === undefined) {
            return this.getRuleContexts(FunctionArgumentContext);
        }

        return this.getRuleContext(i, FunctionArgumentContext);
    }
    public KW_FILTER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FILTER, 0);
    }
    public KW_WHERE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_WHERE, 0);
    }
    public KW_OVER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OVER, 0);
    }
    public windowSpec(): WindowSpecContext | null {
        return this.getRuleContext(0, WindowSpecContext);
    }
    public booleanExpression(): BooleanExpressionContext | null {
        return this.getRuleContext(0, BooleanExpressionContext);
    }
    public KW_RESPECT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_RESPECT, 0);
    }
    public setQuantifier(): SetQuantifierContext | null {
        return this.getRuleContext(0, SetQuantifierContext);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public ARROW(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.ARROW, 0);
    }
    public KW_EXTRACT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_EXTRACT, 0);
    }
    public KW_FROM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FROM, 0);
    }
    public KW_SUBSTR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SUBSTR, 0);
    }
    public KW_SUBSTRING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SUBSTRING, 0);
    }
    public KW_FOR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_FOR, 0);
    }
    public KW_TRIM(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TRIM, 0);
    }
    public KW_BOTH(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_BOTH, 0);
    }
    public KW_LEADING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_LEADING, 0);
    }
    public KW_TRAILING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TRAILING, 0);
    }
    public KW_OVERLAY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_OVERLAY, 0);
    }
    public KW_PLACING(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PLACING, 0);
    }
    public KW_WITHIN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_WITHIN, 0);
    }
    public KW_GROUP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_GROUP, 0);
    }
    public KW_ORDER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ORDER, 0);
    }
    public KW_BY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_BY, 0);
    }
    public sortItem(): SortItemContext | null {
        return this.getRuleContext(0, SortItemContext);
    }
    public KW_PERCENTILE_CONT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PERCENTILE_CONT, 0);
    }
    public KW_PERCENTILE_DISC(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PERCENTILE_DISC, 0);
    }
    public LEFT_BRACKET(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_BRACKET, 0);
    }
    public RIGHT_BRACKET(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_BRACKET, 0);
    }
    public primaryExpression(): PrimaryExpressionContext | null {
        return this.getRuleContext(0, PrimaryExpressionContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_primaryExpression;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterPrimaryExpression) {
             listener.enterPrimaryExpression(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitPrimaryExpression) {
             listener.exitPrimaryExpression(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitPrimaryExpression) {
            return visitor.visitPrimaryExpression(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class ConstantContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_NULL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_NULL, 0);
    }
    public QUESTION(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.QUESTION, 0);
    }
    public COLON(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.COLON, 0);
    }
    public identifier(): IdentifierContext | null {
        return this.getRuleContext(0, IdentifierContext);
    }
    public interval(): IntervalContext | null {
        return this.getRuleContext(0, IntervalContext);
    }
    public literalType(): LiteralTypeContext | null {
        return this.getRuleContext(0, LiteralTypeContext);
    }
    public stringLit(): StringLitContext[];
    public stringLit(i: number): StringLitContext | null;
    public stringLit(i?: number): StringLitContext[] | StringLitContext | null {
        if (i === undefined) {
            return this.getRuleContexts(StringLitContext);
        }

        return this.getRuleContext(i, StringLitContext);
    }
    public number(): NumberContext | null {
        return this.getRuleContext(0, NumberContext);
    }
    public booleanValue(): BooleanValueContext | null {
        return this.getRuleContext(0, BooleanValueContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_constant;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterConstant) {
             listener.enterConstant(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitConstant) {
             listener.exitConstant(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitConstant) {
            return visitor.visitConstant(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


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


export class MultiUnitsIntervalContext extends antlr.ParserRuleContext {
    public _unitInMultiUnits?: UnitInMultiUnitsContext;
    public _unit: UnitInMultiUnitsContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public intervalValue(): IntervalValueContext[];
    public intervalValue(i: number): IntervalValueContext | null;
    public intervalValue(i?: number): IntervalValueContext[] | IntervalValueContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IntervalValueContext);
        }

        return this.getRuleContext(i, IntervalValueContext);
    }
    public unitInMultiUnits(): UnitInMultiUnitsContext[];
    public unitInMultiUnits(i: number): UnitInMultiUnitsContext | null;
    public unitInMultiUnits(i?: number): UnitInMultiUnitsContext[] | UnitInMultiUnitsContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnitInMultiUnitsContext);
        }

        return this.getRuleContext(i, UnitInMultiUnitsContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_multiUnitsInterval;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterMultiUnitsInterval) {
             listener.enterMultiUnitsInterval(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitMultiUnitsInterval) {
             listener.exitMultiUnitsInterval(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitMultiUnitsInterval) {
            return visitor.visitMultiUnitsInterval(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ErrorCapturingUnitToUnitIntervalContext extends antlr.ParserRuleContext {
    public _body?: UnitToUnitIntervalContext;
    public _error1?: MultiUnitsIntervalContext;
    public _error2?: UnitToUnitIntervalContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public unitToUnitInterval(): UnitToUnitIntervalContext[];
    public unitToUnitInterval(i: number): UnitToUnitIntervalContext | null;
    public unitToUnitInterval(i?: number): UnitToUnitIntervalContext[] | UnitToUnitIntervalContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnitToUnitIntervalContext);
        }

        return this.getRuleContext(i, UnitToUnitIntervalContext);
    }
    public multiUnitsInterval(): MultiUnitsIntervalContext | null {
        return this.getRuleContext(0, MultiUnitsIntervalContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_errorCapturingUnitToUnitInterval;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterErrorCapturingUnitToUnitInterval) {
             listener.enterErrorCapturingUnitToUnitInterval(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitErrorCapturingUnitToUnitInterval) {
             listener.exitErrorCapturingUnitToUnitInterval(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitErrorCapturingUnitToUnitInterval) {
            return visitor.visitErrorCapturingUnitToUnitInterval(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class UnitToUnitIntervalContext extends antlr.ParserRuleContext {
    public _value?: IntervalValueContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public unitInUnitToUnit(): UnitInUnitToUnitContext[];
    public unitInUnitToUnit(i: number): UnitInUnitToUnitContext | null;
    public unitInUnitToUnit(i?: number): UnitInUnitToUnitContext[] | UnitInUnitToUnitContext | null {
        if (i === undefined) {
            return this.getRuleContexts(UnitInUnitToUnitContext);
        }

        return this.getRuleContext(i, UnitInUnitToUnitContext);
    }
    public KW_TO(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_TO, 0)!;
    }
    public intervalValue(): IntervalValueContext {
        return this.getRuleContext(0, IntervalValueContext)!;
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_unitToUnitInterval;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterUnitToUnitInterval) {
             listener.enterUnitToUnitInterval(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitUnitToUnitInterval) {
             listener.exitUnitToUnitInterval(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitUnitToUnitInterval) {
            return visitor.visitUnitToUnitInterval(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


export class DataTypeContext extends antlr.ParserRuleContext {
    public _complex?: Token | null;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public LT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LT, 0);
    }
    public dataType(): DataTypeContext[];
    public dataType(i: number): DataTypeContext | null;
    public dataType(i?: number): DataTypeContext[] | DataTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(DataTypeContext);
        }

        return this.getRuleContext(i, DataTypeContext);
    }
    public GT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.GT, 0);
    }
    public KW_ARRAY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ARRAY, 0);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public KW_MAP(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_MAP, 0);
    }
    public KW_STRUCT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_STRUCT, 0);
    }
    public NEQ(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.NEQ, 0);
    }
    public complexColTypeList(): ComplexColTypeListContext | null {
        return this.getRuleContext(0, ComplexColTypeListContext);
    }
    public KW_INTERVAL(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_INTERVAL, 0);
    }
    public KW_YEAR(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_YEAR, 0);
    }
    public KW_MONTH(): antlr.TerminalNode[];
    public KW_MONTH(i: number): antlr.TerminalNode | null;
    public KW_MONTH(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_MONTH);
    	} else {
    		return this.getToken(SparkSqlParser.KW_MONTH, i);
    	}
    }
    public KW_TO(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_TO, 0);
    }
    public KW_DAY(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DAY, 0);
    }
    public KW_HOUR(): antlr.TerminalNode[];
    public KW_HOUR(i: number): antlr.TerminalNode | null;
    public KW_HOUR(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_HOUR);
    	} else {
    		return this.getToken(SparkSqlParser.KW_HOUR, i);
    	}
    }
    public KW_MINUTE(): antlr.TerminalNode[];
    public KW_MINUTE(i: number): antlr.TerminalNode | null;
    public KW_MINUTE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_MINUTE);
    	} else {
    		return this.getToken(SparkSqlParser.KW_MINUTE, i);
    	}
    }
    public KW_SECOND(): antlr.TerminalNode[];
    public KW_SECOND(i: number): antlr.TerminalNode | null;
    public KW_SECOND(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.KW_SECOND);
    	} else {
    		return this.getToken(SparkSqlParser.KW_SECOND, i);
    	}
    }
    public type(): TypeContext | null {
        return this.getRuleContext(0, TypeContext);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public INTEGER_VALUE(): antlr.TerminalNode[];
    public INTEGER_VALUE(i: number): antlr.TerminalNode | null;
    public INTEGER_VALUE(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.INTEGER_VALUE);
    	} else {
    		return this.getToken(SparkSqlParser.INTEGER_VALUE, i);
    	}
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_dataType;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterDataType) {
             listener.enterDataType(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitDataType) {
             listener.exitDataType(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitDataType) {
            return visitor.visitDataType(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class QualifiedColTypeWithPositionSeqForAddContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public qualifiedColTypeWithPositionForAdd(): QualifiedColTypeWithPositionForAddContext[];
    public qualifiedColTypeWithPositionForAdd(i: number): QualifiedColTypeWithPositionForAddContext | null;
    public qualifiedColTypeWithPositionForAdd(i?: number): QualifiedColTypeWithPositionForAddContext[] | QualifiedColTypeWithPositionForAddContext | null {
        if (i === undefined) {
            return this.getRuleContexts(QualifiedColTypeWithPositionForAddContext);
        }

        return this.getRuleContext(i, QualifiedColTypeWithPositionForAddContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForAdd;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQualifiedColTypeWithPositionSeqForAdd) {
             listener.enterQualifiedColTypeWithPositionSeqForAdd(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQualifiedColTypeWithPositionSeqForAdd) {
             listener.exitQualifiedColTypeWithPositionSeqForAdd(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQualifiedColTypeWithPositionSeqForAdd) {
            return visitor.visitQualifiedColTypeWithPositionSeqForAdd(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class QualifiedColTypeWithPositionForAddContext extends antlr.ParserRuleContext {
    public _name?: ColumnNameCreateContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public dataType(): DataTypeContext {
        return this.getRuleContext(0, DataTypeContext)!;
    }
    public columnNameCreate(): ColumnNameCreateContext {
        return this.getRuleContext(0, ColumnNameCreateContext)!;
    }
    public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[];
    public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext | null;
    public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext[] | ColDefinitionDescriptorWithPositionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext);
        }

        return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_qualifiedColTypeWithPositionForAdd;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQualifiedColTypeWithPositionForAdd) {
             listener.enterQualifiedColTypeWithPositionForAdd(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQualifiedColTypeWithPositionForAdd) {
             listener.exitQualifiedColTypeWithPositionForAdd(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQualifiedColTypeWithPositionForAdd) {
            return visitor.visitQualifiedColTypeWithPositionForAdd(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class QualifiedColTypeWithPositionSeqForReplaceContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public qualifiedColTypeWithPositionForReplace(): QualifiedColTypeWithPositionForReplaceContext[];
    public qualifiedColTypeWithPositionForReplace(i: number): QualifiedColTypeWithPositionForReplaceContext | null;
    public qualifiedColTypeWithPositionForReplace(i?: number): QualifiedColTypeWithPositionForReplaceContext[] | QualifiedColTypeWithPositionForReplaceContext | null {
        if (i === undefined) {
            return this.getRuleContexts(QualifiedColTypeWithPositionForReplaceContext);
        }

        return this.getRuleContext(i, QualifiedColTypeWithPositionForReplaceContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_qualifiedColTypeWithPositionSeqForReplace;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQualifiedColTypeWithPositionSeqForReplace) {
             listener.enterQualifiedColTypeWithPositionSeqForReplace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQualifiedColTypeWithPositionSeqForReplace) {
             listener.exitQualifiedColTypeWithPositionSeqForReplace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQualifiedColTypeWithPositionSeqForReplace) {
            return visitor.visitQualifiedColTypeWithPositionSeqForReplace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class QualifiedColTypeWithPositionForReplaceContext extends antlr.ParserRuleContext {
    public _name?: ColumnNameContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public dataType(): DataTypeContext {
        return this.getRuleContext(0, DataTypeContext)!;
    }
    public columnName(): ColumnNameContext {
        return this.getRuleContext(0, ColumnNameContext)!;
    }
    public colDefinitionDescriptorWithPosition(): ColDefinitionDescriptorWithPositionContext[];
    public colDefinitionDescriptorWithPosition(i: number): ColDefinitionDescriptorWithPositionContext | null;
    public colDefinitionDescriptorWithPosition(i?: number): ColDefinitionDescriptorWithPositionContext[] | ColDefinitionDescriptorWithPositionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ColDefinitionDescriptorWithPositionContext);
        }

        return this.getRuleContext(i, ColDefinitionDescriptorWithPositionContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_qualifiedColTypeWithPositionForReplace;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQualifiedColTypeWithPositionForReplace) {
             listener.enterQualifiedColTypeWithPositionForReplace(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQualifiedColTypeWithPositionForReplace) {
             listener.exitQualifiedColTypeWithPositionForReplace(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQualifiedColTypeWithPositionForReplace) {
            return visitor.visitQualifiedColTypeWithPositionForReplace(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


export class ColTypeListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public colType(): ColTypeContext[];
    public colType(i: number): ColTypeContext | null;
    public colType(i?: number): ColTypeContext[] | ColTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ColTypeContext);
        }

        return this.getRuleContext(i, ColTypeContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_colTypeList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterColTypeList) {
             listener.enterColTypeList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitColTypeList) {
             listener.exitColTypeList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitColTypeList) {
            return visitor.visitColTypeList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class CreateOrReplaceTableColTypeListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public createOrReplaceTableColType(): CreateOrReplaceTableColTypeContext[];
    public createOrReplaceTableColType(i: number): CreateOrReplaceTableColTypeContext | null;
    public createOrReplaceTableColType(i?: number): CreateOrReplaceTableColTypeContext[] | CreateOrReplaceTableColTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(CreateOrReplaceTableColTypeContext);
        }

        return this.getRuleContext(i, CreateOrReplaceTableColTypeContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_createOrReplaceTableColTypeList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateOrReplaceTableColTypeList) {
             listener.enterCreateOrReplaceTableColTypeList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateOrReplaceTableColTypeList) {
             listener.exitCreateOrReplaceTableColTypeList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateOrReplaceTableColTypeList) {
            return visitor.visitCreateOrReplaceTableColTypeList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class CreateOrReplaceTableColTypeContext extends antlr.ParserRuleContext {
    public _colName?: ColumnNameCreateContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public dataType(): DataTypeContext {
        return this.getRuleContext(0, DataTypeContext)!;
    }
    public columnNameCreate(): ColumnNameCreateContext {
        return this.getRuleContext(0, ColumnNameCreateContext)!;
    }
    public colDefinitionOption(): ColDefinitionOptionContext[];
    public colDefinitionOption(i: number): ColDefinitionOptionContext | null;
    public colDefinitionOption(i?: number): ColDefinitionOptionContext[] | ColDefinitionOptionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ColDefinitionOptionContext);
        }

        return this.getRuleContext(i, ColDefinitionOptionContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_createOrReplaceTableColType;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterCreateOrReplaceTableColType) {
             listener.enterCreateOrReplaceTableColType(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitCreateOrReplaceTableColType) {
             listener.exitCreateOrReplaceTableColType(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitCreateOrReplaceTableColType) {
            return visitor.visitCreateOrReplaceTableColType(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class ComplexColTypeListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public complexColType(): ComplexColTypeContext[];
    public complexColType(i: number): ComplexColTypeContext | null;
    public complexColType(i?: number): ComplexColTypeContext[] | ComplexColTypeContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ComplexColTypeContext);
        }

        return this.getRuleContext(i, ComplexColTypeContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_complexColTypeList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterComplexColTypeList) {
             listener.enterComplexColTypeList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitComplexColTypeList) {
             listener.exitComplexColTypeList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitComplexColTypeList) {
            return visitor.visitComplexColTypeList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class WhenClauseContext extends antlr.ParserRuleContext {
    public _condition?: ExpressionContext;
    public _result?: ExpressionContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_WHEN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_WHEN, 0)!;
    }
    public KW_THEN(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_THEN, 0)!;
    }
    public expression(): ExpressionContext[];
    public expression(i: number): ExpressionContext | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_whenClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterWhenClause) {
             listener.enterWhenClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitWhenClause) {
             listener.exitWhenClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitWhenClause) {
            return visitor.visitWhenClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class WindowClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_WINDOW(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_WINDOW, 0)!;
    }
    public namedWindow(): NamedWindowContext[];
    public namedWindow(i: number): NamedWindowContext | null;
    public namedWindow(i?: number): NamedWindowContext[] | NamedWindowContext | null {
        if (i === undefined) {
            return this.getRuleContexts(NamedWindowContext);
        }

        return this.getRuleContext(i, NamedWindowContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_windowClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterWindowClause) {
             listener.enterWindowClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitWindowClause) {
             listener.exitWindowClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitWindowClause) {
            return visitor.visitWindowClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class ZorderClauseContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_ZORDER(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_ZORDER, 0)!;
    }
    public KW_BY(): antlr.TerminalNode {
        return this.getToken(SparkSqlParser.KW_BY, 0)!;
    }
    public columnNameSeq(): ColumnNameSeqContext {
        return this.getRuleContext(0, ColumnNameSeqContext)!;
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_zorderClause;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterZorderClause) {
             listener.enterZorderClause(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitZorderClause) {
             listener.exitZorderClause(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitZorderClause) {
            return visitor.visitZorderClause(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class WindowSpecContext extends antlr.ParserRuleContext {
    public _name?: ErrorCapturingIdentifierContext;
    public _expression?: ExpressionContext;
    public _partition: ExpressionContext[] = [];
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public errorCapturingIdentifier(): ErrorCapturingIdentifierContext | null {
        return this.getRuleContext(0, ErrorCapturingIdentifierContext);
    }
    public LEFT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.LEFT_PAREN, 0);
    }
    public RIGHT_PAREN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.RIGHT_PAREN, 0);
    }
    public KW_CLUSTER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_CLUSTER, 0);
    }
    public KW_BY(): antlr.TerminalNode[];
    public KW_BY(i: number): antlr.TerminalNode | null;
    public KW_BY(i?: number): antlr.TerminalNode | null | antlr.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 | null;
    public expression(i?: number): ExpressionContext[] | ExpressionContext | null {
        if (i === undefined) {
            return this.getRuleContexts(ExpressionContext);
        }

        return this.getRuleContext(i, ExpressionContext);
    }
    public windowFrame(): WindowFrameContext | null {
        return this.getRuleContext(0, WindowFrameContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public sortItem(): SortItemContext[];
    public sortItem(i: number): SortItemContext | null;
    public sortItem(i?: number): SortItemContext[] | SortItemContext | null {
        if (i === undefined) {
            return this.getRuleContexts(SortItemContext);
        }

        return this.getRuleContext(i, SortItemContext);
    }
    public KW_PARTITION(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_PARTITION, 0);
    }
    public KW_DISTRIBUTE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_DISTRIBUTE, 0);
    }
    public KW_ORDER(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ORDER, 0);
    }
    public KW_SORT(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_SORT, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_windowSpec;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterWindowSpec) {
             listener.enterWindowSpec(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitWindowSpec) {
             listener.exitWindowSpec(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitWindowSpec) {
            return visitor.visitWindowSpec(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


export class WindowFrameContext extends antlr.ParserRuleContext {
    public _frameType?: Token | null;
    public _start_?: FrameBoundContext;
    public _end?: FrameBoundContext;
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public KW_RANGE(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_RANGE, 0);
    }
    public frameBound(): FrameBoundContext[];
    public frameBound(i: number): FrameBoundContext | null;
    public frameBound(i?: number): FrameBoundContext[] | FrameBoundContext | null {
        if (i === undefined) {
            return this.getRuleContexts(FrameBoundContext);
        }

        return this.getRuleContext(i, FrameBoundContext);
    }
    public KW_ROWS(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_ROWS, 0);
    }
    public KW_BETWEEN(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_BETWEEN, 0);
    }
    public KW_AND(): antlr.TerminalNode | null {
        return this.getToken(SparkSqlParser.KW_AND, 0);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_windowFrame;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterWindowFrame) {
             listener.enterWindowFrame(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitWindowFrame) {
             listener.exitWindowFrame(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitWindowFrame) {
            return visitor.visitWindowFrame(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class QualifiedNameListContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public qualifiedName(): QualifiedNameContext[];
    public qualifiedName(i: number): QualifiedNameContext | null;
    public qualifiedName(i?: number): QualifiedNameContext[] | QualifiedNameContext | null {
        if (i === undefined) {
            return this.getRuleContexts(QualifiedNameContext);
        }

        return this.getRuleContext(i, QualifiedNameContext);
    }
    public COMMA(): antlr.TerminalNode[];
    public COMMA(i: number): antlr.TerminalNode | null;
    public COMMA(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.COMMA);
    	} else {
    		return this.getToken(SparkSqlParser.COMMA, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_qualifiedNameList;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQualifiedNameList) {
             listener.enterQualifiedNameList(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQualifiedNameList) {
             listener.exitQualifiedNameList(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQualifiedNameList) {
            return visitor.visitQualifiedNameList(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


export class QualifiedNameContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public DOT(): antlr.TerminalNode[];
    public DOT(i: number): antlr.TerminalNode | null;
    public DOT(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.DOT);
    	} else {
    		return this.getToken(SparkSqlParser.DOT, i);
    	}
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_qualifiedName;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterQualifiedName) {
             listener.enterQualifiedName(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitQualifiedName) {
             listener.exitQualifiedName(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitQualifiedName) {
            return visitor.visitQualifiedName(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


export class ErrorCapturingIdentifierExtraContext extends antlr.ParserRuleContext {
    public constructor(parent: antlr.ParserRuleContext | null, invokingState: number) {
        super(parent, invokingState);
    }
    public MINUS(): antlr.TerminalNode[];
    public MINUS(i: number): antlr.TerminalNode | null;
    public MINUS(i?: number): antlr.TerminalNode | null | antlr.TerminalNode[] {
    	if (i === undefined) {
    		return this.getTokens(SparkSqlParser.MINUS);
    	} else {
    		return this.getToken(SparkSqlParser.MINUS, i);
    	}
    }
    public identifier(): IdentifierContext[];
    public identifier(i: number): IdentifierContext | null;
    public identifier(i?: number): IdentifierContext[] | IdentifierContext | null {
        if (i === undefined) {
            return this.getRuleContexts(IdentifierContext);
        }

        return this.getRuleContext(i, IdentifierContext);
    }
    public override get ruleIndex(): number {
        return SparkSqlParser.RULE_errorCapturingIdentifierExtra;
    }
    public override enterRule(listener: SparkSqlParserListener): void {
        if(listener.enterErrorCapturingIdentifierExtra) {
             listener.enterErrorCapturingIdentifierExtra(this);
        }
    }
    public override exitRule(listener: SparkSqlParserListener): void {
        if(listener.exitErrorCapturingIdentifierExtra) {
             listener.exitErrorCapturingIdentifierExtra(this);
        }
    }
    public override accept<Result>(visitor: SparkSqlParserVisitor<Result>): Result | null {
        if (visitor.visitErrorCapturingIdentifierExtra) {
            return visitor.visitErrorCapturingIdentifierExtra(this);
        } else {
            return visitor.visitChildren(this);
        }
    }
}


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


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


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


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


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


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


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


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


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


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


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


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